
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>Changes / Apache Celix</title>

    
    <link rel="icon" href="/assets/img/favicon.ico">

    
    <link href="/assets/css/bootstrap.min.css" rel="stylesheet">

    
    <link href="/assets/css/style.css" rel="stylesheet">

    <style>
         
         
        .card-body img {
            max-width: 100%;
            width: 100%;
            height: auto;
        }

         
        .card-body img + em {
            text-decoration: underline;
        }
    </style>

    
<script>
  var _paq = window._paq = window._paq || [];
   
  _paq.push(['disableCookies']);
   
  _paq.push(['trackPageView']);
  _paq.push(['enableLinkTracking']);
  (function() {
    var u="https://analytics.apache.org/";
    _paq.push(['setTrackerUrl', u+'matomo.php']);
    _paq.push(['setSiteId', '9']);
    var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
    g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
  })();
</script>


</head>
<body class="light-grey">

<a href="https://github.com/apache/celix" class="github-ribbon">
    <img src="/assets/img/forkme_right_red_aa0000.png" alt="Fork me on GitHub">
</a>


<nav class="navbar navbar-expand-lg navbar-dark bg-primary fixed-top">
    <div class="container">
        <a class="navbar-brand" href="/">
            <img src="/assets/img/celix-white.svg" height="40" class="d-inline-block align-top" alt="Celix Logo">
        </a>
        <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarResponsive" aria-controls="navbarResponsive" aria-expanded="false" aria-label="Toggle navigation">
            <span class="navbar-toggler-icon"></span>
        </button>
        <div class="collapse navbar-collapse" id="navbarResponsive">
            <ul class="navbar-nav ml-auto">
                <li class="nav-item">
                    <a class="nav-link" href="/">Home</a>
                </li>
                <li class="nav-item">
                    <a class="nav-link" href="/download.cgi">Download</a>
                </li>
                <li class="nav-item dropdown active">
                    <a class="nav-link dropdown-toggle" href="#" id="ddDocs" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
                        Docs
                    </a>
                    <div class="dropdown-menu" aria-labelledby="ddDocs">
                        <a class="dropdown-item" href="/docs/2.4.0/docs.html">2.4.0 (latest)</a>
                        <a class="dropdown-item" href="/docs/2.3.0/docs.html">2.3.0</a>
                        <a class="dropdown-item" href="/docs/2.2.1/docs.html">2.2.1</a>
                        <a class="dropdown-item" href="/docs/2.1.0/docs.html">2.1.0</a>
                    </div>
                </li>
                <li class="nav-item dropdown">
                    <a class="nav-link dropdown-toggle" href="#" id="ddContributing" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
                        Contributing
                    </a>
                    <div class="dropdown-menu" aria-labelledby="ddContributing">
                        <a class="dropdown-item" href="/contributing/youatcelix.html">You at Celix</a>
                        <a class="dropdown-item" href="/contributing/submitting-patches.html">Submitting patches</a>
                        <a class="dropdown-item" href="/contributing/source-and-builds.html">Source code and builds</a>
                        <hr>
                        <a class="dropdown-item" href="/contributing/releasing.html">Releasing</a>
                        <a class="dropdown-item" href="/contributing/volunteers.html">Volunteers</a>
                        <a class="dropdown-item" href="https://whimsy.apache.org/board/minutes/Celix.html">Board Reports</a>
                    </div>
                </li>
                <li class="nav-item dropdown">
                    <a class="nav-link dropdown-toggle" href="#" id="ddSupport" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
                        Support
                    </a>
                    <div class="dropdown-menu" aria-labelledby="ddSupport">
                        <a class="dropdown-item" href="/support/mailing-list.html">Mailing Lists</a>
                        <a class="dropdown-item" href="/support/issue-tracking.html">Issue Tracking</a>
                    </div>
                </li>
                <li class="nav-item dropdown">
                    <a class="nav-link dropdown-toggle" href="#" id="ddFoundation" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
                        ASF
                    </a>
                    <div class="dropdown-menu" aria-labelledby="ddFoundation">
                        <a class="dropdown-item" href="https://www.apache.org/">ASF Home</a>
                        <a class="dropdown-item" href="https://www.apache.org/foundation/how-it-works.html">How it works</a>
                        <a class="dropdown-item" href="https://www.apache.org/licenses/">License</a>
                        <a class="dropdown-item" href="https://www.apache.org/foundation/sponsorship.html">Sponsorship</a>
                        <a class="dropdown-item" href="https://www.apache.org/foundation/thanks.html">Thanks</a>
                        <a class="dropdown-item" href="https://www.apache.org/security/">Security</a>
                        <a class="dropdown-item" href="https://www.apache.org/foundation/policies/conduct">Code of Conduct</a>
                    </div>
                </li>
            </ul>
        </div>
    </div>
