Feature/refactor bundle cache

.github/workflows/ubuntu.yml

@@ -109,7 +109,7 @@ jobs:
           -DRSA_SHM=ON
           -DRSA_REMOTE_SERVICE_ADMIN_SHM_V2=ON
           -DSHELL_BONJOUR=ON
-          -DCMAKE_BUILD_TYPE=Release
+          -DCMAKE_BUILD_TYPE=Debug
       run: |
         mkdir build install
         cd build

CMakeLists.txt

@@ -149,8 +149,8 @@ endif()
 
 # Set build type specific flags
 # Debug
-set(CMAKE_C_FLAGS_DEBUG "-g -DDEBUG -Og ${CMAKE_C_FLAGS}")
-set(CMAKE_CXX_FLAGS_DEBUG "-g -DDEBUG -Og ${CMAKE_CXX_FLAGS}")
+set(CMAKE_C_FLAGS_DEBUG "-g -DDEBUG -O0 ${CMAKE_C_FLAGS}")
+set(CMAKE_CXX_FLAGS_DEBUG "-g -DDEBUG -O0 ${CMAKE_CXX_FLAGS}")
 set(CMAKE_DEBUG_POSTFIX "d")
 
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")

bundles/deployment_admin/src/deployment_admin.c

@@ -32,6 +32,7 @@
 #include <curl/easy.h>
 #include <stdbool.h>
 #include <uuid/uuid.h>
+#include <celix_bundle_context.h>
 
 
 #include "deployment_admin.h"
