Feature/556 osgi uninstall

bundles/pubsub/integration/gtest/tst_activator.c

@@ -55,21 +55,21 @@ celix_status_t bnd_start(struct activator *act, celix_bundle_context_t *ctx) {
         celix_properties_set(props, PUBSUB_SUBSCRIBER_TOPIC, "ping");
         act->subSvc1.handle = act;
         act->subSvc1.receive = tst_receive;
-        act->subSvcId1 = celix_bundleContext_registerService(ctx, &act->subSvc1, PUBSUB_SUBSCRIBER_SERVICE_NAME, props);
+        act->subSvcId1 = celix_bundleContext_registerServiceAsync(ctx, &act->subSvc1, PUBSUB_SUBSCRIBER_SERVICE_NAME, props);
     }
 
     {
         celix_properties_t *props = celix_properties_create();
         celix_properties_set(props, PUBSUB_SUBSCRIBER_TOPIC, "ping");
         act->subSvc2.handle = act;
         act->subSvc2.receive = tst_receive2;
-        act->subSvcId2 = celix_bundleContext_registerService(ctx, &act->subSvc2, PUBSUB_SUBSCRIBER_SERVICE_NAME, props);
+        act->subSvcId2 = celix_bundleContext_registerServiceAsync(ctx, &act->subSvc2, PUBSUB_SUBSCRIBER_SERVICE_NAME, props);
     }
 
     {
         act->countSvc.handle = act;
         act->countSvc.receiveCount = tst_count;
-        act->countSvcId = celix_bundleContext_registerService(ctx, &act->countSvc, CELIX_RECEIVE_COUNT_SERVICE_NAME, NULL);
+        act->countSvcId = celix_bundleContext_registerServiceAsync(ctx, &act->countSvc, CELIX_RECEIVE_COUNT_SERVICE_NAME, NULL);
     }
 
     return CELIX_SUCCESS;

bundles/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c

@@ -1344,7 +1344,7 @@ static celix_status_t pubsub_topologyManager_metrics(pubsub_topology_manager_t *
                 if (sm->msgMetrics[j].nrOfMessagesSend == 0 && sm->msgMetrics[j].nrOfMessagesSendFailed == 0 && sm->msgMetrics[j].nrOfSerializationErrors == 0) {
                     continue;
                 }
-                const char *bndName = NULL;
+                const char *bndName = "inactive";
                 celix_bundleContext_useBundle(manager->context, sm->msgMetrics->bndId, &bndName, fetchBundleName);
                 fprintf(os, "   |- Message '%s' from bundle '%s' (%li):\n", sm->msgMetrics[j].typeFqn, bndName, sm->msgMetrics->bndId);
                 fprintf(os, "      |- msg type = 0x%X\n", sm->msgMetrics[j].typeId);

bundles/remote_services/remote_service_admin_dfi/CMakeLists.txt

@@ -33,7 +33,6 @@ if (RSA_REMOTE_SERVICE_ADMIN_DFI)
             src/export_registration_dfi.c
             src/import_registration_dfi.c
             )
-    celix_bundle_private_libs(rsa_dfi Celix::dfi)
     target_link_libraries(rsa_dfi PRIVATE
             Celix::rsa_dfi_utils
             Celix::dfi

bundles/remote_services/rsa_rpc_json/CMakeLists.txt

@@ -58,7 +58,6 @@ if (RSA_JSON_RPC)
     add_library(Celix::rsa_json_rpc ALIAS rsa_json_rpc)
 
     if (ENABLE_TESTING)
-        celix_bundle_private_libs(rsa_json_rpc Celix::dfi)
         add_library(rsa_json_rpc_cut STATIC ${RSA_JSON_RPC_SRC})
         celix_deprecated_utils_headers(rsa_json_rpc_cut)
         target_include_directories(rsa_json_rpc_cut PUBLIC src)

bundles/shell/shell/CMakeLists.txt

@@ -41,6 +41,7 @@ if (SHELL)
 			src/install_command.c
 			src/update_command.c
 			src/uninstall_command.c
+			src/unload_command.c
 			src/help_command.c
 			src/dm_shell_list_command.c
 			src/query_command.c

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

@@ -104,11 +104,14 @@ TEST_F(ShellTestSuite, testAllCommandsAreCallable) {
     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, "unload not-a-number", false);
+    callCommand(ctx, "unload", 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, "unload 15", false); //non existing bundle id
     callCommand(ctx, "update 15", false); //non existing bundle id
 }
 

