celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [49/60] [abbrv] [partial] celix git commit: CELIX-424: Cleans up the directory structure. Moves all libraries to the libs subdir and all bundles to the bundles subdir
Date Sun, 27 May 2018 18:52:57 GMT
http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/private/src/activator.c
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/private/src/activator.c b/bundles/config_admin/service/private/src/activator.c
new file mode 100644
index 0000000..2f94efa
--- /dev/null
+++ b/bundles/config_admin/service/private/src/activator.c
@@ -0,0 +1,136 @@
+/**
+ *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.
+ */
+/*
+ * activator.c
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* celix.framework.public */
+#include "bundle_activator.h"
+#include "bundle_context.h"
+#include "celix_errno.h"
+#include "service_factory.h"
+#include "service_registration.h"
+/* celix.config_admin.public */
+#include "configuration_admin.h"
+/* celix.config_admin.private */
+#include "configuration_admin_factory.h"
+
+
+struct config_admin_bundle {
+	bundle_context_pt context;
+	service_registration_pt configAdminFactoryReg;
+    service_factory_pt configAdminFactory;
+	configuration_admin_factory_pt configAdminFactoryInstance;
+};
+
+typedef struct config_admin_bundle *config_admin_bundle_t;
+
+
+/* -------------------- Implements BundleActivator ---------------------------- */
+
+celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) {
+
+	celix_status_t status = CELIX_SUCCESS;
+
+	config_admin_bundle_t bi = calloc(1, sizeof(struct config_admin_bundle));
+
+	if (bi == NULL) {
+
+		status = CELIX_ENOMEM;
+
+	} else {
+
+		(*userData) = bi;
+		bi->context = context;
+		bi->configAdminFactoryReg = NULL;
+		bi->configAdminFactoryInstance = NULL;
+
+		status = CELIX_SUCCESS;
+
+	}
+	return status;
+}
+
+celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
+
+	celix_status_t status;
+
+	config_admin_bundle_t bi = (config_admin_bundle_t) userData;
+
+
+	status = configurationAdminFactory_create(bi->context, &bi->configAdminFactory, &bi->configAdminFactoryInstance);
+	if (status != CELIX_SUCCESS){
+		return status;
+	}
+
+	status = bundleContext_registerServiceFactory(bi->context, (char *) CONFIGURATION_ADMIN_SERVICE_NAME, bi->configAdminFactory, NULL, &bi->configAdminFactoryReg);
+	if (status != CELIX_SUCCESS){
+		return status;
+	}
+	printf("[ SUCCESS ]: Activator - ConfigAdminFactory Registered \n");
+
+	status = configurationAdminFactory_start(bi->configAdminFactoryInstance);
+	if (status != CELIX_SUCCESS){
+		return status;
+	}
+
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
+
+	celix_status_t status = CELIX_SUCCESS;
+
+	config_admin_bundle_t bi = (config_admin_bundle_t) userData;
+	configurationAdminFactory_stop(bi->configAdminFactoryInstance);
+	serviceRegistration_unregister(bi->configAdminFactoryReg);
+	configurationAdminFactory_destroy(context, bi->configAdminFactoryInstance);
+
+	bi->configAdminFactoryReg = NULL;
+    free(bi->configAdminFactory);
+
+
+	return status;
+}
+
+celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) {
+
+    config_admin_bundle_t bi = (config_admin_bundle_t) userData;
+
+    free(bi);
+
+	return CELIX_SUCCESS;
+}
+
+
+
+
+
+
+

