celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [1/3] celix git commit: CELIX-412: add celix_ version for bundle and container CMake commands
Date Tue, 16 Jan 2018 15:24:37 GMT
Repository: celix
Updated Branches:
  refs/heads/release/2.1.0 f32363ac0 -> 68775a042


CELIX-412: add celix_ version for bundle and container CMake commands


Project: http://git-wip-us.apache.org/repos/asf/celix/repo
Commit: http://git-wip-us.apache.org/repos/asf/celix/commit/ee29b00d
Tree: http://git-wip-us.apache.org/repos/asf/celix/tree/ee29b00d
Diff: http://git-wip-us.apache.org/repos/asf/celix/diff/ee29b00d

Branch: refs/heads/release/2.1.0
Commit: ee29b00d7a80af43d351e61916d5a5aa90f97e46
Parents: f32363a
Author: Pepijn Noltes <pepijnnoltes@gmail.com>
Authored: Tue Jan 16 16:12:08 2018 +0100
Committer: Pepijn Noltes <pepijnnoltes@gmail.com>
Committed: Tue Jan 16 16:12:08 2018 +0100

----------------------------------------------------------------------
 CMakeLists.txt                          |   2 -
 cmake/cmake_celix/BundlePackaging.cmake |  84 ++++++++++++-----
 cmake/cmake_celix/DeployPackaging.cmake |  39 ++++++--
 documents/cmake_commands/readme.md      | 135 +++++++++++++--------------
 4 files changed, 160 insertions(+), 100 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/celix/blob/ee29b00d/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/CMakeLists.txt b/CMakeLists.txt
index dec1dff..2fbf62d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,7 +26,6 @@ include(GNUInstallDirs)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")
 
 #Setup vars conform the FindCelix setup, so that examples and supporting cmake command can
assume these variables are set
-#TODO move this to a seperate cmake file or integrate in the FindCelix.cmake file
 set(CELIX_FOUND true)
 set(CELIX_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/framework/public/include ${CMAKE_SOURCE_DIR}/utils/public/include)
 set(CELIX_LIBRARIES celix_framework celix_utils celix_dfi)
@@ -34,7 +33,6 @@ set(CELIX_LAUNCHER celix)
 set(CELIX_FRAMEWORK_LIBRARY celix_framework)
 set(CELIX_UTILS_LIBRARY celix_utils)
 set(CELIX_DFI_LIBRARY celix_dfi)
-#TODO CELIX_BUNDLES_DIR this will not work, maybe only use var (e.g. ${CELIX_SHELL_BUNDLE})
for bundles
 set(CELIX_DM_LIB dependency_manager_so)
 set(CELIX_DM_STATIC_LIB dependency_manager_static)
 set(CELIX_DM_STATIC_CXX_LIB dependency_manager_cxx_static)

http://git-wip-us.apache.org/repos/asf/celix/blob/ee29b00d/cmake/cmake_celix/BundlePackaging.cmake
----------------------------------------------------------------------
diff --git a/cmake/cmake_celix/BundlePackaging.cmake b/cmake/cmake_celix/BundlePackaging.cmake
index 992e88e..f3adde3 100644
--- a/cmake/cmake_celix/BundlePackaging.cmake
+++ b/cmake/cmake_celix/BundlePackaging.cmake
@@ -30,7 +30,7 @@ endif()
 
 
 ##### setup bundles/deploy target
-add_custom_target(bundles ALL)
+add_custom_target(celix-bundles ALL)
 #####
 
 macro(extract_version_parts VERSION MAJOR MINOR PATCH)
@@ -88,8 +88,11 @@ function(check_bundle BUNDLE)
     endif()
 endfunction()
 
-
 function(add_bundle)
+    #message(DEPRECATION"add_bundle is DEPRECATION, use add_celix_bundle instead.")
+    add_celix_bundle(${ARGN})
+endfunction()
+function(add_celix_bundle)
     list(GET ARGN 0 BUNDLE_TARGET_NAME)
     list(REMOVE_AT ARGN 0)
 
@@ -130,9 +133,9 @@ function(add_bundle)
 
 
     ###### Setting up dependency for bundles target