</nav>


<div class="section">
    <div class="container">
        <div class="row py-4">
            <div class="col-sm-12 card">
                <div class="card-body pt-5">
                    
                    
                        
                        
                    

                    
                        
                        <a href="/docs/2.2.1/docs.html" title="back to documentation">&lt;&lt; back to documentation</a>
                    

                    
	<!--
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.
-->
<h1 id="changes-for-221">Changes for 2.2.1</h1>
<h2 id="fixes">Fixes</h2>
<ul>
<li>Fixes etcdlib CMake setup to that etcdlib can be build as a separate project</li>
</ul>
<h1 id="changes-for-220">Changes for 2.2.0</h1>
<h2 id="new-features">New features:</h2>
<ul>
<li>PubSub TCP (donation)</li>
<li>PubSub Avro bin serializer</li>
<li>PubSub Websocket (donation)</li>
<li>HTTP Admin (donation)</li>
<li>Shell Web UI (using HTTP Admin) d</li>
</ul>
<h2 id="improvements">Improvements</h2>
<ul>
<li>CELIX-438: Refactored celix api so that include files and symbols have a _celix &ldquo;namespace&rdquo;</li>
<li>CELIX-459: Adds PubSub health/usage monitoring</li>
<li>CELIX-467: Adds doxygen generation</li>
<li>Refactored etcdlib to supported multiple instances</li>
</ul>
<h2 id="bugs">Bugs</h2>
<ul>
<li>CELIX-410: Fixes issue with property loader duplicating spaces and tabs</li>
<li>CELIX-454: Fixed race condition in the etcd pubsub discovery</li>
<li>CELIX-460: Fixed issue with msg not found in pub/sub serializer map due to signed/unsigned difference</li>
<li>CELIX-466: Fixed race condition Race condition in adding/removing service listener hooks</li>
</ul>
<h1 id="changes-for-210">Changes for 2.1.0</h1>
<h2 id="new-features-1">New Features:</h2>
<ul>
<li>CELIX-408: Adds support for generating runtime shell scripts so that multiple Celix containers and other executable can be run with a single command.</li>
<li>CELIX-418: Adds support for generating properties in the Celix container launcher.</li>
<li>CELIX-407: Adds support for serializers as a service for PubSub. This way PubSubAdmin are purely focused on transport techniques.</li>
<li>CELIX-401: Adds support for creating Celix docker images using a CMake function.</li>
<li>CELIX-397: Adds support for PubSub selection based on a match function. This way multiple PubSubAdmin can be active.</li>
<li>CELIX-389: Adds the PubSub implementation. A set of bundles which together operates as a service based publish subscribe technology agnostic abstraction.</li>
<li>CELIX-385: Adds etcdlib as library. This libray can be used to communicate with etcd using a C abstraction.</li>
<li>CELIX-370: Adds C++11 support by adding a C++ Dependency Manager library. This is moslty a header based library.</li>
</ul>
<h2 id="improvements-1">Improvements:</h2>
<ul>
<li>CELIX-415: Improves handling of ANSI control sequences to better support running in IDE&rsquo;s.</li>
<li>CELIX-414: Improves support for running Celix container inside IDE&rsquo;s by basicly handling Celix containers as add_executable CMake target.</li>
<li>CELIX-406: Improves handling of descriptor files, by allowing different directories for Remote Services and PubSub.</li>
<li>CELIX-399: Improves PubSub to use etcdlib instead of local copy of etcd.c file.</li>
<li>CELIX-396: Improves the ZMQ PubSub security so that enabling/disable of security can be done per topic.</li>
<li>CELIX-395: Improves Remote Service to use the etcdlib instead of a local etcd.c file.</li>
<li>CELIX-392: Removes the use of the deprecated readdir_r function.</li>
</ul>
<h2 id="bugs-1">Bugs:</h2>
<ul>
<li>CELIX-416: Fixes an issue for the Android build.</li>
<li>CELIX-410: Fixes an issue where spaces and tabs are duplicated when loading properties.</li>
<li>CELIX-405: Fixes an issue with crashes because of invalid DFI descriptors.</li>
<li>CELIX-404: Fixes an issue with crashes using the inspect shell command.</li>
<li>CELIX-403: Fixes an memory leak in the service tracker.</li>
<li>CELIX-400: Fixes an issue with private libraries being loaded twice.</li>
<li>CELIX-398: Fixes an issue with PubSub and multiple UDP connections.</li>
<li>CELIX-393: Fixes an issue with the add_bundle CMake function and using existing libaries.</li>
<li>CELIX-391: Fixes an issue with the utils_stringHash not genering unique (enough) hashes.</li>
<li>CELIX-390: Fixes an issue with cycle dependency between the Celix framework and Celix utils libraries.</li>
<li>CELIX-387: Fixes an issue with the travis build and OSX</li>
<li>CELIX-386: Fixes an issue with the C++ dependency manager and register multiple C++ services.</li>
</ul>
<h1 id="changes-for-200">Changes for 2.0.0</h1>
<h2 id="new-features-2">New Features</h2>
<ul>
<li>CELIX-77 Configuration Admin Implementation</li>
<li>CELIX-116 Event admin</li>
<li>CELIX-119 Remove apr usage from framework</li>
<li>CELIX-172 Bonjour Shell</li>
<li>CELIX-237 RSA with libffi</li>
<li>CELIX-269 New Dependency Manager</li>
<li>CELIX-370 Add C++ support</li>
</ul>
<h2 id="improvements-2">Improvements</h2>
<ul>
<li>CELIX-63 make cmake directory useable for custom bundle projects</li>
<li>CELIX-66 Refactor shell service struct</li>
<li>CELIX-90 add additional build options for RSA components</li>
<li>CELIX-111 Support multiple libraries</li>
<li>CELIX-115 logservice bundle entries list grows indefinitely</li>
<li>CELIX-118 Deployment Admin - Support auditlog of Apache ACE</li>
<li>CELIX-123 enable code coverage for utils_test</li>
<li>CELIX-125 CMakeCelix module</li>
<li>CELIX-134 Update source from incubator structure to TLP</li>
<li>CELIX-138 Parameterise launcher</li>
<li>CELIX-144 Document Developing Celix with Eclipse</li>
<li>CELIX-146 Replace printfs wit fw_log calls</li>
<li>CELIX-149 Add log_writer_syslog</li>
<li>CELIX-152 Added Discovery/ETCD support</li>
<li>CELIX-153 add cmake configuration options for rsa_bundles</li>
<li>CELIX-156 Enable all warnings</li>
<li>CELIX-158 RSA is unable to re-use already started proxy factory</li>
<li>CELIX-165 Add port collision auto-correction to RSA</li>
<li>CELIX-169 Add port collision auto-correction to discovery</li>
<li>CELIX-182 loghelper eases log_service tracking</li>
<li>CELIX-187 discovery_etcd: add watchindex, handle expire action</li>
<li>CELIX-193 support portable celix_thread_t initalization</li>
<li>CELIX-199 Code Coverage should be optional rather than required by cmake</li>
<li>CELIX-200 SEGFAULT occurs when remote services are closed</li>
<li>CELIX-216 Replace strtok with strtok_r</li>
<li>CELIX-230 Refactoring of the shell command service</li>
<li>CELIX-242 Fix Warnings</li>
<li>CELIX-245 Update civetweb to latest version</li>
<li>CELIX-246 enable Travis CI for Apache Celix</li>
<li>CELIX-247 Enable ANDROID support</li>
<li>CELIX-249 Refactor most char * usage to const char *</li>
<li>CELIX-251 missing includes in device access example</li>
<li>CELIX-255 Update default BUILD option</li>
<li>CELIX-258 framework uses  dlopen/dlsym to set the bundleActivator</li>
<li>CELIX-259 dispatcherThread does not perform a graceful shutdown</li>
<li>CELIX-275 Can&rsquo;t do mkstemp on root system (deploymentAdmin_download)</li>
<li>CELIX-278 Adding tags to ACE target through deployment admin</li>
<li>CELIX-284 Restrict export and imports based on properties</li>
<li>CELIX-285 Discovery SHM: remove obsolete jansson dependency</li>
<li>CELIX-295 Many compiling warnings in unit tests</li>
<li>CELIX-296 Framework unit tests improvement</li>
<li>CELIX-309 Make DFI available for common use</li>
<li>CELIX-317 Dependency Manager suspend state</li>
<li>CELIX-320 outdated utils tests (threads, hashmap)</li>
<li>CELIX-323 Version and version_range moved from framework to utils</li>
<li>CELIX-326 Add service version support to dependency manager</li>
<li>CELIX-327 Filter does not support greater than and lesser than operators</li>
<li>CELIX-328 Service version support for RSA DFI</li>
<li>CELIX-330 document using markdown</li>
<li>CELIX-333 integrate coverity scans</li>
<li>CELIX-335 Refactor deploying bundles with cmake</li>
<li>CELIX-339 celix_log_mock doesnt show logs to the user</li>
<li>CELIX-341 Fix coverity issues in Shell / Shell TUI</li>
<li>CELIX-348 The utils_stringHash does not generate unique hashes.</li>
<li>CELIX-352 RSA_DFI and embedded celix</li>
<li>CELIX-353 Make bundle context retrievable form dm component</li>
<li>CELIX-365 Refactor some usage of void* to const void*</li>
</ul>
<h2 id="bugs-2">Bugs</h2>
<ul>
<li>CELIX-104 deployment_admin bundle won&rsquo;t start when missing properties</li>
<li>CELIX-105 Fixed array_list_test</li>
<li>CELIX-114 Potential deadlock in log_service bundle during stop</li>
<li>CELIX-122 missing dependency uuid</li>
<li>CELIX-124 Celix memory leaks fixing</li>
<li>CELIX-127 Makefiles not generated using CMake 3.0</li>
<li>CELIX-128 remote_shell port cannot be changed</li>
<li>CELIX-129 Update RSA to be compatible with the Amdatu RSA implementation</li>
<li>CELIX-130 Implement Configured Endpoint discovery compatible with Amdatu RSA</li>
<li>CELIX-136 contrib Configured endpoint discovery</li>
<li>CELIX-137 Possible concurrency issues in topology manager</li>
<li>CELIX-139 Update tests and mocks to latest CppUTest</li>
<li>CELIX-147 RSA_SHM: concurrency issue when client segfaults</li>
<li>CELIX-150 Topology Manager segfaults when RSA/bundle w/ exp. service stops in wrong order</li>
<li>CELIX-154 echo exampe not working</li>
<li>CELIX-155 Fix CMake warnings during configuration</li>
<li>CELIX-157 service_reference misses functions to get property keys and values</li>
<li>CELIX-159 PThread usage not correct for Linux</li>
<li>CELIX-161 newly added RSA cannot manage already exported/imported services</li>
<li>CELIX-162 Update encoding/decoding of replies.</li>
<li>CELIX-167 Update command to be able to pass a pointer (handle)</li>
<li>CELIX-168 discovery_etcd:Make root-path configurable</li>
<li>CELIX-170 Remote services can fail to restart when felix restarts</li>
<li>CELIX-173 stopping rsa_http bundle does not stop rsa webserver</li>
<li>CELIX-174  invalid bundle_context during fw shutdown</li>
<li>CELIX-175 segfault during shutdown when calculator is already stopped</li>
<li>CELIX-177 not all endpoints are unistalled when rsa_http bundle is stopped</li>
<li>CELIX-178 Shell_Tui bundle hangs on stop</li>
<li>CELIX-179 memory leak in rsa_http callback</li>
<li>CELIX-180 framework_tests do not compile</li>
<li>CELIX-181 Incorrect reply status when no data is returned on a remote call.</li>
<li>CELIX-185 Memory leaks in Discovery Endpoint Descriptor Reader</li>
<li>CELIX-186 deployment_admin segfaults while downloading bundle</li>
<li>CELIX-188 Add missing log_service headers to installations</li>
<li>CELIX-189 LogService segfaults when log message pointer is overwritten</li>
<li>CELIX-190 remote services memory leaks</li>
<li>CELIX-192 rsa_http: add locking</li>
<li>CELIX-194 Refactor RemoteService proxy factory</li>
<li>CELIX-195 SEGFAULT occurs when running a log command.</li>
<li>CELIX-197 insufficient memory allocated</li>
<li>CELIX-198 Logging can segfault for strings 512 characters or longer</li>
<li>CELIX-201 SEGFAULT occurs when restarting apache_celix_rs_topology_manager</li>
<li>CELIX-202 Not all components are disabled with a clean build</li>
<li>CELIX-205 RSA Discovery (Configured) bundle gets stuck</li>
<li>CELIX-213 SEGFAULT occurs due to memory access after memory is free&rsquo;d</li>
<li>CELIX-215 curl_global_init() not called directly</li>
<li>CELIX-218 Memory leaks in service_registry.c</li>
<li>CELIX-219 Memory Leaks</li>
<li>CELIX-221 Deployment admin segfaults when deploying a bundle</li>
<li>CELIX-223 Celix crashes because of wrong bundle versions</li>
<li>CELIX-224 Wrong use of errno in launcher.c</li>
<li>CELIX-226 __unused atttibute does not work with  Linux</li>
<li>CELIX-227 compile error under linux due to missing header include</li>
<li>CELIX-229 Make APR optional</li>
<li>CELIX-231 Missing log_helper creation in discovery_etcd</li>
<li>CELIX-238 Contributing page links incorrect</li>
<li>CELIX-239 TopologyManager does not maintain exportedServices</li>
<li>CELIX-240 RSA: deadlock when stopping</li>
<li>CELIX-241 remote_interface incorrect</li>
<li>CELIX-248 too many arguments for format</li>
<li>CELIX-250 config.h is not exported</li>
<li>CELIX-252 discovery_etcd cannot handle celix restarts</li>
<li>CELIX-253 Deployment admin does not always download the latest version from ACE</li>
<li>CELIX-254 Memory leakage in deployment_admin</li>
<li>CELIX-260 missing include in deployment admin</li>
<li>CELIX-262 Fix minor issues in hashMap/linkedList</li>
<li>CELIX-263 replace utils cunit tests w/ cpputest tests</li>
<li>CELIX-264 Missing strdup leads to invalid free</li>
<li>CELIX-270 Fix Code Coverage</li>
<li>CELIX-271 setup coveralls.io</li>
<li>CELIX-272 framework: improve locking / synchronization</li>
<li>CELIX-274 waitForShutdown issue when starting two embedded celix frameworks.</li>
<li>CELIX-279 Celix fails to compile w/ CMake 3.3</li>
<li>CELIX-280 deployment_admin misses proper shutdown functionality</li>
<li>CELIX-287 racecondition for framework event listener</li>
<li>CELIX-288 Archive directory not properly read</li>
<li>CELIX-289 Fix celix mocks</li>
<li>CELIX-290 Mock fixes, CMakelist fix, build warning fix</li>
<li>CELIX-292 Memory leak in refactored shell</li>
<li>CELIX-294 changed dfi library from static to shared</li>
<li>CELIX-298 Memory leaks in rsa_dfi</li>
<li>CELIX-300 Invalid read in serviceRegistry during framework_shutdown</li>
<li>CELIX-301 Memory leaks in rsa_shm</li>
<li>CELIX-302 Service Tracker Test error breaks the build</li>
<li>CELIX-304 Memory leaks in manifest parser, requirement, capability; out-of-date tests</li>
<li>CELIX-305 Memory leaks in RSA_SHM, RSA_DFI, RSA_HTTP</li>
<li>CELIX-306 Memory leaks in remote_proxy_factory, unit tests issues</li>
<li>CELIX-307 &ldquo;service registration set properties&rdquo; deadlocks</li>
<li>CELIX-308 Dependency Manager memory leaks</li>
<li>CELIX-310 &ldquo;serviceRegistry_getRegisteredServices&rdquo; deadlocks</li>
<li>CELIX-311 Framework Tests Build broken</li>
<li>CELIX-312 ServiceReference usage counter inconsistent state</li>
<li>CELIX-313 out of date/defunct tests</li>
<li>CELIX-316 Wrong conversion for &lsquo;N&rsquo; type in json_serializer</li>
<li>CELIX-322 Memory leaks in resolver and framework tests</li>
<li>CELIX-324 Version support in dfi library</li>
<li>CELIX-325 Bundle test sporadicly fails</li>
<li>CELIX-329 framework &ldquo;service_&rdquo; tests are outdates, some small bugs in the sources</li>
<li>CELIX-331 test configuraiton needs update for newer CMake</li>
<li>CELIX-332 filter tests absent, small bugs in the source</li>
<li>CELIX-334 Race Condition in Topology Manager causes spurious segfaults</li>
<li>CELIX-336 resolver_test doesn&rsquo;t compile</li>
<li>CELIX-343 configuration_unbind never called</li>
<li>CELIX-344 service tracker removes wrong service</li>
<li>CELIX-345 Typo in Dependency Manager interface</li>
<li>CELIX-346 celix-bootstrap problems</li>
<li>CELIX-347 Memory leaks in dm_service_dependency</li>
<li>CELIX-349 ServiceTracker update references list after invoking added callback</li>
<li>CELIX-350 shell_tui wrong handling service reference</li>
<li>CELIX-354 Coverity High Impact issues</li>
<li>CELIX-356 Import libraries not supported in revamped cmake commands</li>
<li>CELIX-357 Coverity Medium Impact issues</li>
<li>CELIX-358 Coverity Low+New High Impact issues</li>
<li>CELIX-359 Android build stopped working</li>
<li>CELIX-360 Coverity leftover issues</li>
<li>CELIX-361 etcd_watcher notifications loss when ETCD transaction rate is high</li>
<li>CELIX-363 Memory leak in DFI exportRegistration_create</li>
<li>CELIX-364 Incorrect destroy of dependency manager info struct</li>
<li>CELIX-366 eclipse launch file not correctly generated</li>
<li>CELIX-367 Memory leak in properties</li>
<li>CELIX-369 Tests fail with sanitizer</li>
<li>CELIX-371 Due to a fixed maximum length of lines in property file not all bundles are started</li>
<li>CELIX-372 serviceRegistry_clearReferencesFor warning info unclear</li>
<li>CELIX-373 Endpoint Server number is fixed and too low</li>
<li>CELIX-374 RTLD_NODELETE flag</li>
<li>CELIX-375 Topology manager deadlocks when interacts with dependency manager</li>
<li>CELIX-377 wrong rpath setup in CMake files</li>
<li>CELIX-378 Travis build errors on Max OSX</li>
<li>CELIX-379 Extend cmake fucntion add_deploy with an option to specify the launcher</li>
<li>CELIX-376 serviceRegistration sometimes paired to invalidated serviceReference</li>
<li>CELIX-380 PROPERTIES_FOR_EACH macro does not iterate over all keys</li>
<li>CELIX-381 Invoke set for dependency manager called before suspending the component</li>
</ul>


                </div>
            </div>
        </div>
    </div>
</div>


<footer class="py-3 bg-secondary">
    <div class="container">
        <div class="row">
            <div class="col-md-8 text-center">
                <p class="m-0 text-white">
                    Copyright &copy; 2024 The Apache Software Foundation, Licensed under
                    the <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>.
                    <br>
                    Apache Celix, Celix, Apache, the Apache feather logo and the Apache Celix logo are trademarks of The Apache Software Foundation.
                </p>
            </div>
            <div class="col-md-4 text-center">
                <a href="https://www.apache.org/events/current-event.html" target="_blank">
                    <img src="https://www.apache.org/events/current-event-234x60.png" title="Apache Event" width="234" height="60" border="0">
                </a>
            </div>
        </div>
    </div>
</footer>


<script src="/assets/js/jquery.min.js"></script>
<script src="/assets/js/bootstrap.bundle.min.js"></script>


</body>
</html>