bundles/shell/shell/src/query_command.c

@@ -20,6 +20,7 @@
 #include <string.h>
 #include <stdlib.h>
 
+#include "celix_framework.h"
 #include "celix_shell_constants.h"
 #include "celix_bundle_context.h"
 #include "std_commands.h"
@@ -129,7 +130,7 @@ static void queryCommand_callback(void *handle, const celix_bundle_t *bnd) {
 
 
 static void queryCommand_listServicesForBundle(celix_bundle_context_t *ctx, long bndId, struct bundle_callback_data *data, const struct query_options *opts, FILE *sout, FILE *serr) {
-    bool called = celix_bundleContext_useBundle(ctx, bndId, data, queryCommand_callback);
+    bool called = celix_framework_useBundle(celix_bundleContext_getFramework(ctx), true, bndId, data, queryCommand_callback);
     if (!called) {
         fprintf(serr, "Bundle %li not installed!", bndId);
     }

bundles/shell/shell/src/std_commands.c

@@ -82,7 +82,7 @@ celix_std_commands_t* celix_stdCommands_create(celix_bundle_context_t* ctx) {
                     .exec = uninstallCommand_execute,
                     .name = "celix::uninstall",
                     .description = "uninstall bundle(s).",
-                    .usage = "uninstall <file> [<file> ...]"
+                    .usage = "uninstall <id> [<id> ...]"
             };
     commands->std_commands[5] =
             (struct celix_shell_command_register_entry) {
@@ -133,6 +133,13 @@ celix_std_commands_t* celix_stdCommands_create(celix_bundle_context_t* ctx) {
                     .usage = "quit"
             };
     commands->std_commands[11] =
+        (struct celix_shell_command_register_entry) {
+            .exec = unloadCommand_execute,
+            .name = "celix::unload",
+            .description = "unload bundle(s).",
+            .usage = "unload <id> [<id> ...]"
+        };
+    commands->std_commands[12] =
             (struct celix_shell_command_register_entry) {
                     .exec = NULL
             };

bundles/shell/shell/src/std_commands.h

@@ -48,6 +48,8 @@ bool installCommand_execute(void *handle, const char *commandLine, FILE *outStre
 
 bool uninstallCommand_execute(void *handle, const char *commandLine, FILE *outStream, FILE *errStream);
 
+bool unloadCommand_execute(void *handle, const char *commandLine, FILE *outStream, FILE *errStream);
+
 bool updateCommand_execute(void *handle, const char *commandLine, FILE *outStream, FILE *errStream);
 
 bool helpCommand_execute(void *handle, const char *commandLine, FILE *outStream, FILE *errStream);

bundles/shell/shell/src/unload_command.c

@@ -0,0 +1,24 @@
+/*
+ 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"
+
+bool unloadCommand_execute(void *handle, const char* constCommandLine, FILE *outStream, FILE *errStream) {
+    return bundleCommand_execute(handle, constCommandLine, outStream, errStream, celix_framework_unloadBundleAsync);
+}

cmake/cmake_celix/BundlePackaging.cmake

@@ -266,8 +266,9 @@ function(add_celix_bundle)
         )
     endif()
     add_custom_target(${BUNDLE_TARGET_NAME}_bundle
-        DEPENDS ${BUNDLE_TARGET_NAME} "$<TARGET_PROPERTY:${BUNDLE_TARGET_NAME},BUNDLE_FILE>"
+        DEPENDS "$<TARGET_PROPERTY:${BUNDLE_TARGET_NAME},BUNDLE_FILE>"
     )
+    add_dependencies(${BUNDLE_TARGET_NAME}_bundle ${BUNDLE_TARGET_NAME})
     add_dependencies(celix-bundles ${BUNDLE_TARGET_NAME}_bundle)
     #######################################################################
 
@@ -317,13 +318,13 @@ function(add_celix_bundle)
     ###################################
     ##### Additional Cleanup info #####
     ###################################
-    set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "$<TARGET_PROPERTY:${BUNDLE_TARGET_NAME},BUNDLE_GEN_DIR>;$<TARGET_PROPERTY:${BUNDLE_TARGET_NAME},BUNDLE_CONTENT_DIR>")
+    set_target_properties(${BUNDLE_TARGET_NAME}_bundle PROPERTIES "ADDITIONAL_CLEAN_FILES" "$<TARGET_PROPERTY:${BUNDLE_TARGET_NAME},BUNDLE_GEN_DIR>;$<TARGET_PROPERTY:${BUNDLE_TARGET_NAME},BUNDLE_CONTENT_DIR>")
 
     #############################
     ### BUNDLE TARGET PROPERTIES
     #############################
     #already set
-    #   BUNDLE_TARGET_IS_LIB -> true (can be use to test if target is bundle target
+    #   BUNDLE_TARGET_IS_LIB -> true (can be use to test if target is library target
     #   BUNDLE_TARGET -> refers to the _bundle target which is responsible for building the zip file
     #internal use
     set_target_properties(${BUNDLE_TARGET_NAME} PROPERTIES "BUNDLE_IS_BUNDLE_TARGET" TRUE) #indicate that this is a bundle target
@@ -356,7 +357,6 @@ function(add_celix_bundle)
     if(BUNDLE_SOURCES) 
         celix_bundle_libs(${BUNDLE_TARGET_NAME} "PRIVATE" TRUE ${BUNDLE_TARGET_NAME})
         set_target_properties(${BUNDLE_TARGET_NAME} PROPERTIES "BUNDLE_ACTIVATOR" "$<TARGET_SONAME_FILE_NAME:${BUNDLE_TARGET_NAME}>")
-        set_target_properties(${BUNDLE_TARGET_NAME} PROPERTIES "BUILD_WITH_INSTALL_RPATH" true)
 
         if(APPLE)
             set_target_properties(${BUNDLE_TARGET_NAME} PROPERTIES INSTALL_RPATH "@loader_path")
@@ -459,7 +459,7 @@ function(celix_bundle_libs)
     #0 is bundle TARGET
     #1 is TYPE, e.g PRIVATE,EXPORT or IMPORT
     #2 is ADD_TO_MANIFEST 
-    #2..n is libs
+    #3..n is libs
     list(GET ARGN 0 BUNDLE)
     list(REMOVE_AT ARGN 0)
 
@@ -484,7 +484,8 @@ function(celix_bundle_libs)
             get_filename_component(LIB_NAME ${LIB} NAME) 
             set(OUT "${BUNDLE_DIR}/${LIB_NAME}") 
             add_custom_command(OUTPUT ${OUT} 
-                COMMAND ${CMAKE_COMMAND} -E copy_if_different ${LIB} ${OUT} 
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different ${LIB} ${OUT}
+                DEPENDS ${LIB}
             )
             if (ADD_TO_MANIFEST)
                 list(APPEND LIBS ${LIB_NAME})
@@ -520,7 +521,7 @@ function(celix_bundle_libs)
 
         get_target_property(IS_LIB ${BUNDLE} "BUNDLE_TARGET_IS_LIB")
         if ("${LIB}" STREQUAL "${BUNDLE}")
-            #ignore. Do not have to link agaist own lib
+            #ignore. Do not have to link against itself
         elseif(IS_LIB)
             target_link_libraries(${BUNDLE} PRIVATE ${LIB})
         endif()
@@ -551,7 +552,6 @@ function(celix_bundle_import_libs)
     check_bundle(${BUNDLE})
 
     get_target_property(LIBS ${BUNDLE} "BUNDLE_IMPORT_LIBS")
-    set(LIBS )
 
     foreach(LIB IN ITEMS ${ARGN})
         message(WARNING "Bundle with import libs in Celix is not complete and still experimental.")
@@ -662,18 +662,18 @@ function(celix_bundle_add_dir)
     if (NOT DEFINED COPY_DESTINATION)
         set(DESTINATION "${BUNDLE_DIR}")
     else()
-	set(DESTINATION "${BUNDLE_DIR}/${COPY_DESTINATION}")
+        set(DESTINATION "${BUNDLE_DIR}/${COPY_DESTINATION}")
     endif()
 
     string(UUID COPY_ID NAMESPACE "661ee07c-842d-11e8-adfc-80fa5b02e11b" NAME "${INPUT_DIR}" TYPE MD5)
 
     set(COPY_CMAKE_SCRIPT "${CMAKE_BINARY_DIR}/celix/gen/bundles/${BUNDLE}/copy-dir-${COPY_ID}.cmake")
     if (IS_ABSOLUTE ${INPUT_DIR})
-	    file(WRITE ${COPY_CMAKE_SCRIPT}
-		    "file(COPY ${INPUT_DIR} DESTINATION ${DESTINATION})")
+        file(WRITE ${COPY_CMAKE_SCRIPT}
+                "file(COPY ${INPUT_DIR} DESTINATION ${DESTINATION})")
     else()
-	    file(WRITE ${COPY_CMAKE_SCRIPT}
-		    "file(COPY ${CMAKE_CURRENT_LIST_DIR}/${INPUT_DIR} DESTINATION ${DESTINATION})")
+        file(WRITE ${COPY_CMAKE_SCRIPT}
+                "file(COPY ${CMAKE_CURRENT_LIST_DIR}/${INPUT_DIR} DESTINATION ${DESTINATION})")
     endif()
 
     set(TIMESTAMP "${CMAKE_BINARY_DIR}/celix/gen/bundles/${BUNDLE}/copy-dir-${COPY_ID}.timestamp")
@@ -683,15 +683,15 @@ function(celix_bundle_add_dir)
             COMMAND ${CMAKE_COMMAND} -P ${COPY_CMAKE_SCRIPT}
             DEPENDS ${DIR_FILES}
             COMMENT "Copying dir ${INPUT_DIR} to ${DESTINATION}"
-    )
+            )
 
     get_target_property(DEPS ${BUNDLE} "BUNDLE_DEPEND_TARGETS")
     list(APPEND DEPS "${TIMESTAMP}")
     set_target_properties(${BUNDLE} PROPERTIES "BUNDLE_DEPEND_TARGETS" "${DEPS}")
 endfunction()
 
 #[[
-Copy to the content of a directory to a bundle.
+Copy specified files to a bundle.
 
 ```CMake
 celix_bundle_add_files(<bundle_target>
@@ -725,29 +725,29 @@ function(celix_bundle_add_files)
     if (NOT DEFINED COPY_DESTINATION)
         set(DESTINATION "${BUNDLE_DIR}")
     else()
-	set(DESTINATION "${BUNDLE_DIR}/${COPY_DESTINATION}")
+        set(DESTINATION "${BUNDLE_DIR}/${COPY_DESTINATION}")
     endif()
 
     string(UUID COPY_ID NAMESPACE "661ee07c-842d-11e8-adfc-80fa5b02e11b" NAME "${COPY_FILES}" TYPE MD5)
 
     set(TIMESTAMP "${CMAKE_BINARY_DIR}/celix/gen/bundles/${BUNDLE}/copy-files-${COPY_ID}.timestamp")
     set(COPY_CMAKE_SCRIPT "${CMAKE_BINARY_DIR}/celix/gen/bundles/${BUNDLE}/copy-files-${COPY_ID}.cmake")
     file(WRITE ${COPY_CMAKE_SCRIPT}
-	    "#Copy script, copies the file on a file per file base\n")
+            "#Copy script, copies the file on a file per file base\n")
     foreach(FILE IN ITEMS ${COPY_FILES})
-	    if (IS_ABSOLUTE ${FILE})
-	    	file(APPEND ${COPY_CMAKE_SCRIPT}
-			"file(COPY ${FILE} DESTINATION ${DESTINATION})\n")
-	    else()
-	    	file(APPEND ${COPY_CMAKE_SCRIPT}
-			"file(COPY ${CMAKE_CURRENT_LIST_DIR}/${FILE} DESTINATION ${DESTINATION})\n")
-	    endif()
+        if (IS_ABSOLUTE ${FILE})
+            file(APPEND ${COPY_CMAKE_SCRIPT}
+                    "file(COPY ${FILE} DESTINATION ${DESTINATION})\n")
+        else()
+            file(APPEND ${COPY_CMAKE_SCRIPT}
+                    "file(COPY ${CMAKE_CURRENT_LIST_DIR}/${FILE} DESTINATION ${DESTINATION})\n")
+        endif()
     endforeach()
     add_custom_command(OUTPUT ${TIMESTAMP}
             COMMAND ${CMAKE_COMMAND} -E touch ${TIMESTAMP}
             COMMAND ${CMAKE_COMMAND} -P ${COPY_CMAKE_SCRIPT}
-	        DEPENDS ${COPY_FILES}
-	        COMMENT "Copying files to ${DESTINATION}"
+            DEPENDS ${COPY_FILES}
+            COMMENT "Copying files to ${DESTINATION}"
     )
 
     get_target_property(DEPS ${BUNDLE} "BUNDLE_DEPEND_TARGETS")
@@ -835,7 +835,7 @@ endfunction()
 
 function(bundle_name)
     message(DEPRECATION "bundle_name is deprecated, use celix_bundle_name instead.")
-    celix_bundle_symbolic_name(${ARGN})
+    celix_bundle_name(${ARGN})
 endfunction()
 
 #[[
@@ -851,7 +851,7 @@ endfunction()
 
 function(bundle_version)
     message(DEPRECATION "bundle_version is deprecated, use celix_bundle_version instead.")
-    celix_bundle_symbolic_name(${ARGN})
+    celix_bundle_version(${ARGN})
 endfunction()
 
 #[[
@@ -867,7 +867,7 @@ endfunction()
 
 function(bundle_description)
     message(DEPRECATION "bundle_description is deprecated, use celix_bundle_description instead.")
-    celix_bundle_symbolic_name(${ARGN})
+    celix_bundle_description(${ARGN})
 endfunction()
 
 #[[
@@ -911,6 +911,9 @@ function(celix_get_bundle_filename)
         if (_IMP)
             _celix_extract_imported_bundle_info(${ARGV0})
             set(${ARGV1} ${BUNDLE_FILENAME} PARENT_SCOPE)
+            unset(BUNDLE_FILE)
+            unset(BUNDLE_FILENAME)
+            unset(BUNDLE_SYMBOLIC_NAME)
         else ()
             get_target_property(BF ${ARGV0} BUNDLE_FILENAME)
             set(${ARGV1} ${BF} PARENT_SCOPE)
@@ -942,6 +945,7 @@ function(celix_get_bundle_file)
             set(${ARGV1} ${BUNDLE_FILE} PARENT_SCOPE)
             unset(BUNDLE_FILE)
             unset(BUNDLE_FILENAME)
+            unset(BUNDLE_SYMBOLIC_NAME)
         else ()
             get_target_property(BF ${ARGV0} BUNDLE_FILE)
             set(${ARGV1} ${BF} PARENT_SCOPE)
@@ -1028,7 +1032,7 @@ endfunction()
 
 #[[
 Generate and install a Celix Targets cmake file which contains CMake commands to create imported targets for the bundles
-install using the provided <export_name>. These imported CMake targets can be used in in CMake project using the installed
+install using the provided <export_name>. These imported CMake targets can be used in CMake project using the installed
 bundles.
 
 ```CMake
@@ -1037,6 +1041,7 @@ install_celix_targets(<export_name>
     [FILE <celix_target_filename>]
     [PROJECT_NAME <project_name>]
     [DESTINATION <celix_targets_destination>]
+    [COMPONENT <component>]
 )
 ```
 
@@ -1049,6 +1054,7 @@ Optional Arguments:
 - FILE: The Celix Targets cmake filename to used, without the cmake extension. Default is <export_name>BundleTargets
 - PROJECT_NAME: The project name to used for the share location. Default is the cmake project name.
 - DESTINATION: The (relative) location to install the Celix Targets cmake file to. Default is share/<PROJECT_NAME>/cmake.
+- COMPONENT: Specify an installation component name with which the install rule is associated.
 ]]
 
 function(install_celix_bundle_targets)
@@ -1136,7 +1142,7 @@ set_target_properties(${TN} PROPERTIES
     file(GENERATE OUTPUT "${CONF_FILE}" INPUT "${CONF_IN_FILE}")
 
 
-    #Generate not build type specific targets file
+    #Generate build-type independent targets file
     set(GENERIC_CONF_FILE "${CMAKE_BINARY_DIR}/celix/gen/cmake/${EXPORT_NAME}-BundleTargets.cmake")
     file(GENERATE OUTPUT ${GENERIC_CONF_FILE} CONTENT "
 # Load bundle information for each installed configuration.
@@ -1161,7 +1167,7 @@ endfunction()
 
 
 #[[
-extract the BUNDLE_FILENAME and BUNDLE_FILE from a imported bundle target taking into account the used CMAKE_BUILD_TYPE
+extract the BUNDLE_FILENAME, BUNDLE_FILE, and BUNDLE_SYMBOLIC_NAME from a imported bundle target taking into account the used CMAKE_BUILD_TYPE
 and if configured the MAP_IMPORTED_CONFIG_* or CMAKE_MAP_IMPORTED_CONFIG_*
 
 ```CMake