@@ -581,10 +582,10 @@ celix_status_t deploymentAdmin_updateDeploymentPackageBundles(deployment_admin_p
 		deploymentPackage_getBundle(source, info->symbolicName, &updateBundle);
 		if (updateBundle != NULL) {
 			//printf("Update bundle from: %s\n", bundlePath);
-			bundle_update(updateBundle, bundlePath);
+            celix_bundleContext_updateBundle(admin->context, celix_bundle_getId(updateBundle), bundlePath);
 		} else {
 			//printf("Install bundle from: %s\n", bundlePath);
-			bundleContext_installBundle2(admin->context, bsn, bundlePath, &updateBundle);
+            celix_bundleContext_installBundle(admin->context, bundlePath, false);
 		}
 
         free(entry);
@@ -674,7 +675,7 @@ celix_status_t deploymentAdmin_processDeploymentPackageResources(deployment_admi
 					bundle_getEntry(bundle, "/", &entry);
 					deploymentPackage_getName(source, &name);
 
-					int length = strlen(entry) + strlen(name) + strlen(info->path) + 7;
+					length = strlen(entry) + strlen(name) + strlen(info->path) + 7;
 					char resourcePath[length];
 					snprintf(resourcePath, length, "%srepo/%s/%s", entry, name, info->path);
 					deploymentPackage_getName(source, &packageName);

bundles/http_admin/gtest/CMakeLists.txt

@@ -41,6 +41,7 @@ target_compile_definitions(http_websocket_tests PRIVATE
         HTTP_ADMIN_SUT_BUNDLE="${HTTP_ADMIN_SUT_BUNDLE}"
 )
 target_link_libraries(http_websocket_tests PRIVATE Celix::framework Celix::http_admin_api GTest::gtest GTest::gtest_main)
+add_celix_bundle_dependencies(http_websocket_tests Celix::http_admin http_admin_sut)
 
 add_test(NAME http_websocket_tests COMMAND http_websocket_tests)
 setup_target_for_coverage(http_websocket_tests SCAN_DIR ../http_admin)

bundles/http_admin/gtest/src/http_websocket_tests.cc

@@ -76,7 +76,7 @@ static void checkHttpRequest(const char* req_str, int expectedReturnCode) {
     //If response is successful, check if the received response contains the info we expected
     auto response_info = mg_get_response_info(connection);
     EXPECT_TRUE(response_info != nullptr);
-    EXPECT_EQ(expectedReturnCode, response_info->status_code);
+    EXPECT_EQ(expectedReturnCode, response_info->status_code) << "Unexpected return code for request: " << req_str;
 
     mg_close_connection(connection);
 }

bundles/http_admin/http_admin/CMakeLists.txt

@@ -30,8 +30,6 @@ add_celix_bundle(http_admin
 target_include_directories(http_admin PRIVATE src)
 
 target_link_libraries(http_admin PUBLIC Celix::http_admin_api)
-file(MAKE_DIRECTORY resources)
-celix_bundle_add_dir(http_admin resources/ DESTINATION root/)
 
 celix_deprecated_utils_headers(http_admin)
 

bundles/http_admin/http_admin/src/activator.c

@@ -16,26 +16,18 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/**
- * activator.c
- *
- *  \date       May 24, 2019
- *  \author     <a href="mailto:[email protected]">Apache Celix Project Team</a>
- *  \copyright  Apache License, Version 2.0
- */
 
 #include <stdlib.h>
 #include <memory.h>
 
 #include "celix_api.h"
 #include "celix_types.h"
-
 #include "http_admin.h"
 #include "websocket_admin.h"
-
 #include "http_admin/api.h"
 #include "http_admin_constants.h"
 #include "civetweb.h"
+#include "celix_file_utils.h"
 
 
 typedef struct http_admin_activator {
@@ -52,7 +44,28 @@ typedef struct http_admin_activator {
 
 static int http_admin_start(http_admin_activator_t *act, celix_bundle_context_t *ctx) {
     celix_bundle_t *bundle = celix_bundleContext_getBundle(ctx);
-    char* root = celix_bundle_getEntry(bundle, "root");
+    char* storeRoot = celix_bundle_getDataFile(bundle, "");
+    if (storeRoot == NULL) {
+        celix_bundleContext_log(ctx, CELIX_LOG_LEVEL_ERROR, "Cannot get bundle store root for the http admin bundle.");
+        return CELIX_BUNDLE_EXCEPTION;
+    }
+
+    char* httpRoot = NULL;
+    int rc = asprintf(&httpRoot, "%s/root", storeRoot);
+    if (rc < 0) {
+        celix_bundleContext_log(ctx, CELIX_LOG_LEVEL_ERROR, "Cannot create http root directory for the http admin bundle.");
+        free(storeRoot);
+        return CELIX_ENOMEM;
+    }
+    free(storeRoot);
+
+    celix_status_t status = celix_utils_createDirectory(httpRoot, false, NULL);
+    if (status != CELIX_SUCCESS) {
+        celix_bundleContext_log(ctx, CELIX_LOG_LEVEL_ERROR, "Cannot create http root directory for the http admin bundle.");
+        free(httpRoot);
+        return status;
+    }
+    celix_bundleContext_log(ctx, CELIX_LOG_LEVEL_DEBUG, "Using http root directory %s", httpRoot);
 
     bool prop_use_websockets = celix_bundleContext_getPropertyAsBool(ctx, HTTP_ADMIN_USE_WEBSOCKETS_KEY, HTTP_ADMIN_USE_WEBSOCKETS_DFT);
     long listPort = celix_bundleContext_getPropertyAsLong(ctx,    HTTP_ADMIN_LISTENING_PORTS_KEY, HTTP_ADMIN_LISTENING_PORTS_DFT);
@@ -72,22 +85,22 @@ static int http_admin_start(http_admin_activator_t *act, celix_bundle_context_t
     act->useWebsockets = prop_use_websockets;
 
     const char *svr_opts[] = {
-            "document_root", root,
+            "document_root", httpRoot,
             "listening_ports", prop_port,
             "websocket_timeout_ms", prop_timeout,
-            "websocket_root", root,
+            "websocket_root", httpRoot,
             "num_threads", prop_num_threads,
             NULL
     };
 
     //Try the 'LISTENING_PORT' property first, if failing continue with the port range functionality
-    act->httpManager = httpAdmin_create(ctx, root, svr_opts);
+    act->httpManager = httpAdmin_create(ctx, httpRoot, svr_opts);
 
     for(long port = prop_port_min; act->httpManager == NULL && port <= prop_port_max; port++) {
         char *port_str;
         asprintf(&port_str, "%li", port);
         svr_opts[3] = port_str;
-        act->httpManager = httpAdmin_create(ctx, root, svr_opts);
+        act->httpManager = httpAdmin_create(ctx, httpRoot, svr_opts);
         free(port_str);
     }
 

bundles/http_admin/http_admin/src/http_admin.c

@@ -16,13 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/**
- * http_admin.c
- *
- *  \date       May 24, 2019
- *  \author     <a href="mailto:[email protected]">Apache Celix Project Team</a>
- *  \copyright  Apache License, Version 2.0
- */
 
 #include <stdlib.h>
 #include <memory.h>
@@ -480,33 +473,22 @@ static bool aliasList_containsAlias(celix_array_list_t *alias_list, const char *
 }
 
 void http_admin_startBundle(void *data, const celix_bundle_t *bundle) {
-    bundle_archive_pt archive = NULL;
-    bundle_revision_pt revision = NULL;
-    manifest_pt manifest = NULL;
-
     http_admin_manager_t *admin = data;
-
-    // Retrieve manifest from current bundle revision (retrieve revision from bundle archive) to check for
-    // Amdatu pattern manifest property X-Web-Resource. This property is used for aliases.
-    celix_status_t status = bundle_getArchive((celix_bundle_t*)bundle, &archive);
-    if(status == CELIX_SUCCESS && archive != NULL) {
-        status = bundleArchive_getCurrentRevision(archive, &revision);
+    const char* aliases = celix_bundle_getManifestValue(bundle, "X-Web-Resource");
+    if (aliases == NULL) {
+        celix_bundleContext_log(admin->context, CELIX_LOG_LEVEL_TRACE, "No aliases found for bundle %s",
+                                celix_bundle_getSymbolicName(bundle));
+        return;
     }
-
-    if(status == CELIX_SUCCESS && revision != NULL) {
-        status = bundleRevision_getManifest(revision, &manifest);
-    }
-
-    if(status == CELIX_SUCCESS && manifest != NULL) {
-        const char *aliases = NULL;
-        const char *revision_root = NULL;
-        long bnd_id;
-
-        aliases = manifest_getValue(manifest, "X-Web-Resource");
-        bnd_id = celix_bundle_getId(bundle);
-        bundleRevision_getRoot(revision, &revision_root);
-        createAliasesSymlink(aliases, admin->root, revision_root, bnd_id, admin->aliasList);
+    char* bundleRoot = celix_bundle_getEntry(bundle, "");
+    if (bundleRoot == NULL) {
+        celix_bundleContext_log(admin->context, CELIX_LOG_LEVEL_ERROR, "No root for bundle %s",
+                                celix_bundle_getSymbolicName(bundle));
+        return;
     }
+    long bndId = celix_bundle_getId(bundle);
+    createAliasesSymlink(aliases, admin->root, bundleRoot, bndId, admin->aliasList);
+    free(bundleRoot);
     httpAdmin_updateInfoSvc(admin);
 }
 

bundles/http_admin/http_admin/src/websocket_admin.c

@@ -16,13 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/**
- * websocket_admin.c
- *
- *  \date       May 24, 2019
- *  \author     <a href="mailto:[email protected]">Apache Celix Project Team</a>
- *  \copyright  Apache License, Version 2.0
- */
 
 #include <stdlib.h>
 #include <memory.h>

bundles/remote_services/remote_service_admin_shm_v2/rsa_shm/gtest/CMakeLists.txt

@@ -51,5 +51,8 @@ celix_get_bundle_file(Celix::rsa_discovery RSA_DISCOVERY_BUNDLE_FILE)
 configure_file(resources/client.properties.in client.properties)
 configure_file(resources/server.properties.in server.properties)
 
+
+add_celix_bundle_dependencies(test_rsa_shm Celix::rsa_shm Celix::rsa_json_rpc calculator_shell calculator)
+
 add_test(NAME run_test_rsa_shm COMMAND test_rsa_shm)
 setup_target_for_coverage(test_rsa_shm SCAN_DIR ..)

bundles/remote_services/topology_manager/tms_tst/CMakeLists.txt

@@ -42,7 +42,7 @@ target_link_libraries(test_tm_scoped PRIVATE
         Celix::rsa_common
 )
 
-add_celix_bundle_dependencies(test_tm_scoped Celix::rsa_dfi Celix::rsa_topology_manager)
+add_celix_bundle_dependencies(test_tm_scoped Celix::rsa_dfi Celix::rsa_topology_manager calculator topology_manager_disc_mock_bundle topology_manager_test_bundle)
 
 file(GENERATE 
     OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/config.properties"

bundles/shell/shell/CMakeLists.txt

@@ -46,7 +46,7 @@ if (SHELL)
 			src/query_command.c
 			src/quit_command.c
 			src/std_commands.c
-	)
+			src/bundle_command.c)
 	target_include_directories(shell_commands PRIVATE src)
 	target_link_libraries(shell_commands PRIVATE Celix::shell_api Celix::log_helper)
 	celix_deprecated_utils_headers(shell_commands)

bundles/shell/shell/gtest/src/ShellTestSuite.cc

@@ -78,9 +78,9 @@ static void callCommand(std::shared_ptr<celix_bundle_context_t>& ctx, const char
         EXPECT_TRUE(shell != nullptr);
         celix_status_t status = shell->executeCommand(shell->handle, d->cmdLine, stdout, stderr);
         if (d->cmdShouldSucceed) {
-            EXPECT_EQ(CELIX_SUCCESS, status);
+            EXPECT_EQ(CELIX_SUCCESS, status) << "Command '" << d->cmdLine << "' should succeed";
         } else {
-            EXPECT_TRUE(status != CELIX_SUCCESS);
+            EXPECT_NE(CELIX_SUCCESS, status) << "Command '" << d->cmdLine << "' should not succeed";
         }
     };
     bool called = celix_bundleContext_useServiceWithOptions(ctx.get(), &opts);
@@ -98,10 +98,18 @@ TEST_F(ShellTestSuite, testAllCommandsAreCallable) {
     callCommand(ctx, "lb -l", true);
     callCommand(ctx, "query", true);
     callCommand(ctx, "q -v", true);
-    callCommand(ctx, "stop 15", false);
-    callCommand(ctx, "start 15", false);
-    callCommand(ctx, "uninstall 15", false);
-    callCommand(ctx, "update 15", false);
+    callCommand(ctx, "stop not-a-number", false);
+    callCommand(ctx, "stop", false); // incorrect number of arguments
+    callCommand(ctx, "start not-a-number", false);
+    callCommand(ctx, "start", false); // incorrect number of arguments
+    callCommand(ctx, "uninstall not-a-number", false);
+    callCommand(ctx, "uninstall", false); // incorrect number of arguments
+    callCommand(ctx, "update not-a-number", false);
+    callCommand(ctx, "update", false); // incorrect number of arguments
+    callCommand(ctx, "stop 15", false); //non existing bundle id
+    callCommand(ctx, "start 15", false); //non existing bundle id
+    callCommand(ctx, "uninstall 15", false); //non existing bundle id
+    callCommand(ctx, "update 15", false); //non existing bundle id
 }
 
 TEST_F(ShellTestSuite, quitTest) {

bundles/shell/shell/src/bundle_command.c

@@ -0,0 +1,72 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+ */
+
+#include "bundle_command.h"
+#include "celix_bundle_context.h"
+#include "celix_convert_utils.h"
+#include "celix_utils.h"
+#include <stdlib.h>
+#include <string.h>
+
+bool bundleCommand_execute(void *handle, const char *constCommandLine, FILE *outStream, FILE *errStream, bundle_control_fpt ctrl) {
+    celix_bundle_context_t *ctx = handle;
+
+    char* sub = NULL;
+    char* savePtr = NULL;
+    char* command = celix_utils_strdup(constCommandLine);
+    strtok_r(command, OSGI_SHELL_COMMAND_SEPARATOR, &savePtr); //ignore command name
+    sub = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &savePtr);
+    celix_array_list_t* bundleIds = celix_arrayList_create();
+    bool validArgs = true;
+
+    if (sub == NULL) {
+        fprintf(errStream, "Incorrect number of arguments.\n");
+        validArgs = false;
+    }
+
+    for (; sub != NULL; sub = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &savePtr)) {
+        bool converted;
+        long bndId = celix_utils_convertStringToLong(sub, 0, &converted);
+        if (!converted) {
+            validArgs = false;
+            fprintf(errStream, "Cannot convert '%s' to long (bundle id).\n", sub);
+            continue;
+        }
+        if (!celix_bundleContext_isBundleInstalled(ctx, bndId)) {
+            validArgs = false;
+            fprintf(outStream, "No bundle with id %li.\n", bndId);
+            continue;
+        }
+        celix_arrayList_addLong(bundleIds, bndId);
+    }
+    free(command);
+
+    if (!validArgs) {
+        goto cleanup;
+    }
+    for (int i = 0; i < celix_arrayList_size(bundleIds); i++) {
+        long bndId = celix_arrayList_getLong(bundleIds, i);
+        celix_framework_t* fw = celix_bundleContext_getFramework(ctx);
+        ctrl(fw, bndId);
+    }
+
+cleanup:
+    celix_arrayList_destroy(bundleIds);
+    return validArgs;
+}