-    get_target_property(DEPS bundles "BUNDLES_DEPS")
+    get_target_property(DEPS celix-bundles "BUNDLES_DEPS")
     list(APPEND DEPS "${BUNDLE_FILE}")
-    set_target_properties(bundles PROPERTIES "BUNDLES_DEPS" "${DEPS}")
+    set_target_properties(celix-bundles PROPERTIES "BUNDLES_DEPS" "${DEPS}")
     #####
 
     ####### Setting target for activator lib if neccesary ####################
@@ -147,7 +150,7 @@ function(add_bundle)
     add_custom_target(${BUNDLE_TARGET_NAME}_bundle
         DEPENDS "$<TARGET_PROPERTY:${BUNDLE_TARGET_NAME},BUNDLE_FILE>"
     )
-    add_dependencies(bundles ${BUNDLE_TARGET_NAME}_bundle)
+    add_dependencies(celix-bundles ${BUNDLE_TARGET_NAME}_bundle)
     #######################################################################
    
 
@@ -237,7 +240,7 @@ function(add_bundle)
     elseif(BUNDLE_NO_ACTIVATOR)
         #do nothing
     else() #ACTIVATOR 
-        bundle_libs(${BUNDLE_TARGET_NAME} "PRIVATE" TRUE ${BUNDLE_ACTIVATOR})
+        celix_bundle_libs(${BUNDLE_TARGET_NAME} "PRIVATE" TRUE ${BUNDLE_ACTIVATOR})
         
         if(TARGET ${BUNDLE_ACTIVATOR})
             set_target_properties(${BUNDLE_TARGET_NAME} PROPERTIES "BUNDLE_ACTIVATOR" "$<TARGET_SONAME_FILE_NAME:${BUNDLE_ACTIVATOR}>")
@@ -251,30 +254,37 @@ function(add_bundle)
     endif()
 
 
-    bundle_private_libs(${BUNDLE_TARGET_NAME} ${BUNDLE_PRIVATE_LIBRARIES})
-    bundle_export_libs(${BUNDLE_TARGET_NAME} ${BUNDLE_EXPORT_LIBRARIES})
-    bundle_import_libs(${BUNDLE_TARGET_NAME} ${BUNDLE_IMPORT_LIBRARIES})
-    bundle_headers(${BUNDLE_TARGET_NAME} ${BUNDLE_HEADERS})
-endfunction()
-
-function(get_bundle_file BUNDLE OUT)
-    check_bundle(${BUNDLE})
-    get_target_property(${OUT} ${BUNDLE} "BUNDLE_FILE")
+    celix_bundle_private_libs(${BUNDLE_TARGET_NAME} ${BUNDLE_PRIVATE_LIBRARIES})
+    celix_bundle_export_libs(${BUNDLE_TARGET_NAME} ${BUNDLE_EXPORT_LIBRARIES})
+    celix_bundle_import_libs(${BUNDLE_TARGET_NAME} ${BUNDLE_IMPORT_LIBRARIES})
+    celix_bundle_headers(${BUNDLE_TARGET_NAME} ${BUNDLE_HEADERS})
 endfunction()
 
 function(bundle_export_libs)
+    #message(DEPRECATION"bundle_export_libs is DEPRECATION, use celix_bundle_export_libs
instead.")
+    celix_bundle_export_libs(${ARGN})
+endfunction()
+function(celix_bundle_export_libs)
     list(GET ARGN 0 BUNDLE)
     list(REMOVE_AT ARGN 0)
-    bundle_libs(${BUNDLE} "EXPORT" TRUE ${ARGN})
+    celix_bundle_libs(${BUNDLE} "EXPORT" TRUE ${ARGN})
 endfunction()
 
 function(bundle_private_libs)
+    #message(DEPRECATION"bundle_private_libs is DEPRECATION, use celix_bundle_private_libs
instead.")
+    celix_bundle_private_libs(${ARGN})
+endfunction()
+function(celix_bundle_private_libs)
     list(GET ARGN 0 BUNDLE)
     list(REMOVE_AT ARGN 0)
-    bundle_libs(${BUNDLE} "PRIVATE" FALSE ${ARGN})
+    celix_bundle_libs(${BUNDLE} "PRIVATE" FALSE ${ARGN})
 endfunction()
 
 function(bundle_libs)