http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/private/src/configuration_admin_factory.c
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/private/src/configuration_admin_factory.c b/bundles/config_admin/service/private/src/configuration_admin_factory.c
new file mode 100644
index 0000000..f8871d9
--- /dev/null
+++ b/bundles/config_admin/service/private/src/configuration_admin_factory.c
@@ -0,0 +1,211 @@
+/**
+ *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.
+ */
+/*
+ * configuration_admin_factory.c
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#include <celixbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* celix.config_admin.ConfigAdminFactory */
+#include "configuration_admin_factory.h"
+
+/* celix.framework.Patch*/
+#include "framework_patch.h"
+/* celix.config_admin.public*/
+#include "configuration_admin.h"
+/* celix.config_admin.private*/
+#include "configuration_admin_impl.h"
+#include "managed_service_tracker.h"
+#include "configuration_store.h"
+
+
+struct configuration_admin_factory{
+	bundle_context_pt 	context;
+
+//	configuration_permission_t configurationPermission;
+//	event_dispatcher_t eventDispatcher;
+//	plugin_manager_t pluginManager;
+	managed_service_tracker_pt managedServiceTrackerHandle;
+	service_tracker_pt managedServiceTracker;
+//	managed_service_factory_ptracker_t managedServiceFactoryTracker;
+	configuration_store_pt configurationStore;
+
+};
+
+
+celix_status_t configurationAdminFactory_getService(void *factory, bundle_pt bundle, service_registration_pt registration, void **service);
+celix_status_t configurationAdminFactory_ungetService(void *factory, bundle_pt bundle, service_registration_pt registration, void **service);
+
+
+/* ========== CONSTRUCTOR =========== */
+
+/* ---------- public ---------- */
+
+celix_status_t configurationAdminFactory_create( bundle_context_pt context, service_factory_pt *factory, configuration_admin_factory_pt *instance){
+
+	celix_status_t status;
+
+	configuration_admin_factory_pt this = calloc(1, sizeof(*this));
+	configuration_store_pt configurationStore;
+	managed_service_tracker_pt managedServiceTrackerHandle;
+	service_tracker_pt managedServiceTracker;
+
+	// (1) SERVICE FACTORY
+	*factory = calloc(1, sizeof(**factory));
+    if (!*factory) {
+        return CELIX_ENOMEM;
+    }
+    // (2) FACTORY DATA
+	if (!this){
+		printf("[ ERROR ]: ConfigAdminFactory - Not initialized \n");
+		return CELIX_ENOMEM;
+	}
+	// (2.1) CONFIGURATION STORE
+	status = configurationStore_create(context, this, &configurationStore);
+	if (status != CELIX_SUCCESS){
+		return status;
+	}
+	// (2.2) SERVICE TRACKER
+	status = managedServiceTracker_create(context, this, configurationStore, &managedServiceTrackerHandle, &managedServiceTracker);
+	if (status != CELIX_SUCCESS){
+		return status;
+	}
+	// (3) INITIALIZATION
+	this->context = context;
+
+	this->managedServiceTrackerHandle = managedServiceTrackerHandle;
+	this->managedServiceTracker = managedServiceTracker;
+	this->configurationStore = configurationStore;
+
+	(*factory)->handle = this;
+	(*factory)->getService = configurationAdminFactory_getService;
+	(*factory)->ungetService = configurationAdminFactory_ungetService;
+
+	*instance = this;
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t configurationAdminFactory_destroy( bundle_context_pt context, configuration_admin_factory_pt instance){
+	managedServiceTracker_destroy(context, instance->managedServiceTrackerHandle, instance->managedServiceTracker);
+	configurationStore_destroy(instance->configurationStore);
+	free(instance);
+	return CELIX_SUCCESS;
+}
+/* ========== IMPLEMENTS SERVICE FACTORY ========== */
+
+/* ---------- public ---------- */
+
+celix_status_t configurationAdminFactory_getService(void *handle, bundle_pt bundle, service_registration_pt registration, void **service){
+
+	celix_status_t status;
+
+	configuration_admin_factory_pt configAdminFactory = (configuration_admin_factory_pt)handle;
+	configuration_admin_service_pt confAdminService;
+
+	// TODO
+	// (1) reference = registration.getServiceReference
+	// (2) eventDispatcher.setServiceReference(reference);
+
+	// (3) return new ConfigurationAdminImpl(this, configurationStore, bundle);
+	status = configurationAdmin_create(configAdminFactory, configAdminFactory->configurationStore, bundle, &confAdminService);
+	if (status != CELIX_SUCCESS){
+		return status;
+	}
+
+	/* DEBUG CODE *
+		char* location;
+		bundle_getBundleLocation(bundle, &location);
+		printf("[ SUCCESS ]: ConfigAdminFactory - get configAdminService (bundle=%s) \n ",location);
+	* END DEBUG CODE */
+
+	(*service) = confAdminService;
+
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t configurationAdminFactory_ungetService(void *factory, bundle_pt bundle, service_registration_pt registration, void **service) {
+
+    configuration_admin_service_pt confAdminService = (*service);
+
+    configurationAdmin_destroy(&confAdminService);
+
+    return CELIX_SUCCESS;
+}
+
+
+/* ========== IMPLEMENTATION ========== */
+
+/* ---------- public ---------- */
+
+celix_status_t configurationAdminFactory_start(configuration_admin_factory_pt factory){
+
+	celix_status_t status;
+	printf("%s\n", __func__);
+	status = serviceTracker_open(factory->managedServiceTracker);
+	if( status!=CELIX_SUCCESS ){
+		printf("[ ERROR ]: ConfigAdminFactory - ManagedServiceTracker not opened \n");
+		return status;
+	}
+
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configurationAdminFactory_stop(configuration_admin_factory_pt factory){
+	celix_status_t status = serviceTracker_close(factory->managedServiceTracker);
+	return status;;
+}
+
+celix_status_t configurationAdminFactory_checkConfigurationPermission(configuration_admin_factory_pt factory){
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configurationAdminFactory_dispatchEvent(configuration_admin_factory_pt factory, int type, char *factoryPid, char *pid){
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configurationAdminFactory_notifyConfigurationUpdated(configuration_admin_factory_pt factory, configuration_pt configuration, bool isFactory){
+
+	if (isFactory == true){
+
+		return CELIX_SUCCESS;
+
+	}else{
+
+		return managedServiceTracker_notifyUpdated(factory->managedServiceTrackerHandle,configuration);
+
+	}
+
+}
+
+celix_status_t configurationAdminFactory_notifyConfigurationDeleted(configuration_admin_factory_pt factory, configuration_pt configuration, bool isFactory){
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configurationAdminFactory_modifyConfiguration(configuration_admin_factory_pt factory, service_reference_pt reference, properties_pt properties){
+	return CELIX_SUCCESS;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/private/src/configuration_admin_impl.c
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/private/src/configuration_admin_impl.c b/bundles/config_admin/service/private/src/configuration_admin_impl.c
new file mode 100644
index 0000000..6d01cb0
--- /dev/null
+++ b/bundles/config_admin/service/private/src/configuration_admin_impl.c
@@ -0,0 +1,208 @@
+/**
+ *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.
+ */
+/*
+ * configuration_admin_impl.c
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* celix.config_admin.ConfigAdmin */
+#include "configuration_admin_impl.h"
+
+/* celix.framework.public */
+#include "utils.h"
+/* celix.framework_patch*/
+#include "framework_patch.h"
+/* celix.config_admin.private*/
+#include "configuration_impl.h"
+
+
+static celix_status_t configurationAdmin_checkPid(char *pid);
+
+
+/* ========== CONSTRUCTOR ========== */
+
+celix_status_t configurationAdmin_create(configuration_admin_factory_pt factory, configuration_store_pt store, bundle_pt bundle,
+										 configuration_admin_service_pt *service){
+
+	*service = calloc(1, sizeof(**service));
+
+
+	if(!*service){
+		printf("[ ERROR ]: ConfigAdmin - Not initialized(ENOMEM) \n");
+		return CELIX_ENOMEM;
+	}
+
+	configuration_admin_pt this = calloc(1, sizeof(*this));
+	if (!this){
+		printf("[ ERROR ]: ConfigAdmin - Not initialized \n");
+		return CELIX_ENOMEM;
+	}
+
+	this->bundle = bundle;
+
+	this->configurationAdminFactory = factory;
+	this->configurationStore = store;
+
+	(*service)->configAdmin = this;
+	(*service)->createFactoryConfiguration = configurationAdmin_createFactoryConfiguration;
+	(*service)->createFactoryConfiguration2 = configurationAdmin_createFactoryConfiguration2;
+	(*service)->getConfiguration = configurationAdmin_getConfiguration;
+	(*service)->getConfiguration2 = configurationAdmin_getConfiguration2;
+	(*service)->listConfigurations = configurationAdmin_listConfigurations;
+
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t configurationAdmin_destroy(configuration_admin_service_pt *service) {
+    free((*service)->configAdmin);
+    free(*service);
+
+    return CELIX_SUCCESS;
+}
+/* ========== IMPLEMENTATION ========== */
+
+
+/* ---------- public ---------- */
+
+celix_status_t configurationAdmin_createFactoryConfiguration(configuration_admin_pt configAdmin, char *factoryPid, configuration_pt *configuration){
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configurationAdmin_createFactoryConfiguration2(configuration_admin_pt configAdmin, char *factoryPid, char *location, configuration_pt *configuration){
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configurationAdmin_getConfiguration(configuration_admin_pt configAdmin, char *pid, configuration_pt *configuration){
+	configuration_pt config;
+
+	const char* configAdminBundleLocation;
+	const char* configBundleLocation;
+
+
+	// (1) configurationAdmin.checkPid
+	if ( configurationAdmin_checkPid(pid) != CELIX_SUCCESS ){
+		*configuration = NULL;
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	// (2) bundle.getLocation
+	if ( bundle_getBundleLocation(configAdmin->bundle,&configAdminBundleLocation) != CELIX_SUCCESS ){
+		*configuration = NULL;
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	// (3) delegates to configurationStore.getConfiguration
+	if ( configurationStore_getConfiguration(configAdmin->configurationStore, pid, (char*)configAdminBundleLocation, &config) != CELIX_SUCCESS ){
+		*configuration = NULL;
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+
+	/* ---------- pseudo code ---------- */
+	/*
+
+	(4) is the configuration already bound? / configBundleLocation != NULL ?
+		YES - are the Configuration and the ConfigAdmin bound to the same bundle?
+			NO - check permission
+
+	(5) config.bind(bundle)
+		if the Configuration is not bound, then we bind it up with the ConfigAdmin bundle
+		in case of be bound, the function does not bind it up with ConfigAdmin bundle
+
+	*/
+
+
+	// (4) config.getBundleLocation != NULL ?
+	if ( configuration_getBundleLocation2(config->handle,false,(char**)&configBundleLocation) == CELIX_SUCCESS ){
+
+		if ( strcmp(configAdminBundleLocation,configBundleLocation) != 0 ){
+
+			if ( configurationAdminFactory_checkConfigurationPermission(configAdmin->configurationAdminFactory) != CELIX_SUCCESS ){
+				printf("[ ERROR ]: ConfigAdmin - Config. Permission \n");
+				*configuration = NULL;
+				return CELIX_ILLEGAL_STATE; //TODO checkConfigurationPermission not yet implemented, everything is allowed
+			}
+		}
+	}
+
+	// (5) config.bind(bundle)
+	bool dummy;
+	if ( configuration_bind(config->handle, configAdmin->bundle, &dummy) != CELIX_SUCCESS){
+		*configuration = NULL;
+		printf("[ ERROR]: ConfigAdmin - bind Config.");
+		return CELIX_ILLEGAL_STATE;
+	}
+
+	*configuration = config;
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t configurationAdmin_getConfiguration2(configuration_admin_pt configAdmin, char *pid, char *location, configuration_pt *configuration){
+
+//	celix_status_t status;
+//
+//	status = configurationAdmin_checkPid(pid);
+//	if (status != CELIX_SUCCESS){
+//		*configuration = NULL;
+//		return status;
+//	}
+//
+//	status = configurationAdminFactory_checkConfigurationPermission(configAdmin->configurationAdminFactory);
+//	if (status != CELIX_SUCCESS){
+//		*configuration = NULL;
+//		return status;
+//	}
+//
+//	configuration_pt config;
+//	status = configurationStore_getConfiguration(configAdmin->configurationStore, pid, location, &config);
+//	if (status != CELIX_SUCCESS){
+//		*configuration = NULL;
+//		return status;
+//	}
+//
+//	printf("SUCCESS get Configuration");
+//	*configuration = config;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configurationAdmin_listConfigurations(configuration_admin_pt configAdmin, char *filter, array_list_pt *configurations){
+	return CELIX_SUCCESS;
+}
+
+/* ---------- private ---------- */
+
+celix_status_t configurationAdmin_checkPid(char *pid){
+
+	if (pid == NULL){
+		printf("[ ERROR ]: PID cannot be null");
+		return CELIX_ILLEGAL_ARGUMENT;
+	} else {
+		return CELIX_SUCCESS;
+	}
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/private/src/configuration_impl.c
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/private/src/configuration_impl.c b/bundles/config_admin/service/private/src/configuration_impl.c
new file mode 100644
index 0000000..ed3c8c6
--- /dev/null
+++ b/bundles/config_admin/service/private/src/configuration_impl.c
@@ -0,0 +1,683 @@
+/**
+ *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.
+ */
+/*
+ * configuration_impl.c
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/*celix.config_admin.Configuration */
+//#include "configuration.h"
+#include "configuration_impl.h"
+#include "celix_threads.h"
+
+
+/* celix.framework */
+#include "bundle.h"
+#include "constants.h"
+#include "utils.h"
+/* celix.framework_patch*/
+#include "framework_patch.h"
+/* celix.config_admin.public*/
+#include "configuration_event.h"
+#include "configuration_admin.h"
+/* celix.config_admin.private*/
+#include "configuration_admin_factory.h"
+#include "configuration_store.h"
+
+struct configuration_impl {
+
+	configuration_admin_factory_pt configurationAdminFactory;
+	configuration_store_pt 		configurationStore;
+
+	configuration_pt	        configuration_interface;
+	char 						*bundleLocation;
+	char 						*factoryPid;
+	char 						*pid;
+	properties_pt 				dictionary;
+
+	bool 						deleted; // Not sure if it's needed
+	bundle_pt 					boundBundle;
+
+	celix_thread_mutex_t        mutex;
+};
+
+
+
+// External interface functions
+// see configuration.h
+celix_status_t configuration_delete(void* configuration);
+celix_status_t configuration_equals(void* thisConfiguration, void* otherConfiguration, bool *equals);
+celix_status_t configuration_getBundleLocation(void *configuration, char **bundleLocation);
+celix_status_t configuration_getFactoryPid(void *handle, char **factoryPid);
+celix_status_t configuration_hashCode(void *handle, int *hashCode);
+celix_status_t configuration_setBundleLocation(void *handle, char *bundleLocation);
+celix_status_t configuration_update(void *handle, properties_pt properties);
+
+
+// Configuration admin internal functions
+// see configuration_impl.h
+//static celix_status_t configuration_getBundleLocation2(configuration_impl_pt configuration, bool checkPermission, char **location);
+
+
+// static functions
+
+// org.eclipse.equinox.internal.cm
+static celix_status_t configuration_getFactoryPid2(configuration_impl_pt configuration, bool checkDeleted, char **factoryPid);
+static celix_status_t configuration_getPid2(configuration_impl_pt configuration, bool checkDeleted, char **pid);
+static celix_status_t configuration_updateDictionary(configuration_impl_pt configuration, properties_pt properties);
+
+// org.apache.felix.cm.impl
+static celix_status_t configuration_setBundleLocationProperty(configuration_impl_pt configuration, properties_pt *properties);
+static celix_status_t configuration_setAutoProperties(configuration_impl_pt configuration, properties_pt *properties, bool withBundleLocation);
+
+
+static celix_status_t configuration_checkDeleted(configuration_impl_pt configuration);
+
+/* ========== CONSTRUCTOR ========== */
+
+/* ---------- public ---------- */
+
+celix_status_t configuration_create( configuration_admin_factory_pt factory, configuration_store_pt store,
+									 char *factoryPid, char *pid, char *bundleLocation,
+									 configuration_pt *configuration){
+
+	struct configuration *config;
+	struct configuration_impl *conf_impl;
+    celix_thread_mutexattr_t	mutex_attr;
+
+    config = calloc(1, sizeof(struct configuration));
+    if (config == NULL) return CELIX_ENOMEM;
+    conf_impl = calloc(1, sizeof(struct configuration_impl));
+    if (conf_impl == NULL) {
+    	free (config);
+    	return CELIX_ENOMEM;
+    }
+
+    config->configuration_delete = configuration_delete;
+    config->configuration_equals = configuration_equals;
+    config->configuration_getBundleLocation = configuration_getBundleLocation;
+    config->configuration_getFactoryPid = configuration_getFactoryPid;
+    config->configuration_getPid = configuration_getPid;
+    config->configuration_getProperties = configuration_getProperties;
+    config->configuration_hashCode = configuration_hashCode;
+    config->configuration_setBundleLocation = configuration_setBundleLocation;
+    config->configuration_update = configuration_update;
+/*
+	config = calloc(1,sizeof(struct configuration));
+	if(!config){
+		printf("[ ERROR ]: Configuration{PID=%s} - Not created (ENOMEM) \n",pid);
+		return CELIX_ENOMEM;
+	}
+*/
+	conf_impl->configurationAdminFactory  = factory;
+	conf_impl->configurationStore = store;
+
+	if (factoryPid != NULL)
+		conf_impl->factoryPid = strdup(factoryPid);
+	else
+		conf_impl->factoryPid = NULL;
+	if (pid != NULL)
+		conf_impl->pid = strdup(pid);
+	else
+		conf_impl->pid = NULL;
+	if (bundleLocation != NULL)
+		conf_impl->bundleLocation = strdup(bundleLocation);
+	else
+		conf_impl->bundleLocation = NULL;
+	conf_impl->dictionary = NULL;
+
+	conf_impl->deleted = false;
+	conf_impl->boundBundle = NULL;
+
+    celixThreadMutexAttr_create(&mutex_attr);
+    celixThreadMutexAttr_settype(&mutex_attr, CELIX_THREAD_MUTEX_RECURSIVE);  // why recursive?
+	if( celixThreadMutex_create(&conf_impl->mutex, &mutex_attr) != CELIX_SUCCESS ){
+		printf("[ ERROR ]: Configuration{PID=%s} - Not created (MUTEX) \n",pid);
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	conf_impl->configuration_interface = config;
+	config->handle = conf_impl;
+	*configuration = config;
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_create2(configuration_admin_factory_pt factory, configuration_store_pt store,
+									 properties_pt dictionary,
+									 configuration_pt *configuration){
+
+	configuration_pt config;
+	configuration_impl_pt conf_impl;
+
+    celix_thread_mutexattr_t	mutex_attr;
+    const char *value;
+
+	config = calloc(1, sizeof(struct configuration));
+    if (config == NULL) return CELIX_ENOMEM;
+    conf_impl = calloc(1, sizeof(struct configuration_impl));
+    if (conf_impl == NULL) {
+    	free (config);
+    	return CELIX_ENOMEM;
+    }
+
+    config->configuration_delete = configuration_delete;
+    config->configuration_equals = configuration_equals;
+    config->configuration_getBundleLocation = configuration_getBundleLocation;
+    config->configuration_getFactoryPid = configuration_getFactoryPid;
+    config->configuration_getPid = configuration_getPid;
+    config->configuration_getProperties = configuration_getProperties;
+    config->configuration_hashCode = configuration_hashCode;
+    config->configuration_setBundleLocation = configuration_setBundleLocation;
+    config->configuration_update = configuration_update;
+
+	conf_impl->configurationAdminFactory  = factory;
+	conf_impl->configurationStore = store;
+
+	value = properties_get(dictionary,(char *)SERVICE_FACTORYPID);
+	if (value != NULL)
+		conf_impl->factoryPid = strdup(value);
+	else
+		conf_impl->factoryPid = NULL;
+	value = properties_get(dictionary, (char *)OSGI_FRAMEWORK_SERVICE_PID);
+	if (value != NULL)
+		conf_impl->pid = strdup(value);
+	else
+		conf_impl->pid = NULL;
+	value = properties_get(dictionary, (char *)SERVICE_BUNDLELOCATION);
+	if (value != NULL)
+		conf_impl->bundleLocation = strdup(value);
+	else
+		conf_impl->bundleLocation = NULL;
+	conf_impl->dictionary = NULL;
+
+	conf_impl->deleted = false;
+	conf_impl->boundBundle = NULL;
+
+    celixThreadMutexAttr_create(&mutex_attr);
+    celixThreadMutexAttr_settype(&mutex_attr, CELIX_THREAD_MUTEX_RECURSIVE);  // why recursive?
+	if( celixThreadMutex_create(&conf_impl->mutex, &mutex_attr) != CELIX_SUCCESS ){
+		printf("[ ERROR ]: Configuration{PID=%s} - Not created (MUTEX) \n", conf_impl->pid);
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+    celixThreadMutexAttr_destroy(&mutex_attr);
+	configuration_updateDictionary(conf_impl, dictionary);
+
+	conf_impl->configuration_interface = config;
+	config->handle = conf_impl;
+	*configuration = config;
+	return CELIX_SUCCESS;
+
+}
+
+
+/* ========== IMPLEMENTS CONFIGURATION ========== */
+
+/* ---------- public ---------- */
+// specifications
+
+celix_status_t configuration_delete(void *handle){
+	configuration_impl_pt conf = (configuration_impl_pt)handle;
+
+	printf("TODO: Implement configuration_delete\n");
+	celixThreadMutex_destroy(&conf->mutex);
+	if (conf->factoryPid != NULL)
+		free(conf->factoryPid);
+	if (conf->pid != NULL)
+		free(conf->pid);
+	if (conf->bundleLocation != NULL)
+		free(conf->bundleLocation);
+	free(conf->configuration_interface);
+	free(conf);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_equals(void* thisConfiguration, void *otherConfiguration, bool *equals){
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_getBundleLocation(void *handle, char **bundleLocation){
+	return configuration_getBundleLocation2( handle, true, bundleLocation);
+}
+
+celix_status_t configuration_getFactoryPid(void *handle, char **factoryPid){
+	return configuration_getFactoryPid2(handle, true, factoryPid);
+}
+
+celix_status_t configuration_getPid(void *handle, char **pid){
+	return configuration_getPid2(handle, true, pid);
+}
+
+celix_status_t configuration_getProperties(void *handle, properties_pt *properties){
+
+    configuration_impl_pt conf = (configuration_impl_pt) handle;
+
+	properties_pt copy = conf->dictionary;
+
+	// (1) configuration.lock
+	configuration_lock(conf);
+
+	// (2) configuration.checkDeleted
+	if ( configuration_checkDeleted(conf) != CELIX_SUCCESS ){
+		configuration_unlock(conf);
+		return CELIX_ILLEGAL_STATE;
+	}
+	// (3) Have the Configuration properties ?
+	if ( conf->dictionary == NULL ){
+		*properties = NULL;
+		configuration_unlock(conf);
+		return CELIX_SUCCESS;
+	}
+
+	// (4) configuration.setAutoProperties
+	if ( configuration_setAutoProperties(conf, &copy, false) != CELIX_SUCCESS ){
+		configuration_unlock(conf);
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	// (5) return
+	*properties = copy;
+	configuration_unlock(conf);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_hashCode(void *handle, int *hashCode){
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_setBundleLocation(void *handle, char *bundleLocation){
+
+	configuration_impl_pt	conf = (configuration_impl_pt)handle;
+	configuration_lock(conf);
+
+	if ( configuration_checkDeleted(conf) != CELIX_SUCCESS ){
+		configuration_unlock(conf);
+		return CELIX_ILLEGAL_STATE;
+	}
+
+	//	TODO configurationAdminFactory.checkConfigurationPermission
+
+	conf->bundleLocation = bundleLocation;
+	conf->boundBundle = NULL; // always reset the boundBundle when setBundleLocation is called
+
+	configuration_unlock(conf);
+
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_update(void *handle, properties_pt properties){
+
+	configuration_impl_pt conf = (configuration_impl_pt)handle;
+
+
+	celix_status_t status;
+
+	// (1)
+	configuration_lock(conf);
+
+	// (2)
+	if ( configuration_checkDeleted(conf) != CELIX_SUCCESS ){
+		configuration_unlock(conf);
+		return CELIX_ILLEGAL_STATE;
+	}
+	// (3)
+	configuration_updateDictionary(conf, properties);
+
+	// (4)
+	status = configurationStore_saveConfiguration(conf->configurationStore, conf->pid, conf->configuration_interface);
+	if (status != CELIX_SUCCESS){
+		configuration_unlock(conf);
+		return status;
+	}
+
+	// (5)
+	bool isFactory;
+	if (conf->factoryPid == NULL){
+		isFactory = false;
+	} else{
+		isFactory = true;
+	}
+
+	status = configurationAdminFactory_notifyConfigurationUpdated(conf->configurationAdminFactory, conf->configuration_interface, isFactory);
+	if (status != CELIX_SUCCESS){
+		configuration_unlock(conf);
+		return status;
+	}
+
+	// (6)
+	status = configurationAdminFactory_dispatchEvent(conf->configurationAdminFactory, CONFIGURATION_EVENT_CM_UPDATED, conf->factoryPid, conf->pid);
+	if (status != CELIX_SUCCESS){
+		configuration_unlock(conf);
+		return status;
+	}
+
+	// (7)
+	configuration_unlock(conf);
+	return CELIX_SUCCESS;
+}
+
+/* ---------- protected ---------- */
+// org.eclipse.equinox.cm.impl
+
+celix_status_t configuration_lock(configuration_impl_pt configuration){
+//	printf("[ DEBUG ]: Configuration{PID=%s} - LOCK \n",configuration->pid);
+	celixThreadMutex_lock(&configuration->mutex);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_unlock(configuration_impl_pt configuration){
+//	printf("[ DEBUG ]: Configuration{PID=%s} - UNLOCK \n",configuration->pid);
+	celixThreadMutex_unlock(&configuration->mutex);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_checkLocked(configuration_impl_pt configuration){
+	// Not used
+	return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_bind(configuration_impl_pt configuration, bundle_pt bundle, bool *isBind){
+
+//	printf("[ DEBUG ]: Configuration{PID=%s} - bind(START) \n",configuration->pid);
+
+	char *bundleLocation;
+
+	configuration_lock(configuration);
+
+	/* ----------- BINDING -------------- */
+
+	// (1): it's the configuration already bound?
+	if ( configuration->boundBundle == NULL ){// (1): No
+
+		// (2): it's the configuration located?
+		if ( configuration->bundleLocation != NULL ){//(2): Yes
+
+			if ( bundle_getBundleLocation(bundle, (const char**)&bundleLocation) != CELIX_SUCCESS){
+				configuration_unlock(configuration);
+				return CELIX_ILLEGAL_ARGUMENT;
+			}
+
+			// (3): bundle and configuration have the same location?
+			if ( strcmp(configuration->bundleLocation, bundleLocation) == 0 ){ // (3): Yes
+				// bind up configuration with bundle
+				configuration->boundBundle = bundle;
+//				printf("[ DEBUG ]: Configuration{PID=%s} - bind (bound with Bundle{%s}) \n",configuration->pid,bundleLocation);
+			}
+			// (3): No
+
+		}else{// (2): No
+			// bind up configuration with bundle
+			configuration->boundBundle = bundle;
+//			printf("[ DEBUG ]: Configuration{PID=%s}) - bind (not located and now bound with Bundle) \n",configuration->pid);
+		}
+
+	}// (1): Yes
+
+	/* ------------ RETURN -------------- */
+
+	bool bind;
+	if(configuration->boundBundle == bundle){
+		bind = true;
+	}else{
+		bind = false;
+	}
+
+	/* ------------- END ----------------- */
+	configuration_unlock(configuration);
+
+	*isBind = bind;
+//	printf("[ DEBUG ]: Configuration{PID=%s} - bind(END) \n",configuration->pid);
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t configuration_unbind(configuration_impl_pt configuration, bundle_pt bundle){
+	configuration->boundBundle = NULL;
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configuration_getBundleLocation2(configuration_impl_pt configuration, bool checkPermission, char** location){
+
+	celix_status_t status;
+
+	// (1)
+	configuration_lock(configuration);
+
+	// (2)
+	if( configuration_checkDeleted(configuration) != CELIX_SUCCESS ){
+		configuration_unlock(configuration);
+		return CELIX_ILLEGAL_STATE;
+	}
+	// (3)
+	if ( checkPermission ){
+
+		if ( configurationAdminFactory_checkConfigurationPermission(configuration->configurationAdminFactory) != CELIX_SUCCESS ){
+			return CELIX_ILLEGAL_STATE; // TODO configurationAdmin, not yet implemented
+		}
+	}
+
+	// (4)
+	if ( configuration->bundleLocation ){
+		*location = configuration->bundleLocation;
+		configuration_unlock(configuration);
+		return CELIX_SUCCESS;
+	}
+
+	// (5)
+	if ( configuration->boundBundle != NULL ){
+		status = bundle_getBundleLocation(configuration->boundBundle,(const char**)location);
+		configuration_unlock(configuration);
+		return status;
+	}
+
+	// (6)
+	*location = NULL;
+	configuration_unlock(configuration);
+	return CELIX_SUCCESS;
+}
+
+static celix_status_t configuration_getFactoryPid2(configuration_impl_pt configuration, bool checkDeleted, char **factoryPid){
+	return CELIX_SUCCESS;
+}
+
+static celix_status_t configuration_getPid2(configuration_impl_pt configuration, bool checkDeleted, char **pid){
+
+	configuration_lock(configuration);
+
+	if ( checkDeleted ){
+		if ( configuration_checkDeleted(configuration) != CELIX_SUCCESS ){
+			configuration_unlock(configuration);
+			return CELIX_ILLEGAL_STATE;
+		}
+	}
+
+	*pid = configuration->pid;
+
+	configuration_unlock(configuration);
+
+	return CELIX_SUCCESS;
+}
+
+// org.eclipse.equinox.internal.cm modified to fit with org.apache.felix.cm.impl
+// change due to ConfigurationStore implementation
+celix_status_t configuration_getAllProperties(configuration_impl_pt configuration, properties_pt *properties){
+
+	celix_status_t status;
+
+	properties_pt copy = NULL;
+
+	// (1) configuration.lock
+	configuration_lock(configuration);
+
+	// (2) configuration.deleted ?
+	if( configuration->deleted ){
+		*properties = NULL;
+		configuration_unlock(configuration);
+		return CELIX_SUCCESS;
+	}
+
+	// (3) configuration.getProps
+	if( configuration_getProperties(configuration, &copy) != CELIX_SUCCESS){
+		configuration_unlock(configuration);
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	// (4) configuration.setProperties
+	if ( copy == NULL ){ //set all the automatic properties
+
+		copy = properties_create();
+		status = configuration_setAutoProperties(configuration, &copy, true);
+
+	}else{ // copy != NULL - only set service.bundleLocation
+
+		status = configuration_setBundleLocationProperty(configuration, &copy);
+
+	}
+
+	// (5) return
+	if (status == CELIX_SUCCESS){
+		*properties = copy;
+	}else{
+		*properties = NULL;
+	}
+
+	configuration_unlock(configuration);
+	return status;
+
+}
+
+celix_status_t configuration_isDeleted(configuration_impl_pt configuration, bool *isDeleted){
+	return CELIX_SUCCESS;
+}
+
+/* ---------- private ---------- */
+
+celix_status_t configuration_checkDeleted(configuration_impl_pt configuration){
+
+	if ( configuration->deleted ){
+		printf("[CELIX_ILLEGAL_STATE ]: configuration(pid=%s) deleted \n", configuration->pid);
+		return CELIX_ILLEGAL_STATE;
+	}
+
+	return CELIX_SUCCESS;
+}
+
+// configuration->dictionary must not contain keys reserved to ConfigAdmin (i.e. "service.pid")
+celix_status_t configuration_updateDictionary(configuration_impl_pt configuration, properties_pt properties){
+
+	properties_pt newDictionary = NULL;
+
+	if ( configuration->dictionary != NULL && configuration->dictionary != properties ){
+		properties_destroy(configuration->dictionary); //free
+	}
+
+	newDictionary = properties; // properties == NULL | properties != NULL
+
+	if ( newDictionary != NULL ){
+
+		hashMap_remove(newDictionary, (void *) OSGI_FRAMEWORK_SERVICE_PID);
+		hashMap_remove(newDictionary, (void *) SERVICE_FACTORYPID);
+		hashMap_remove(newDictionary, (void *) SERVICE_BUNDLELOCATION);
+	}
+
+	configuration->dictionary = newDictionary;
+	return CELIX_SUCCESS;
+
+}
+
+/* ========== IMPLEMENTATION ========== */
+
+/* ---------- protected ---------- */
+#if 0
+celix_status_t configuration_getPool(configuration_impl_pt configuration, apr_pool_t **pool){
+
+	printf("[ DEBUG ]: Configuration{PID=%s} - get Pool \n",configuration->pid);
+
+	configuration_lock(configuration);
+
+	*pool = configuration->pool;
+
+	configuration_unlock(configuration);
+
+	return CELIX_SUCCESS;
+}
+#endif
+/* ---------- private ---------- */
+// org.apache.felix.cm.impl
+
+
+// properties_pt as input and output
+celix_status_t configuration_setAutoProperties(configuration_impl_pt configuration, properties_pt *properties, bool withBundleLocation){
+
+	//(1) configuration.lock
+	configuration_lock(configuration);
+
+	// (2) set service.pid
+//    if (properties_get(*properties, (char*)OSGI_FRAMEWORK_SERVICE_PID) != NULL) {
+        properties_set(*properties, (char*)OSGI_FRAMEWORK_SERVICE_PID, configuration->pid);
+//    }
+
+	// (3) set factory.pid
+	if ( configuration->factoryPid != NULL ){
+		properties_set(*properties, (char*)SERVICE_FACTORYPID, configuration->factoryPid);
+	}
+
+	// (4) set service.bundleLocation
+	if ( withBundleLocation ){
+
+		if ( configuration_setBundleLocationProperty(configuration, properties) != CELIX_SUCCESS ){
+			configuration_unlock(configuration);
+			return CELIX_ILLEGAL_ARGUMENT;
+		}
+
+	}
+
+	// (5) return
+	configuration_unlock(configuration);
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t configuration_setBundleLocationProperty(configuration_impl_pt configuration, properties_pt *properties){
+
+	char *bundleLocation;
+
+	configuration_lock(configuration);
+
+	if( configuration_getBundleLocation(configuration, &bundleLocation) != CELIX_SUCCESS ){
+		configuration_unlock(configuration);
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if ( bundleLocation != NULL ) {
+		properties_set(*properties, (char*)SERVICE_BUNDLELOCATION, bundleLocation);
+	}
+
+	configuration_unlock(configuration);
+
+	return CELIX_SUCCESS;
+
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/private/src/configuration_store.c
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/private/src/configuration_store.c b/bundles/config_admin/service/private/src/configuration_store.c
new file mode 100644
index 0000000..37b091e
--- /dev/null
+++ b/bundles/config_admin/service/private/src/configuration_store.c
@@ -0,0 +1,417 @@
+/**
+ *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.
+ */
+/*
+ * configuration_store.c
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <limits.h>
+
+/* celix.config_admin.ConfigurationStore */
+#include "configuration_store.h"
+
+/* celix.utils */
+#include "hash_map.h"
+/* celix.framework */
+#include "properties.h"
+#include "utils.h"
+/* celix.config_admin.private*/
+#include "configuration_admin_factory.h"
+#include "configuration.h"
+#include "configuration_impl.h"
+
+#define STORE_DIR "store"
+#define PID_EXT ".pid"
+#define MAX_CONFIG_PROPERTY_LEN		128
+
+
+struct configuration_store {
+
+    bundle_context_pt context;
+
+    celix_thread_mutex_t mutex;
+
+    configuration_admin_factory_pt configurationAdminFactory;
+
+    hash_map_pt configurations;
+// int createdPidCount;
+
+};
+
+static celix_status_t configurationStore_createCache(configuration_store_pt store);
+static celix_status_t configurationStore_getConfigurationFile(char *pid, char* storePath, int *file);
+static celix_status_t configurationStore_writeConfigurationFile(int fd, properties_pt properties);
+static celix_status_t configurationStore_readCache(configuration_store_pt store);
+static celix_status_t configurationStore_readConfigurationFile(const char *name, int size, properties_pt *dictionary);
+static celix_status_t configurationStore_parseDataConfigurationFile(char *data, properties_pt *dictionary);
+
+/* ========== CONSTRUCTOR ========== */
+
+celix_status_t configurationStore_create(bundle_context_pt context, configuration_admin_factory_pt factory, configuration_store_pt *store) {
+
+    *store = calloc(1, sizeof(**store));
+
+    if (!*store) {
+        printf("[ ERROR ]: ConfigStore - Not initialized (ENOMEM) \n");
+        return CELIX_ENOMEM;
+    }
+
+    (*store)->context = context;
+
+    (*store)->configurationAdminFactory = factory;
+
+    (*store)->configurations = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL);
+//	(*store)->createdPidCount = 0;
+
+    if (configurationStore_createCache((*store)) != CELIX_SUCCESS) {
+        printf("[ ERROR ]: ConfigStore - Not initialized (CACHE) \n");
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    celix_status_t mutexStatus = celixThreadMutex_create(&(*store)->mutex, NULL);
+    if (mutexStatus != CELIX_SUCCESS) {
+        printf("[ ERROR ]: ConfigStore - Not initialized (MUTEX) \n");
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    configurationStore_readCache((*store));
+
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_destroy(configuration_store_pt store) {
+    celixThreadMutex_destroy(&store->mutex);
+    hashMap_destroy(store->configurations, false, true);
+    free(store);
+
+    return CELIX_SUCCESS;
+}
+
+/* ========== IMPLEMENTATION ==========  */
+
+/* ---------- public ---------- */
+// org.eclipse.equinox.internal.cm
+celix_status_t configurationStore_lock(configuration_store_pt store) {
+    celixThreadMutex_lock(&store->mutex);
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_unlock(configuration_store_pt store) {
+    celixThreadMutex_unlock(&store->mutex);
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_saveConfiguration(configuration_store_pt store, char *pid, configuration_pt configuration) {
+
+    celix_status_t status;
+
+    //(1) config.checkLocked
+
+    //(2) configurationStore.getFile
+    int configFile;
+    status = configurationStore_getConfigurationFile(pid, (char *) STORE_DIR, &configFile);
+    if (status != CELIX_SUCCESS) {
+        return status;
+    }
+
+    //(4) configProperties = config.getAllProperties
+
+    properties_pt configProperties = NULL;
+    status = configuration_getAllProperties(configuration->handle, &configProperties);
+    if (status != CELIX_SUCCESS) {
+        printf("[ ERROR ]: ConfigStore - config{PID=%s}.getAllProperties \n", pid);
+        return status;
+    }
+
+
+    //(5) configStore.writeFile(file,properties)
+    status = configurationStore_writeConfigurationFile(configFile, configProperties);
+
+    if (status != CELIX_SUCCESS) {
+        return status;
+    }
+
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_removeConfiguration(configuration_store_pt store, char *pid) {
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_getConfiguration(configuration_store_pt store, char *pid, char *location, configuration_pt *configuration) {
+
+    celix_status_t status;
+
+    configuration_pt config;
+    config = hashMap_get(store->configurations, pid);
+
+    if (config == NULL) {
+
+        status = configuration_create(store->configurationAdminFactory, store, NULL, pid, location, &config);
+        if (status != CELIX_SUCCESS) {
+            printf("[ ERROR ]: ConfigStore - getConfig(PID=%s) (unable to create) \n", pid);
+            return status;
+        }
+
+        hashMap_put(store->configurations, pid, config);
+    }
+
+    *configuration = config;
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_createFactoryConfiguration(configuration_store_pt store, char *factoryPid, char *location, configuration_pt *configuration) {
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_findConfiguration(configuration_store_pt store, char *pid, configuration_pt *configuration) {
+
+    *configuration = hashMap_get(store->configurations, pid);
+    return CELIX_SUCCESS;
+
+}
+
+celix_status_t configurationStore_getFactoryConfigurations(configuration_store_pt store, char *factoryPid, configuration_pt *configuration) {
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_listConfigurations(configuration_store_pt store, filter_pt filter, array_list_pt *configurations) {
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_unbindConfigurations(configuration_store_pt store, bundle_pt bundle) {
+    return CELIX_SUCCESS;
+}
+
+/* ---------- private ---------- */
+
+celix_status_t configurationStore_createCache(configuration_store_pt store) {
+
+    int result = mkdir((const char*) STORE_DIR, 0777);
+
+    if ((result == 0) || ((result == -1) && (errno == EEXIST))) {
+        return CELIX_SUCCESS;
+    }
+
+    printf("[ ERROR ]: ConfigStore - Create Cache \n");
+    return CELIX_FILE_IO_EXCEPTION;
+
+}
+
+celix_status_t configurationStore_getConfigurationFile(char *pid, char* storePath, int *file) {
+
+    // (1) The full path to the file
+    char fname[PATH_MAX];
+    strcpy(fname, storePath);
+    strcat(fname, "/");
+    strcat(fname, (const char *) pid);
+    strcat(fname, (const char *) PID_EXT);
+
+    // (2) configuration.getPool
+    // (3) file.open
+    if ((*file = open((const char*) fname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)) < 0) {
+        printf("[ ERROR ]: ConfigStore - getFile(IO_EXCEPTION) \n");
+        return CELIX_FILE_IO_EXCEPTION;
+    }
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_writeConfigurationFile(int file, properties_pt properties) {
+
+    if (properties == NULL || hashMap_size(properties) <= 0) {
+        return CELIX_SUCCESS;
+    }
+    // size >0
+
+    char buffer[256];
+
+    hash_map_iterator_pt iterator = hashMapIterator_create(properties);
+    while (hashMapIterator_hasNext(iterator)) {
+
+        hash_map_entry_pt entry = hashMapIterator_nextEntry(iterator);
+
+        char* key = hashMapEntry_getKey(entry);
+        char* val = hashMapEntry_getValue(entry);
+
+        snprintf(buffer, 256, "%s=%s\n", key, val);
+
+        int buffLength = strlen((const char *) buffer);
+
+    	if (write(file, (const void *) buffer, buffLength) != buffLength) {
+            printf("[ ERROR ]: ConfigStore - writing in Cache incomplete \n");
+            return CELIX_FILE_IO_EXCEPTION;
+        }
+    }
+    hashMapIterator_destroy(iterator);
+    return CELIX_SUCCESS;
+
+}
+
+celix_status_t configurationStore_readCache(configuration_store_pt store) {
+
+    celix_status_t status;
+
+    DIR *cache;	// directory handle
+
+    properties_pt properties = NULL;
+    configuration_pt configuration = NULL;
+    char *pid;
+
+    // (1) cache.open
+    cache = opendir((const char*) STORE_DIR);
+    if (cache == NULL) {
+        printf("[ ERROR ]: ConfigStore - Read Cache \n");
+        return CELIX_FILE_IO_EXCEPTION;
+    }
+
+    // (2) directory.read
+    struct dirent *dp;
+    int res;
+    struct stat st;
+    union {
+        struct dirent d;
+        char b[offsetof (struct dirent, d_name) + NAME_MAX + 1];
+    } u;
+    res = readdir_r(cache, (struct dirent*) &u, &dp);
+    while ((res == 0) && (dp != NULL)) {
+
+        if ((strcmp((dp->d_name), ".") != 0) && (strcmp((dp->d_name), "..") != 0) && (strpbrk(dp->d_name, "~") == NULL)) {
+	    char storeRoot[512];
+            snprintf(storeRoot, sizeof(storeRoot), "%s/%s", STORE_DIR, dp->d_name);
+            // (2.1) file.readData
+            if (stat(storeRoot, &st) == 0) {
+                status = configurationStore_readConfigurationFile(dp->d_name, st.st_size, &properties);
+                if (status != CELIX_SUCCESS) {
+                    closedir(cache);
+                    return status;
+                }
+            }
+            else
+                perror("stat");
+            // (2.2) new configuration
+            status = configuration_create2(store->configurationAdminFactory, store, properties, &configuration);
+            if (status != CELIX_SUCCESS) {
+                closedir(cache);
+                return status;
+            }
+
+            // (2.3) configurations.put
+            configuration_getPid(configuration->handle, &pid);
+            hashMap_put(store->configurations, pid, configuration);
+        }
+        res = readdir_r(cache, (struct dirent*) &u, &dp);
+    }
+
+    closedir(cache);
+
+    return CELIX_SUCCESS;
+}
+
+celix_status_t configurationStore_readConfigurationFile(const char *name, int size, properties_pt *dictionary) {
+
+    char fname[256];		// file name
+    char *buffer;		// file buffer
+    int fd;
+    celix_status_t status = CELIX_SUCCESS;
+
+    properties_pt properties = NULL;
+
+    // (1) The full path to the file
+    snprintf(fname, 256, "%s/%s", STORE_DIR, name);
+
+    // (2) pool.new
+
+    // (3) file.open
+    fd = open((const char*) fname, O_RDONLY);
+    if (fd < 0) {
+        printf("[ ERROR ]: ConfigStore - open File{%s} for reading (IO_EXCEPTION) \n", name);
+        return CELIX_FILE_IO_EXCEPTION;
+    }
+
+    // (4) buffer.new
+    buffer = calloc(1, size+1);
+    if (!buffer) {
+        close(fd);
+        return CELIX_ENOMEM;
+    }
+
+    // (5) file.read
+    if (read(fd, (void *) buffer, size) != size) {
+        printf("[ ERROR ]: ConfigStore - reading File{%s} \n", name);
+        status = CELIX_FILE_IO_EXCEPTION;
+    }
+
+    status = CELIX_DO_IF(status, configurationStore_parseDataConfigurationFile(buffer, &properties));
+
+    // (6) file.close & buffer.destroy
+    free(buffer);
+    close(fd);
+    // (7) return
+    *dictionary = properties;
+    return status;
+
+}
+
+celix_status_t configurationStore_parseDataConfigurationFile(char *data, properties_pt *dictionary) {
+
+    properties_pt properties = properties_create();
+
+
+    char *token;
+    char *key;
+    char *value;
+    char *saveptr;
+
+    bool isKey = true;
+    token = strtok_r(data, "=", &saveptr);
+
+    while (token != NULL) {
+
+        if (isKey) {
+            key = strdup(token);
+            isKey = false;
+
+        } else { // isValue
+            value = strdup(token);
+            properties_set(properties, key, value);
+            isKey = true;
+        }
+
+        token = strtok_r(NULL, "=\n", &saveptr);
+    }
+
+    if (hashMap_isEmpty(properties)) {
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    *dictionary = properties;
+    return CELIX_SUCCESS;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/private/src/managed_service_impl.c
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/private/src/managed_service_impl.c b/bundles/config_admin/service/private/src/managed_service_impl.c
new file mode 100644
index 0000000..3909979
--- /dev/null
+++ b/bundles/config_admin/service/private/src/managed_service_impl.c
@@ -0,0 +1,55 @@
+/**
+ *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.
+ */
+/*
+ * managed_service_impl.c
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+
+#include <stdlib.h>
+#include <stdio.h>
+
+/* celix.config_admin.ManagedService */
+#include "managed_service.h"
+
+/* APR */
+
+
+/* ------------------------ Constructor -------------------------------------*/
+
+celix_status_t managedService_create(bundle_context_pt context, managed_service_service_pt *service){
+
+	managed_service_service_pt managedServiceService = calloc(1, sizeof(*managedServiceService));
+	if(!managedServiceService){
+		printf("[ ERROR ]: ManagedService Service not initialized \n");
+		return CELIX_ENOMEM;
+	}
+
+	*service = managedServiceService;
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t managedService_destroy(managed_service_service_pt service) {
+	free(service);
+	return CELIX_SUCCESS;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/private/src/managed_service_tracker.c
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/private/src/managed_service_tracker.c b/bundles/config_admin/service/private/src/managed_service_tracker.c
new file mode 100644
index 0000000..a42d565
--- /dev/null
+++ b/bundles/config_admin/service/private/src/managed_service_tracker.c
@@ -0,0 +1,598 @@
+/**
+ *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.
+ */
+/*
+ * managed_service_tracker.c
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* celix.config_admin.ManagedServiceTracker */
+#include "managed_service_tracker.h"
+#include "service_tracker_customizer.h"
+
+/* celix.utils */
+#include "hash_map.h"
+/* celix.framework */
+#include "constants.h"
+#include "properties.h"
+#include "utils.h"
+#include "service_reference.h"
+#include "service_registration.h"
+/* celix.framework.Patch*/
+#include "framework_patch.h"
+/* celix.config_admin.public */
+#include "managed_service.h"
+/* celix.config_admin.private */
+#include "configuration_impl.h"
+#include "updated_thread_pool.h"
+
+struct managed_service_tracker {
+
+    bundle_context_pt context;
+
+    configuration_admin_factory_pt configurationAdminfactory;
+    configuration_store_pt configurationStore;
+    updated_thread_pool_pt updatedThreadPool; // according to org.equinox is our "SerializableTaskQueue"
+
+    hash_map_pt managedServices;
+    hash_map_pt managedServicesReferences;
+    celix_thread_mutex_t managedServicesReferencesMutex;
+};
+
+static celix_status_t managedServiceTracker_createHandle(bundle_context_pt context, configuration_admin_factory_pt factory, configuration_store_pt store, managed_service_tracker_pt *tracker);
+static celix_status_t managedServiceTracker_createCustomized(bundle_context_pt context, managed_service_tracker_pt trackerHandle, service_tracker_pt *tracker);
+
+static celix_status_t managedServiceTracker_add(managed_service_tracker_pt tracker, service_reference_pt reference, char * pid, managed_service_service_pt service);
+static celix_status_t managedServiceTracker_remove(managed_service_tracker_pt tracker, service_reference_pt reference, char * pid);
+static celix_status_t managedServiceTracker_trackManagedService(managed_service_tracker_pt tracker, char *pid, service_reference_pt reference, managed_service_service_pt service);
+static celix_status_t managedServiceTracker_untrackManagedService(managed_service_tracker_pt tracker, char *pid, service_reference_pt reference);
+static celix_status_t managedServiceTracker_getManagedService(managed_service_tracker_pt tracker, char *pid, managed_service_service_pt *service);
+static celix_status_t managedServiceTracker_getManagedServiceReference(managed_service_tracker_pt tracker, char *pid, service_reference_pt *reference);
+//static celix_status_t managedServiceTracker_getPidForManagedService(managed_service_service_pt *service, char **pid);
+celix_status_t managedServiceTracker_asynchUpdated(managed_service_tracker_pt trackerHandle, managed_service_service_pt service, properties_pt properties);
+
+static celix_status_t managedServiceTracker_getBundleContext(managed_service_tracker_pt trackerHandle, bundle_context_pt *context);
+
+static celix_status_t managedServiceTracker_lockManagedServicesReferences(managed_service_tracker_pt handle);
+static celix_status_t managedServiceTracker_unlockManagedServicesReferences(managed_service_tracker_pt handle);
+
+/* ========== CONSTRUCTOR ========== */
+
+/* ---------- public ---------- */
+
+celix_status_t managedServiceTracker_create(bundle_context_pt context, configuration_admin_factory_pt factory, configuration_store_pt store, managed_service_tracker_pt *trackerHandle, service_tracker_pt *tracker) {
+
+    celix_status_t status;
+
+    managed_service_tracker_pt managedServiceTrackerHandle;
+    service_tracker_pt managedServiceTrackerCustomized;
+
+    status = managedServiceTracker_createHandle(context, factory, store, &managedServiceTrackerHandle);
+    if (status != CELIX_SUCCESS) {
+        *trackerHandle = NULL;
+        *tracker = NULL;
+        return status;
+    }
+
+    status = managedServiceTracker_createCustomized(context, managedServiceTrackerHandle, &managedServiceTrackerCustomized);
+    if (status != CELIX_SUCCESS) {
+        *trackerHandle = NULL;
+        *tracker = NULL;
+        return status;
+    }
+    *trackerHandle = managedServiceTrackerHandle;
+    *tracker = managedServiceTrackerCustomized;
+
+    printf("[ SUCCESS ]: Tracker - Initialized \n");
+    return CELIX_SUCCESS;
+
+}
+
+/* ---------- private ---------- */
+
+celix_status_t managedServiceTracker_createHandle(bundle_context_pt context, configuration_admin_factory_pt factory, configuration_store_pt store, managed_service_tracker_pt *tracker) {
+
+    celix_status_t status;
+
+    updated_thread_pool_pt updatedThreadPool = NULL;
+    managed_service_tracker_pt this = calloc(1, sizeof(*this));
+
+    if (!this) {
+        printf("[ ERROR ]: TrackerInstance - Not initialized (ENOMEM) \n");
+        *tracker = NULL;
+        return CELIX_ENOMEM;
+    }
+
+    status = updatedThreadPool_create(context, MAX_THREADS, &updatedThreadPool);
+    if (status != CELIX_SUCCESS) {
+        return status;
+    }
+
+    this->context = context;
+
+    this->configurationAdminfactory = factory;
+    this->configurationStore = store;
+    this->updatedThreadPool = updatedThreadPool;
+
+    this->managedServices = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL);
+    this->managedServicesReferences = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL);
+
+    celix_status_t mutexStatus = celixThreadMutex_create(&this->managedServicesReferencesMutex, NULL);
+    if (mutexStatus != CELIX_SUCCESS) {
+        printf("[ ERROR ]: TrackerInstance - Not initialized (MUTEX) \n");
+        // TODO destroy threadpool?
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    *tracker = this;
+    return CELIX_SUCCESS;
+
+}
+
+celix_status_t managedServiceTracker_createCustomized(bundle_context_pt context, managed_service_tracker_pt trackerHandle, service_tracker_pt *tracker) {
+    celix_status_t status;
+
+    service_tracker_customizer_pt customizer = NULL;
+    service_tracker_pt managedServiceTracker = NULL;
+
+    status = serviceTrackerCustomizer_create(trackerHandle, managedServiceTracker_addingService, managedServiceTracker_addedService, managedServiceTracker_modifiedService, managedServiceTracker_removedService, &customizer);
+
+    if (status != CELIX_SUCCESS) {
+        printf("[ ERROR ]: TrackerCustomized - Not initialized(ENOMEM) \n");
+        *tracker = NULL;
+        return CELIX_ENOMEM;
+    }
+
+    serviceTracker_create(context, (char *) MANAGED_SERVICE_SERVICE_NAME, customizer, &managedServiceTracker);
+
+    if (status != CELIX_SUCCESS) {
+        printf("[ ERROR ]: TrackerCustomized - Not created \n");
+        *tracker = NULL;
+        return status;
+    }
+
+    *tracker = managedServiceTracker;
+    return CELIX_SUCCESS;
+}
+
+celix_status_t managedServiceTracker_destroy(bundle_context_pt context, managed_service_tracker_pt mgServTr, service_tracker_pt tracker) {
+	updatedThreadPool_destroy(mgServTr->updatedThreadPool);
+	celixThreadMutex_destroy(&mgServTr->managedServicesReferencesMutex);
+	serviceTracker_destroy(tracker);
+
+	hashMap_destroy(mgServTr->managedServices, true, true);
+	hashMap_destroy(mgServTr->managedServicesReferences, true, true);
+
+    free(mgServTr);
+
+	return CELIX_SUCCESS;
+}
+
+
+
+/* ========== IMPLEMENTS CUSTOMIZED TRACKER ========== */
+
+/* ---------- public ---------- */
+
+celix_status_t managedServiceTracker_addingService(void * handle, service_reference_pt reference, void **service) {
+
+
+    celix_status_t status;
+
+    const char* pid = NULL;
+
+    bundle_context_pt context = NULL;
+
+    managed_service_tracker_pt managedServiceTracker_i = handle;	//instance
+    managed_service_service_pt managedService_s = NULL;			//service
+
+    // (1) reference.getPid
+
+    status = serviceReference_getProperty(reference, OSGI_FRAMEWORK_SERVICE_PID, &pid);
+    if (status != CELIX_SUCCESS || pid == NULL) {
+        *service = NULL;
+        printf(" [ ERROR ]: Tracker - PID is NULL \n");
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    // (2) context.getManagedServiceService
+
+    // (2.1) trackerInstance.getBundleContext
+
+    if (managedServiceTracker_getBundleContext(managedServiceTracker_i, &context) != CELIX_SUCCESS) {
+        *service = NULL;
+        printf(" [ ERROR ]: Tracker - NULL bundleContext \n");
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    // (2.2) context.getManagedServiceService
+
+    if (bundleContext_getService(context, reference, (void*) &managedService_s) != CELIX_SUCCESS) {
+        printf("[ ERROR ]: Tracker - AddingService ( BundleContext - getService{PID=%s} ) \n", pid);
+        *service = NULL;
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+    if (managedService_s == NULL) {
+        printf("[ WARNING ]: Tracker - AddingService (none Service{PID=%s}) \n", pid);
+        *service = NULL;
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    /* DEBUG CODE *
+
+    service_registration_pt registration = NULL;
+    serviceReference_getServiceRegistration(reference, &registration);
+    char *serviceName = NULL;
+    serviceRegistration_getServiceName(registration, &serviceName);
+
+    printf("[ DEBUG ]: Tracker - AddingService ( SUCCESS BundleCtxt - getService{Name=%s,PID=%s}  ) \n", serviceName, pid);
+
+    * ENF OF DEBUG CODE */
+
+    // (3) trackerInstance.AddManagedServiceToLocalList
+    configurationStore_lock(managedServiceTracker_i->configurationStore);
+
+    status = managedServiceTracker_add(managedServiceTracker_i, reference, (char*)pid, managedService_s);
+    if (status != CELIX_SUCCESS) {
+        bundleContext_ungetService(context, reference, NULL);
+    }
+    configurationStore_unlock(managedServiceTracker_i->configurationStore);
+
+    if (status != CELIX_SUCCESS) {
+        *service = NULL;
+    } else {
+        *service = &managedService_s;
+    }
+
+    return status;
+
+}
+
+celix_status_t managedServiceTracker_addedService(void * handle, service_reference_pt reference, void * service) {
+    return CELIX_SUCCESS;
+}
+
+celix_status_t managedServiceTracker_modifiedService(void * handle, service_reference_pt reference, void * service) {
+    return CELIX_SUCCESS;
+}
+
+celix_status_t managedServiceTracker_removedService(void * handle, service_reference_pt reference, void * service) {
+    celix_status_t status = CELIX_SUCCESS;
+    const char* pid;
+    managed_service_tracker_pt managedServiceTracker_i = handle;	//instance
+    bundle_context_pt context;
+
+
+    status = serviceReference_getProperty(reference, OSGI_FRAMEWORK_SERVICE_PID, &pid);
+    if (status != CELIX_SUCCESS || pid == NULL){
+	return CELIX_ILLEGAL_ARGUMENT;
+    }
+    if ( managedServiceTracker_getBundleContext(managedServiceTracker_i, &context) != CELIX_SUCCESS ){
+	return CELIX_ILLEGAL_ARGUMENT;
+    }
+    status = managedServiceTracker_remove(managedServiceTracker_i, reference, (char*)pid);
+
+    return status;
+
+}
+
+/* ---------- private ---------- */
+// org.eclipse.equinox.internal.cm.ManagedServiceTracker
+celix_status_t managedServiceTracker_add(managed_service_tracker_pt tracker, service_reference_pt reference, char *pid, managed_service_service_pt service) {
+
+    celix_status_t status;
+
+    bundle_pt bundle = NULL;
+    const char* bundleLocation;
+
+    configuration_pt configuration = NULL;
+    properties_pt properties = NULL;
+
+    configurationStore_findConfiguration(tracker->configurationStore, pid, &configuration);
+
+    if (configuration == NULL) {
+
+        if (managedServiceTracker_trackManagedService(tracker, pid, reference, service) == CELIX_SUCCESS) {
+
+            // TODO : this is new code, it hasn't been tested yet
+
+            if (serviceReference_getBundle(reference, &bundle) != CELIX_SUCCESS) {
+                return CELIX_ILLEGAL_ARGUMENT;
+            }
+
+            if (bundle_getBundleLocation(bundle, &bundleLocation) != CELIX_SUCCESS) {
+                return CELIX_ILLEGAL_ARGUMENT;
+            }
+
+            // (1) creates a new Configuration for the ManagedService
+            if (configurationStore_getConfiguration(tracker->configurationStore, pid, (char*)bundleLocation, &configuration) != CELIX_SUCCESS || configuration == NULL) {
+                return CELIX_ILLEGAL_ARGUMENT;
+            }
+
+            // (2) bind the Configuration with the ManagedService
+            bool dummy;
+            if ((configuration_bind(configuration->handle, bundle, &dummy) != CELIX_SUCCESS)) {
+                return CELIX_ILLEGAL_ARGUMENT;
+            }
+
+            // (3) the new Configuration is persisted and visible for other ConfigAdmin instances
+            if (configurationStore_saveConfiguration(tracker->configurationStore, pid, configuration) != CELIX_SUCCESS) {
+                return CELIX_ILLEGAL_STATE;
+            }
+
+            // End of new code
+
+            // TODO: It must be considered in case of fail if untrack the ManagedService
+
+            return managedServiceTracker_asynchUpdated(tracker, service, NULL);
+
+        } else {
+            return CELIX_ILLEGAL_ARGUMENT; // the service was already tracked
+        }
+
+    } else {
+
+        configuration_lock(configuration->handle);
+
+        if (managedServiceTracker_trackManagedService(tracker, pid, reference, service) == CELIX_SUCCESS) {
+
+            if (serviceReference_getBundle(reference, &bundle) != CELIX_SUCCESS) {
+                configuration_unlock(configuration->handle);
+                printf("[ERROR ]: Tracker - Add (Service{PID=%s} Reference - getBundle NULL)", pid);
+                return CELIX_ILLEGAL_ARGUMENT;
+            }
+
+            // TODO configuration.isDeleted ? - with only using one calling bundle OK
+
+            bool isBind;
+            if ((configuration_bind(configuration->handle, bundle, &isBind) == CELIX_SUCCESS) && (isBind == true)) { // config.bind(bundle)
+
+                if (configuration_getProperties(configuration->handle, &properties) != CELIX_SUCCESS) {
+                    configuration_unlock(configuration->handle);
+                    return CELIX_ILLEGAL_ARGUMENT;
+                }
+
+                if (configurationAdminFactory_modifyConfiguration(tracker->configurationAdminfactory, reference, properties) != CELIX_SUCCESS) {
+                    configuration_unlock(configuration->handle);
+                    return CELIX_ILLEGAL_ARGUMENT;
+                }
+
+                status = managedServiceTracker_asynchUpdated(tracker, service, properties);
+
+                configuration_unlock(configuration->handle);
+
+                return status;
+
+            } else {
+                configuration_unlock(configuration->handle);
+                return CELIX_ILLEGAL_STATE;
+            }
+
+        } else {
+            configuration_unlock(configuration->handle);
+            return CELIX_ILLEGAL_ARGUMENT; // the service was already tracked
+        }
+    }
+}
+
+celix_status_t managedServiceTracker_remove(managed_service_tracker_pt tracker, service_reference_pt reference, char * pid){
+    configuration_pt configuration = NULL;
+    bundle_pt bundle = NULL;
+
+    configurationStore_findConfiguration(tracker->configurationStore, pid, &configuration);
+    if (configuration != NULL) {
+        if (serviceReference_getBundle(reference, &bundle) == CELIX_SUCCESS) {
+			configuration_unbind(configuration->handle, bundle);
+		}	
+	}
+	return managedServiceTracker_untrackManagedService(tracker, pid, reference);
+}
+
+celix_status_t managedServiceTracker_trackManagedService(managed_service_tracker_pt tracker, char *pid, service_reference_pt reference, managed_service_service_pt service) {
+
+    managedServiceTracker_lockManagedServicesReferences(tracker);
+
+    if (hashMap_containsKey(tracker->managedServicesReferences, pid)) {
+        printf("[ WARNING ]: Tracker - Track ( Service{PID=%s} already registered ) ", pid);
+        managedServiceTracker_unlockManagedServicesReferences(tracker);
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    hashMap_put(tracker->managedServicesReferences, pid, reference);
+    hashMap_put(tracker->managedServices, pid, service);
+
+    managedServiceTracker_unlockManagedServicesReferences(tracker);
+
+    return CELIX_SUCCESS;
+}
+
+celix_status_t managedServiceTracker_untrackManagedService(managed_service_tracker_pt tracker, char *pid, service_reference_pt reference){
+    managedServiceTracker_lockManagedServicesReferences(tracker);
+
+    if ( hashMap_containsKey(tracker->managedServicesReferences, pid) ){
+	hashMap_remove(tracker->managedServicesReferences, pid);
+	hashMap_remove(tracker->managedServices, pid);
+    }
+    managedServiceTracker_unlockManagedServicesReferences(tracker);
+    return CELIX_SUCCESS;
+
+}
+
+celix_status_t managedServiceTracker_getManagedService(managed_service_tracker_pt tracker, char *pid, managed_service_service_pt *service) {
+
+    celix_status_t status;
+    managed_service_service_pt serv = NULL;
+
+    managedServiceTracker_lockManagedServicesReferences(tracker);
+
+    serv = hashMap_get(tracker->managedServices, pid);
+    if (serv == NULL) {
+        status = CELIX_ILLEGAL_ARGUMENT;
+    } else {
+        status = CELIX_SUCCESS;
+    }
+
+    managedServiceTracker_unlockManagedServicesReferences(tracker);
+
+    *service = serv;
+    return status;
+}
+
+celix_status_t managedServiceTracker_getManagedServiceReference(managed_service_tracker_pt tracker, char *pid, service_reference_pt *reference) {
+
+    celix_status_t status;
+    service_reference_pt ref = NULL;
+
+    managedServiceTracker_lockManagedServicesReferences(tracker);
+
+    ref = hashMap_get(tracker->managedServicesReferences, pid);
+    if (ref == NULL) {
+        status = CELIX_ILLEGAL_ARGUMENT;
+    } else {
+        status = CELIX_SUCCESS;
+    }
+
+    managedServiceTracker_unlockManagedServicesReferences(tracker);
+
+    *reference = ref;
+    return status;
+}
+
+/* TODO
+ celix_status_t managedServiceTracker_getPidForManagedService(managed_service_service_pt *service, char **pid){
+ return CELIX_SUCCESS;
+ }
+ */
+
+celix_status_t managedServiceTracker_asynchUpdated(managed_service_tracker_pt trackerHandle, managed_service_service_pt service, properties_pt properties) {
+
+    return updatedThreadPool_push(trackerHandle->updatedThreadPool, service, properties);
+
+}
+
+/* ========== IMPLEMENTENTATION  ========== */
+
+/* ---------- public ---------- */
+
+celix_status_t managedServiceTracker_notifyDeleted(managed_service_tracker_pt tracker, configuration_pt configuration) {
+    return CELIX_SUCCESS;
+}
+
+celix_status_t managedServiceTracker_notifyUpdated(managed_service_tracker_pt tracker, configuration_pt configuration) {
+
+
+    char *pid;
+
+    service_reference_pt reference = NULL;
+    bundle_pt bundle = NULL;
+    properties_pt properties = NULL;
+
+    managed_service_service_pt service = NULL;
+
+    // (1) config.checkLocked
+    if (configuration_checkLocked(configuration->handle) != CELIX_SUCCESS) { //TODO not yet implemented
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    // (2) config.getPid
+    if (configuration_getPid(configuration->handle, &pid) != CELIX_SUCCESS) {
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    // (3) reference = getManagedServiceReference(pid)
+    if (managedServiceTracker_getManagedServiceReference(tracker, pid, &reference) != CELIX_SUCCESS || reference == NULL) {
+        printf("[ ERROR ]: Tracker - Notify (NULL Reference Service{PID=%s}) \n", pid);
+        return CELIX_ILLEGAL_ARGUMENT; // Eclipse ignores, but according to Specs, callback is delayed
+    }
+
+    //  (4.1) reference.getBundle
+    if (serviceReference_getBundle(reference, &bundle) != CELIX_SUCCESS || bundle == NULL) {
+        printf("[ ERROR ]: Tracker - Notify (NULL Bundle Service{PID=%s}) \n", pid);
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    //	(4.2) config.bind(reference.getBundle)
+    bool isBind;
+    if (configuration_bind(configuration->handle, bundle, &isBind) != CELIX_SUCCESS || isBind == false) {
+        printf("[ ERROR ]: Tracker - Notify (Service{PID=%s} Permission Error) \n", pid);
+        return CELIX_ILLEGAL_STATE;
+    }
+
+    // (5) if (reference != null && config.bind(reference.getBundle()))
+
+    // (5.1) properties = config.getProperties
+    if (configuration_getProperties(configuration->handle, &properties) != CELIX_SUCCESS) {
+        printf("[ ERROR ]: Tracker - Notify (Service{PID=%s} Wrong Properties) \n", pid);
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    // (5.2) modifyConfiguration
+    if (configurationAdminFactory_modifyConfiguration(tracker->configurationAdminfactory, reference, properties) != CELIX_SUCCESS) {
+        return CELIX_ILLEGAL_ARGUMENT; //TODO no yet implemented modifyConfiguration
+    }
+
+    // (5.3) service = getManagedService(pid)
+    if (managedServiceTracker_getManagedService(tracker, pid, &service) != CELIX_SUCCESS) {
+        printf("[ ERROR ]: Tracker - Notify (NULL Service{PID=%s}) \n", pid);
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+
+    // (5.4) asynchUpdate(service,properties)
+    if ((properties == NULL) || (properties != NULL && hashMap_size(properties) == 0)) {
+        return managedServiceTracker_asynchUpdated(tracker, service, NULL);
+    } else {
+        return managedServiceTracker_asynchUpdated(tracker, service, properties);
+    }
+    return CELIX_ILLEGAL_ARGUMENT;
+}
+
+/* ---------- private ---------- */
+
+celix_status_t managedServiceTracker_getBundleContext(managed_service_tracker_pt trackerHandle, bundle_context_pt *context) {
+
+    if (trackerHandle->context != NULL) {
+        *context = trackerHandle->context;
+    } else {
+        printf("[ ERROR ]: Tracker - getBundleContext (NULL context) \n");
+        *context = NULL;
+        return CELIX_ILLEGAL_ARGUMENT;
+    }
+    return CELIX_SUCCESS;
+}
+
+celix_status_t managedServiceTracker_lockManagedServicesReferences(managed_service_tracker_pt handle) {
+
+    celixThreadMutex_lock(&handle->managedServicesReferencesMutex);
+    return CELIX_SUCCESS;
+
+}
+
+celix_status_t managedServiceTracker_unlockManagedServicesReferences(managed_service_tracker_pt handle) {
+
+    celixThreadMutex_unlock(&handle->managedServicesReferencesMutex);
+    return CELIX_SUCCESS;
+
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/private/src/updated_thread_pool.c
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/private/src/updated_thread_pool.c b/bundles/config_admin/service/private/src/updated_thread_pool.c
new file mode 100644
index 0000000..86220db
--- /dev/null
+++ b/bundles/config_admin/service/private/src/updated_thread_pool.c
@@ -0,0 +1,146 @@
+/**
+ *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.
+ */
+/*
+ * updated_thread_pool.c
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* celix.config_admin.UpdatedThreadPool */
+#include "thpool.h"
+#include "updated_thread_pool.h"
+
+
+
+struct updated_thread_pool{
+
+	bundle_context_pt 	context;
+
+	int maxTreads;
+
+	//	apr_thread_mutex_t *mutex;
+	threadpool threadPool;	//protected by mutex
+
+};
+
+typedef struct data_callback *data_callback_t;
+
+struct data_callback{
+
+	managed_service_service_pt managedServiceService;
+	properties_pt properties;
+
+};
+
+
+static void *updateThreadPool_updatedCallback(void *data);
+static celix_status_t updatedThreadPool_wrapDataCallback(managed_service_service_pt service, properties_pt properties, data_callback_t *data);
+
+
+/* ========== CONSTRUCTOR ========== */
+
+/* ---------- public ---------- */
+
+celix_status_t updatedThreadPool_create(bundle_context_pt context, int maxThreads, updated_thread_pool_pt *updatedThreadPool){
+
+	*updatedThreadPool = calloc(1, sizeof(**updatedThreadPool));
+	if (!*updatedThreadPool){
+		printf("[ ERROR ]: UpdatedThreadPool - Not initialized (ENOMEM) \n");
+		return CELIX_ENOMEM;
+	}
+
+	(*updatedThreadPool)->threadPool=thpool_init(maxThreads);
+//	if ( apr_thread_pool_create(&(*updatedThreadPool)->threadPool, INIT_THREADS, maxTreads, pool) != APR_SUCCESS ){
+	if ((*updatedThreadPool)->threadPool == NULL) {
+		printf("[ ERROR ]: UpdatedThreadPool - Instance not created \n");
+		return CELIX_ENOMEM;
+	}
+
+	(*updatedThreadPool)->context = context;
+
+	printf("[ SUCCESS ]: UpdatedThreadPool - initialized \n");
+	return CELIX_SUCCESS;
+
+}
+
+celix_status_t updatedThreadPool_destroy(updated_thread_pool_pt pool) {
+	thpool_destroy(pool->threadPool);
+	free(pool);
+	return CELIX_SUCCESS;
+}
+/* ========== IMPLEMENTATION ========== */
+
+/* ---------- public ---------- */
+
+celix_status_t updatedThreadPool_push(updated_thread_pool_pt updatedThreadPool, managed_service_service_pt service, properties_pt properties){
+
+	data_callback_t data = NULL;
+
+	if ( updatedThreadPool_wrapDataCallback(service, properties, &data) != CELIX_SUCCESS ){
+		return CELIX_ILLEGAL_ARGUMENT;
+	}
+
+	if (thpool_add_work(updatedThreadPool->threadPool, updateThreadPool_updatedCallback, data) != 0) {
+		printf("[ ERROR ]: UpdatedThreadPool - add_work \n ");
+		return CELIX_ILLEGAL_STATE;
+	}
+
+	return CELIX_SUCCESS;
+}
+
+/* ---------- private ---------- */
+
+void *updateThreadPool_updatedCallback(void *data) {
+
+	data_callback_t params = data;
+
+	managed_service_service_pt managedServiceService = params->managedServiceService;
+	properties_pt properties = params->properties;
+
+	(*managedServiceService->updated)(managedServiceService->managedService, properties);
+
+	free(data);
+
+	return NULL;
+
+}
+
+celix_status_t updatedThreadPool_wrapDataCallback(managed_service_service_pt service, properties_pt properties, data_callback_t *data){
+
+	*data = calloc(1, sizeof(**data));
+
+	if (!*data){
+		printf("[ ERROR ]: UpdatedThreadPool - WrapDataCallback (Data not initialized) \n");
+		return CELIX_ENOMEM;
+	}
+
+	(*data)->managedServiceService = service;
+	(*data)->properties = properties;
+
+	return CELIX_SUCCESS;
+}
+

http://git-wip-us.apache.org/repos/asf/celix/blob/3bce889b/bundles/config_admin/service/public/include/configuration.h
----------------------------------------------------------------------
diff --git a/bundles/config_admin/service/public/include/configuration.h b/bundles/config_admin/service/public/include/configuration.h
new file mode 100644
index 0000000..74bf5b1
--- /dev/null
+++ b/bundles/config_admin/service/public/include/configuration.h
@@ -0,0 +1,80 @@
+/**
+ *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.
+ */
+/*
+ * configuration.h
+ *
+ *  \date       Aug 12, 2013
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+
+#ifndef CONFIGURATION_H_
+#define CONFIGURATION_H_
+
+
+#include <stdbool.h>
+/* celix.framework */
+#include "celix_errno.h"
+#include "properties.h"
+
+
+// Note: the term interface is used because configuration is not a service, it is not
+//       registered in the service registry but it is owned by the config_admin
+struct configuration
+{
+	void 	*handle;	// pointer to configuration datastore
+	/* METHODS */
+	celix_status_t (*configuration_delete)(void *handle);
+
+	celix_status_t (*configuration_equals)(void *thisConfiguration, void *otherConfiguration, bool *equals);
+
+	celix_status_t (*configuration_getBundleLocation)(void *handle, char **bundleLocation);
+	celix_status_t (*configuration_getFactoryPid)(void *handle, char **factoryPid);
+	celix_status_t (*configuration_getPid)(void *handle, char **pid);
+	celix_status_t (*configuration_getProperties)(void *handle, properties_pt *properties);
+
+	celix_status_t (*configuration_hashCode)(void *handle, int *hashCode);
+
+	celix_status_t (*configuration_setBundleLocation)(void *handle, char *bundleLocation);
+
+	celix_status_t (*configuration_update)(void *handle, properties_pt properties);
+
+};
+
+typedef struct configuration *configuration_pt;
+
+/* METHODS
+celix_status_t configuration_delete(configuration_pt configuration);
+
+celix_status_t configuration_equals(configuration_pt thisConfiguration, configuration_pt otherConfiguration, bool *equals);
+
+celix_status_t configuration_getBundleLocation(configuration_pt configuration, char **bundleLocation);
+celix_status_t configuration_getFactoryPid(configuration_pt configuration, char **factoryPid);
+celix_status_t configuration_getPid(configuration_pt configuration, char **pid);
+celix_status_t configuration_getProperties(configuration_pt configuration, properties_pt *properties);
+
+celix_status_t configuration_hashCode(configuration_pt configuration, int *hashCode);
+
+celix_status_t configuration_setBundleLocation(configuration_pt configuration, char *bundleLocation);
+
+celix_status_t configuration_update(configuration_pt configuration, properties_pt properties);
+*/
+
+#endif /* CONFIGURATION_H_ */


Mime
View raw message