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:d...@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:d...@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:d...@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:d...@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, ©, 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, ©) != 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, ©, true); + + }else{ // copy != NULL - only set service.bundleLocation + + status = configuration_setBundleLocationProperty(configuration, ©); + + } + + // (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:d...@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:d...@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:d...@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, ®istration); + 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:d...@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:d...@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_ */