+    #message(DEPRECATION"bundle_libs is DEPRECATION, use celix_bundle_libs instead.")
+    celix_bundle_libs(${ARGN})
+endfunction()
+function(celix_bundle_libs)
     #0 is bundle TARGET
     #1 is TYPE, e.g PRIVATE,EXPORT or IMPORT
     #2 is ADD_TO_MANIFEST 
@@ -338,6 +348,10 @@ function(bundle_libs)
 endfunction()
 
 function(bundle_import_libs)
+    #message(DEPRECATION"bundle_import_libs is DEPRECATION, use celix_bundle_import_libs
instead.")
+    celix_bundle_import_libs(${ARGN})
+endfunction()
+function(celix_bundle_import_libs)
     #0 is bundle TARGET
     #2..n is import libs
     list(GET ARGN 0 BUNDLE)
@@ -364,6 +378,10 @@ function(bundle_import_libs)
 endfunction()
 
 function(bundle_files)
+    #message(DEPRECATION"bundle_files is DEPRECATION, use celix_bundle_files instead.")
+    celix_bundle_files(${ARGN})
+endfunction()
+function(celix_bundle_files)
     #0 is bundle TARGET
     #1..n is header name / header value
     list(GET ARGN 0 BUNDLE)
@@ -387,6 +405,10 @@ function(bundle_files)
 endfunction()
 
 function(bundle_headers)
+    #message(DEPRECATION"bundle_headers is DEPRECATION, use celix_bundle_headers instead.")
+    celix_bundle_headers(${ARGN})
+endfunction()
+function(celix_bundle_headers)
     #0 is bundle TARGET
     #1..n is header name / header value
     list(GET ARGN 0 BUNDLE)
@@ -401,23 +423,43 @@ function(bundle_headers)
     set_target_properties(${BUNDLE} PROPERTIES "BUNDLE_HEADERS" "${HEADERS}")
 endfunction()
 
-function(bundle_symbolic_name BUNDLE SYMBOLIC_NAME) 
+function(bundle_symbolic_name)
+    #message(DEPRECATION"bundle_symbolic_name is DEPRECATION, use celix_bundle_symbolic_name
instead.")
+    celix_bundle_symbolic_name(${ARGN})
+endfunction()
+function(celix_bundle_symbolic_name BUNDLE SYMBOLIC_NAME)
     set_target_properties(${BUNDLE} PROPERTIES "BUNDLE_SYMBOLIC_NAME" ${SYMBOLIC_NAME})
 endfunction()
 
-function(bundle_name BUNDLE NAME) 
+function(bundle_name)
+    #message(DEPRECATION"bundle_name is DEPRECATION, use celix_bundle_name instead.")
+    celix_bundle_symbolic_name(${ARGN})
+endfunction()
+function(celix_bundle_name BUNDLE NAME)
     set_target_properties(${BUNDLE} PROPERTIES "BUNDLE_NAME" ${NAME})
 endfunction()
 
-function(bundle_version BUNDLE VERSION) 
+function(bundle_version)
+    #message(DEPRECATION"bundle_version is DEPRECATION, use celix_bundle_version instead.")
+    celix_bundle_symbolic_name(${ARGN})
+endfunction()
+function(celix_bundle_version BUNDLE VERSION)
     set_target_properties(${BUNDLE} PROPERTIES "BUNDLE_VERSION" ${VERSION})
 endfunction()
 
-function(bundle_description BUNDLE DESC) 
+function(bundle_description)
+    #message(DEPRECATION"bundle_description is DEPRECATION, use celix_bundle_description
instead.")
+    celix_bundle_symbolic_name(${ARGN})
+endfunction()
+function(celix_bundle_description BUNDLE DESC)
     set_target_properties(${BUNDLE} PROPERTIES "BUNDLE_DESCRIPTION" ${DESC})
 endfunction()
 
 function(install_bundle)
+    #message(DEPRECATION"install_bundle is DEPRECATION, use install_celix_bundle instead.")
+    install_celix_bundle(${ARGN})
+endfunction()
+function(install_celix_bundle)
     #0 is bundle TARGET
     list(GET ARGN 0 BUNDLE)
     list(REMOVE_AT ARGN 0)

http://git-wip-us.apache.org/repos/asf/celix/blob/ee29b00d/cmake/cmake_celix/DeployPackaging.cmake
----------------------------------------------------------------------
diff --git a/cmake/cmake_celix/DeployPackaging.cmake b/cmake/cmake_celix/DeployPackaging.cmake
index 0ec2322..26f5c90 100644
--- a/cmake/cmake_celix/DeployPackaging.cmake
+++ b/cmake/cmake_celix/DeployPackaging.cmake
@@ -16,10 +16,10 @@
 # under the License.
 
 ##### setup bundles/container target
-add_custom_target(containers ALL
-        DEPENDS $<TARGET_PROPERTY:containers,CONTAINER_DEPLOYMENTS>
+add_custom_target(celix-containers ALL
+        DEPENDS $<TARGET_PROPERTY:celix-containers,CONTAINER_DEPLOYMENTS>
 )
-set_target_properties(containers PROPERTIES "CONTAINER_DEPLOYMENTS" "") #initial empty deps
list
+set_target_properties(celix-containers PROPERTIES "CONTAINER_DEPLOYMENTS" "") #initial empty
deps list
 
 get_directory_property(CLEANFILES ADDITIONAL_MAKE_CLEAN_FILES)
 list(APPEND CLEANFILES "${CMAKE_BINARY_DIR}/deploy")
@@ -28,6 +28,7 @@ set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${CLEANFILES}")
 #####
 
 function(add_deploy)
+    #message(DEPRECATION "add_deploy is depecrated, use add_celix_container instead.")
     add_celix_container(${ARGN})
 endfunction()
 
@@ -37,7 +38,7 @@ function(add_celix_container)
 
     set(OPTIONS COPY CXX)
     set(ONE_VAL_ARGS GROUP NAME LAUNCHER LAUNCHER_SRC DIR)
-    set(MULTI_VAL_ARGS BUNDLES PROPERTIES)
+    set(MULTI_VAL_ARGS BUNDLES PROPERTIES EMBEDDED_PROPERTIES)
     cmake_parse_arguments(CONTAINER "${OPTIONS}" "${ONE_VAL_ARGS}" "${MULTI_VAL_ARGS}" ${ARGN})
 
     ##### Check arguments #####
@@ -59,9 +60,9 @@ function(add_celix_container)
     endif ()
     ######
 
-    get_target_property(CONTAINERDEPS containers "CONTAINER_DEPLOYMENTS")
+    get_target_property(CONTAINERDEPS celix-containers "CONTAINER_DEPLOYMENTS")
     list(APPEND CONTAINERDEPS ${CONTAINER_TARGET})
-    set_target_properties(containers PROPERTIES "CONTAINER_DEPLOYMENTS" "${CONTAINERDEPS}")
+    set_target_properties(celix-containers PROPERTIES "CONTAINER_DEPLOYMENTS" "${CONTAINERDEPS}")
 
     #FILE TARGETS FOR CONTAINER
     set(CONTAINER_PROPS "${CONTAINER_LOC}/config.properties")
@@ -106,7 +107,7 @@ function(add_celix_container)
 
 int main(int argc, char *argv[]) {
     const char * config = \"cosgi.auto.start.1=$<JOIN:$<TARGET_PROPERTY:${CONTAINER_TARGET},CONTAINER_BUNDLES>,
>\\n\\
-$<JOIN:$<TARGET_PROPERTY:${CONTAINER_TARGET},CONTAINER_PROPERTIES>,\\n\\
+$<JOIN:$<TARGET_PROPERTY:${CONTAINER_TARGET},CONTAINER_EMBEDDED_PROPERTIES>,\\n\\
 >\";
 
     properties_pt packedConfig = properties_loadFromString(config);
@@ -202,10 +203,12 @@ $<JOIN:$<TARGET_PROPERTY:${CONTAINER_TARGET},CONTAINER_PROPERTIES>,
     set_target_properties(${CONTAINER_TARGET} PROPERTIES "CONTAINER_GROUP" "${CONTAINER_GROUP}")
     set_target_properties(${CONTAINER_TARGET} PROPERTIES "CONTAINER_LOC" "${CONTAINER_LOC}")
     set_target_properties(${CONTAINER_TARGET} PROPERTIES "CONTAINER_PROPERTIES" "")
+    set_target_properties(${CONTAINER_TARGET} PROPERTIES "CONTAINER_EMBEDDED_PROPERTIES"
"")
     #####
 
     celix_container_bundles(${CONTAINER_TARGET} ${CONTAINER_BUNDLES})
     celix_container_properties(${CONTAINER_TARGET} ${CONTAINER_PROPERTIES})
+    celix_container_embedded_properties(${CONTAINER_TARGET} ${CONTAINER_EMBEDDED_PROPERTIES})
 
 
     #ensure the container dir will be deleted during clean
@@ -218,6 +221,7 @@ endfunction()
 #NOTE can be used for drivers/proxies/endpoints bundle dirs
 
 function(deploy_bundles_dir)
+    #message(DEPRECATION "deploy_bundles_dir is depecrated, use celix_container_bundles_dir
instead.")
     celix_container_bundles_dir(${ARGN})
 endfunction()
 function(celix_container_bundles_dir)
@@ -261,6 +265,7 @@ function(celix_container_bundles_dir)
 endfunction()
 
 function(deploy_bundles)
+    #message(DEPRECATION "deploy_bundles is depecrated, use celix_container_bundles instead.")
     celix_container_bundles(${ARGN})
 endfunction()
 function(celix_container_bundles)
@@ -298,6 +303,7 @@ function(celix_container_bundles)
 endfunction()
 
 function(deploy_properties)
+    #message(DEPRECATION "deploy_properties is depecrated, use celix_container_properties
instead.")
     celix_container_properties(${ARGN})
 endfunction()
 function(celix_container_properties)
@@ -314,3 +320,22 @@ function(celix_container_properties)
 
    set_target_properties(${CONTAINER_TARGET} PROPERTIES "CONTAINER_PROPERTIES" "${PROPS}")
 endfunction()
+
+function(deploy_embedded_properties)
+    #message(DEPRECATION "deploy_embedded_properties is depecrated, use celix_container_embedded_properties
instead.")
+    celix_container_embedded_properties(${ARGN})
+endfunction()
+function(celix_container_embedded_properties)
+    #0 is container TARGET
+    #1..n is bundles
+    list(GET ARGN 0 CONTAINER_TARGET)
+    list(REMOVE_AT ARGN 0)
+
+    get_target_property(PROPS ${CONTAINER_TARGET} "CONTAINER_EMBEDDED_PROPERTIES")
+
+    foreach(PROP IN ITEMS ${ARGN})
+        list(APPEND PROPS ${PROP})
+    endforeach()
+
+    set_target_properties(${CONTAINER_TARGET} PROPERTIES "CONTAINER_EMBEDDED_PROPERTIES"
"${PROPS}")
+endfunction()

http://git-wip-us.apache.org/repos/asf/celix/blob/ee29b00d/documents/cmake_commands/readme.md
----------------------------------------------------------------------
diff --git a/documents/cmake_commands/readme.md b/documents/cmake_commands/readme.md
index 1287299..6de67e1 100644
--- a/documents/cmake_commands/readme.md
+++ b/documents/cmake_commands/readme.md
@@ -4,14 +4,16 @@ For Apache Celix several cmake command are added to be able to work with
Apache
 
 # Bundles
 
-## add_bundle
-Add a bundle to the project.  There are three variants:
+## add_celix_bundle
+Add a Celix bundle to the project.  There are three variants:
 - With SOURCES the bundle will be created using a list of sources files as input for the
bundle activator library.
 - With ACTIVATOR the bundle will be created using the library target or absolute path to
existing library as activator library.
 - With no SOURCES or ACTIVATOR a bundle without a activator will be created.
 
+Also available under the add_bundle CMake function (deprecated).
+
 ```CMake
-add_bundle(<bundle_target_name> 
+add_celix_bundle(<bundle_target_name> 
     SOURCES source1 source2 ...
     [NAME bundle_name] 
     [SYMBOLIC_NAME bundle_symbolic_name]
@@ -25,7 +27,7 @@ add_bundle(<bundle_target_name>
 ```
 
 ```CMake
-add_bundle(<bundle_target_name> 
+add_celix_bundle(<bundle_target_name> 
     ACTIVATOR <activator_lib>
     [NAME bundle_name] 
     [SYMBOLIC_NAME bundle_symbolic_name]
@@ -39,7 +41,7 @@ add_bundle(<bundle_target_name>
 ```
 
 ```CMake
-add_bundle(<bundle_target_name> 
+add_celix_bundle(<bundle_target_name> 
     [NAME bundle_name] 
     [SYMBOLIC_NAME bundle_symbolic_name]
     [DESCRIPTION bundle_description]
@@ -61,22 +63,22 @@ For SOVERSION only the major part is used. Expected scheme is "<major>.<minor>.<
 - If IMPORT_LIBRARIES is provided all provided lib are added to the "Import-Library" manifest
statement and added in the root of the bundle. libraries can be cmake library targets or absolute
paths to existing libraries.  This is not yet supported by the celix framework
 - If HEADERS is provided the headers values are appended to the bundle manifest.
 
-## bundle_private_libs
+## celix_bundle_private_libs
 Add libraries to a bundle target. The libraries should be cmake library targets or an absolute
path to a existing library.
 
 ```CMake
-bundle_private_libs(<bundle_target>
+celix_bundle_private_libs(<bundle_target>
     lib1 lib2 ...
 )
 ```
 
-## bundle_files
+## celix_bundle_files
 Add files to the target bundle. DESTINATION is relative to the bundle archive root. 
 The rest of the command is conform file(COPY ...) cmake command.
 See cmake file(COPY ...) command for more info.
 
 ```CMake
-bundle_files(<bundle_target>
+celix_bundle_files(<bundle_target>
     files... DESTINATION <dir>
     [FILE_PERMISSIONS permissions...]
     [DIRECTORY_PERMISSIONS permissions...]
@@ -88,53 +90,53 @@ bundle_files(<bundle_target>
 ```
 
 
-## bundle_headers
+## celix_bundle_headers
 Append the provided headers to the target bundle manifest.
 
 ```CMake
-bundle_headers(<bundle_target>
+celix_bundle_headers(<bundle_target>
     "header1: header1_value"
     "header2: header2_value"
     ...
 )
 ```
 
-## bundle_symbolic_name
+## celix_bundle_symbolic_name
 Set bundle symbolic name
 
 ```CMake
-bundle_symbolic_name(<bundle_target> symbolic_name)
+celix_bundle_symbolic_name(<bundle_target> symbolic_name)
 ```
 
-## bundle_name
+## celix_bundle_name
 Set bundle name
 
 ```CMake
-bundle_name(<bundle_target> name)
+celix_bundle_name(<bundle_target> name)
 ```
 
-## bundle_version
+## celix_bundle_version
 Set bundle version
 
 ```CMake
-bundle_version(<bundle_target> version)
+celix_bundle_version(<bundle_target> version)
 ```
 
-## bundle_description
+## celix_bundle_description
 Set bundle description
 
 ```CMake
-bundle_description(<bundle_target> description)
+celix_bundle_description(<bundle_target> description)
 ```
 
-## install_bundle
+## install_celix_bundle
 Install bundle when 'make install' is executed. 
 Bundles are installed at `<install-prefix>/share/<project_name>/bundles`.
 Headers are installed at `<install-prefix>/include/<project_name>/<bundle_name>`
 Resources are installed at `<install-prefix>/shared/<project_name>/<bundle_name>`
 
 ```CMake
-install_bundle(<bundle_target>
+install_celix_bundle(<bundle_target>
     [PROJECT_NAME] project_name
     [BUNDLE_NAME] bundle_name
     [HEADERS header_file1 header_file2 ...]
@@ -147,20 +149,22 @@ install_bundle(<bundle_target>
 - If HEADERS is provided the list of provided headers will be installed.
 - If RESOURCES is provided the list of provided resources will be installed.
 
-# Deployments
+# Celix Containers
+
+## add_celix_container
+Add a Celix container, consisting out of a selection of bundles and a simple Celix launcher.
+Celix containers can be used to run/test a selection of bundles in the celix framework.
+A Celix container can be found in `<cmake_build_dir>/deploy[/<group_name>]/<celix_container_name>`.

+Use the `<celix_container_name>` executable to run the deployments.
 
-## add_deploy
-Add a deployment, consisting out of a selection of bundles and a simple Celix launcher.
-Deployments can be used to run/test a selection of bundles in the celix framework.
-A deployment can be found in `<cmake_build_dir>/deploy[/<group_name>]/<deploy_name>`.

-Use the `<deploy_target_name>` executable to run the deployments.
+Also available under the add_deploy CMake function (deprecated).
 
 ```CMake
-add_deploy(<deploy_target_name>
+add_celix_container(<celix_container_name>
     [COPY] 
     [CXX]
     [GROUP group_name]
-    [NAME deploy_name]
+    [NAME celix_container_name]
     [LAUNCHER launcher]
     [DIR dir]
     [BUNDLES <bundle1> <bundle2> ...]
@@ -168,8 +172,8 @@ add_deploy(<deploy_target_name>
 )
 ```
 
-The provided bundle targets for a deployment do not have to exists (yet).
-This removes the need for correctly ordering the add_bundle commands so that all bundle target
are present before an add_deploy command.
+The provided bundle targets for a celix container do not have to exists (yet).
+This removes the need for correctly ordering the add_bundle commands so that all bundle target
are present before an add_celix_container command.
 If the bundle target is never added CMake will give an error:
 ```
   Error evaluating generator expression:
@@ -178,19 +182,19 @@ If the bundle target is never added CMake will give an error:
 ```
 
 - If the COPY option is provided the selected bundles will be copied in a bundles dir and
the generated config.properties will use relative paths to the bundle locations. Default bundles
will not be copied and the generated config.properties will use absolute references to the
bundle locations.
-- If CXX option is provided the deploy launcher will be build as C++ executable and as result
be linked with the required C++ libraries of the used compiler
-- If GROUP is provided the deployment will be grouped in the provided group name. 
-- If NAME is provided that name will be used for the deployment dir. Default the deploy target
name will be used.
-- If LAUNCHER is provided that path or target will be used as launcher executable for the
deployment. If no LAUNCHER is not provided the celix executable will be used.
+- If CXX option is provided the celix container launcher will be build as C++ executable
and as result be linked with the required C++ libraries of the used compiler
+- If GROUP is provided the celix container will be grouped in the provided group name. 
+- If NAME is provided that name will be used for the celix container dir. Default the Celix
container target name will be used.
+- If LAUNCHER is provided that path or target will be used as launcher executable for the
Celix container. If no LAUNCHER is not provided the celix executable will be used.
 - If DIR is provided, the specified dir is used instead of `<cmake_build_dir>/deploy`
as deploy dir 
 - If BUNDLES is provided the list of bundles will be added the the generated config.properties
for startup. Combined with COPY the bundles will also be copied to a bundles dir.
 - If PROPERTIES is provided the list of properties will be appended to the generated config.properties
 
-## deploy_bundles_dir
+## celix_container_bundles_dir
 Deploy a selection of bundles to the provided bundle dir. This can be used to create an endpoints
/ proxies bundles dir for the remote service admin or drivers bundles dir for the device access.

 
 ```CMake
-deploy_bundles_dir(<deploy_target_name>
+celix_container_bundles_dir(<celix_container_target_name>
     DIR_NAME dir_name
     BUNDLES 
         bundle1 
@@ -199,23 +203,35 @@ deploy_bundles_dir(<deploy_target_name>
 )
 ```
 
-## deploy_bundles
+## celix_container_bundles
 Deploy the selected bundles. The bundles are configured for auto starting. 
 
 ```CMake
-deploy_bundles(<deploy_target_name>
+celix_container_bundles(<celix_container_target_name>
     bundle1 
     bundle2 
     ...
 )
 ```
 
-## deploy_properties
+## celix_container_properties
+Add the provided properties to the target Celix container config.properties.
+
 
 ```CMake
-Add the provided properties to the target deploy config.properties.
+celix_container_properties(<celix_container_target_name>
+    "prop1=val1" 
+    "prop2=val2" 
+    ...
+)
+```
 
-deploy_properties(<deploy_target_name>
+## celix_cotainer_embedded_properties
+Embeds the provided properties to the target Celix launcher as embedded properties.
+Note that these properties can be overridden by using config.properties.
+
+```CMake
+celix_container_embedded_properties(<celix_container_target_name>
     "prop1=val1" 
     "prop2=val2" 
     ...
@@ -223,27 +239,21 @@ deploy_properties(<deploy_target_name>
 ```
 
 # Celix Docker Images
-It is possible the use the `add_docker` Apache Celix CMake command to create Apache Celix
docker directories,
+It is possible the use the `add_celix_docker` Apache Celix CMake command to create Apache
Celix docker directories,
 which in turn can be used to create very small Apache Celix docker images.
 
-## add_docker
+## add_celix_docker
 Adds a docker target dir, containing a all the required executables, 
 libraries and filesystem needed to run a Apache Celix framework in a docker container. 
 Also includes the selected bundles. 
 
-The add_docker image use a `celix_docker_depslib` target to infer which shared libraries
are required 
-for the docker image. The `celix_docker_depslib` is a empty C++ libraries linked against
`jansson`, `libffi` and `m`.
-As result these libraries and some additional required libraries (libgcc_s, libstdc++) are
added to the
-docker dir. It is possible to link additional libraries to the `celix_docker_depslib` to
that these are also
-added to the docker image. It is also possible to specify a own "docker libs" library to
use to infer 
-the required library dependencies
+The add_celix_docker target is a executable target and can be used to link libraries which
are needed in the docker image.
 
 The docker dir can be found in `<cmake_build_dir>/docker[/<group_name>]/<docker_name>`.

   
-  
 The provided bundle targets for a docker dir do not have to exists (yet).
 This removes the need for correctly order the add_bundle commands so that all bundle target
are present before 
-an `add_docker` command.
+an `add_celix_docker` command.
 If the bundle target is never added CMake will give an error:
   ```
     Error evaluating generator expression:
@@ -252,44 +262,29 @@ If the bundle target is never added CMake will give an error:
   ```
  
 ```CMake
-add_docker(<docker_target_name>
+add_celix_docker(<docker_target_name>
+    [CXX]
     [GROUP group_name]
     [NAME deploy_name]
     [FROM docker_from_image]
     [BUNDLES_DIR bundle_dir_in_docker_image]
     [WORKDIR workdir_in_docker_image]
-    [DEPSLIB deps_lib_target_name]
     [IMAGE_NAME docker_image_name]
-    [ENTRYPOINT docker_entry_point]
     [BUNDLES <bundle1> <bundle2> ...]
     [PROPERTIES "prop1=val1" "prop2=val2" ...]
     [INSTRUCTIONS "instr1" "instr2" ...]
 )
 ```
 
+- If CXX is set the entrypoint executable will be created as a C++ main file, default it
is a C main file.
 - If GROUP is provided the docker will be grouped in the provided group name. 
 - If NAME is provided that name will be used for the docker dir. Default the deploy target
name will be used.
 - If FROM is provided the docker image will use the provide FROM as base, else `FROM scratch`
is used and 
     a minimal filesystem will be created for the docker image
 - If BUNDLES_DIR is provided that directory will be used as bundles location. Default `/bundles`
will be used
 - If WORKDIR is provided that directory will be used a workdir. Default `/root` will be used
-- If DEPSLIB is provided that target name will be used to infer the required libraries. Default
the target 
-name `celix_docker_libsdep` will be used
 - If IMAGE_NAME is provided that will be used as docker image name. Default the NAME will
be used
-- If ENTRYPOINT is provided that will be used as docker entrypoint. Default `/bin/celix`
will be used
 - If BUNDLES is provided, the list of bundles will be added to the docker images and configured
in the generated 
  `config.properties`
 - If PROPERTIES is provided, the list of properties will added to the generated `config.properties`
file
 - If INSTRUCTIONS id provided, the list of docker instructions will be added the the generated
`Dockerfile`
-
-## build-docker-images target
-TODO
-
-## docker_bundles
-TODO
-
-## docker_properties
-TODO
-
-## docker_instructions
-TODO


Mime
View raw message