http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/pubsub/pubsub_topology_manager/src/pstm_activator.c ---------------------------------------------------------------------- diff --git a/pubsub/pubsub_topology_manager/src/pstm_activator.c b/pubsub/pubsub_topology_manager/src/pstm_activator.c new file mode 100644 index 0000000..eb874fe --- /dev/null +++ b/pubsub/pubsub_topology_manager/src/pstm_activator.c @@ -0,0 +1,244 @@ +/** + *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. + */ +/* + * pstm_activator.c + * + * \date Sep 29, 2011 + * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> + * \copyright Apache License, Version 2.0 + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "constants.h" +#include "bundle_activator.h" +#include "service_tracker.h" +#include "service_registration.h" + +#include "listener_hook_service.h" +#include "log_service.h" +#include "log_helper.h" + + +#include "pubsub_topology_manager.h" +#include "publisher_endpoint_announce.h" + +struct activator { + bundle_context_pt context; + + pubsub_topology_manager_pt manager; + + service_tracker_pt pubsubDiscoveryTracker; + service_tracker_pt pubsubAdminTracker; + service_tracker_pt pubsubSubscribersTracker; + + listener_hook_service_pt hookService; + service_registration_pt hook; + + publisher_endpoint_announce_pt publisherEPDiscover; + service_registration_pt publisherEPDiscoverService; + + log_helper_pt loghelper; +}; + + +static celix_status_t bundleActivator_createPSDTracker(struct activator *activator, service_tracker_pt *tracker); +static celix_status_t bundleActivator_createPSATracker(struct activator *activator, service_tracker_pt *tracker); +static celix_status_t bundleActivator_createPSSubTracker(struct activator *activator, service_tracker_pt *tracker); + + +static celix_status_t bundleActivator_createPSDTracker(struct activator *activator, service_tracker_pt *tracker) { + celix_status_t status; + + service_tracker_customizer_pt customizer = NULL; + + status = serviceTrackerCustomizer_create(activator->manager, + NULL, + pubsub_topologyManager_pubsubDiscoveryAdded, + pubsub_topologyManager_pubsubDiscoveryModified, + pubsub_topologyManager_pubsubDiscoveryRemoved, + &customizer); + + if (status == CELIX_SUCCESS) { + status = serviceTracker_create(activator->context, (char *) PUBSUB_DISCOVERY_SERVICE, customizer, tracker); + } + + return status; +} + +static celix_status_t bundleActivator_createPSATracker(struct activator *activator, service_tracker_pt *tracker) { + celix_status_t status = CELIX_SUCCESS; + + service_tracker_customizer_pt customizer = NULL; + + status = serviceTrackerCustomizer_create(activator->manager, + NULL, + pubsub_topologyManager_psaAdded, + pubsub_topologyManager_psaModified, + pubsub_topologyManager_psaRemoved, + &customizer); + + if (status == CELIX_SUCCESS) { + status = serviceTracker_create(activator->context, PUBSUB_ADMIN_SERVICE, customizer, tracker); + } + + return status; +} + +static celix_status_t bundleActivator_createPSSubTracker(struct activator *activator, service_tracker_pt *tracker) { + celix_status_t status = CELIX_SUCCESS; + + service_tracker_customizer_pt customizer = NULL; + + status = serviceTrackerCustomizer_create(activator->manager, + NULL, + pubsub_topologyManager_subscriberAdded, + pubsub_topologyManager_subscriberModified, + pubsub_topologyManager_subscriberRemoved, + &customizer); + + if (status == CELIX_SUCCESS) { + status = serviceTracker_create(activator->context, PUBSUB_SUBSCRIBER_SERVICE_NAME, customizer, tracker); + } + + return status; +} + +celix_status_t bundleActivator_create(bundle_context_pt context, void **userData) { + celix_status_t status = CELIX_SUCCESS; + struct activator *activator = NULL; + + activator = calloc(1,sizeof(struct activator)); + + if (!activator) { + return CELIX_ENOMEM; + } + + activator->context = context; + + logHelper_create(context, &activator->loghelper); + logHelper_start(activator->loghelper); + + status = pubsub_topologyManager_create(context, activator->loghelper, &activator->manager); + if (status == CELIX_SUCCESS) { + status = bundleActivator_createPSDTracker(activator, &activator->pubsubDiscoveryTracker); + if (status == CELIX_SUCCESS) { + status = bundleActivator_createPSATracker(activator, &activator->pubsubAdminTracker); + if (status == CELIX_SUCCESS) { + status = bundleActivator_createPSSubTracker(activator, &activator->pubsubSubscribersTracker); + if (status == CELIX_SUCCESS) { + *userData = activator; + } + } + } + } + + if(status != CELIX_SUCCESS){ + bundleActivator_destroy(activator, context); + } + + return status; +} + + +celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) { + celix_status_t status = CELIX_SUCCESS; + struct activator *activator = userData; + + publisher_endpoint_announce_pt pubEPDiscover = calloc(1, sizeof(*pubEPDiscover)); + pubEPDiscover->handle = activator->manager; + pubEPDiscover->announcePublisher = pubsub_topologyManager_announcePublisher; + pubEPDiscover->removePublisher = pubsub_topologyManager_removePublisher; + activator->publisherEPDiscover = pubEPDiscover; + + status += bundleContext_registerService(context, (char *) PUBSUB_TM_ANNOUNCE_PUBLISHER_SERVICE, pubEPDiscover, NULL, &activator->publisherEPDiscoverService); + + + listener_hook_service_pt hookService = calloc(1,sizeof(*hookService)); + hookService->handle = activator->manager; + hookService->added = pubsub_topologyManager_publisherTrackerAdded; + hookService->removed = pubsub_topologyManager_publisherTrackerRemoved; + activator->hookService = hookService; + + status += bundleContext_registerService(context, (char *) OSGI_FRAMEWORK_LISTENER_HOOK_SERVICE_NAME, hookService, NULL, &activator->hook); + + /* NOTE: Enable those line in order to remotely expose the topic_info service + properties_pt props = properties_create(); + properties_set(props, (char *) OSGI_RSA_SERVICE_EXPORTED_INTERFACES, (char *) PUBSUB_TOPIC_INFO_SERVICE); + status += bundleContext_registerService(context, (char *) PUBSUB_TOPIC_INFO_SERVICE, activator->topicInfo, props, &activator->topicInfoService); + */ + status += serviceTracker_open(activator->pubsubAdminTracker); + + status += serviceTracker_open(activator->pubsubDiscoveryTracker); + + status += serviceTracker_open(activator->pubsubSubscribersTracker); + + + return status; +} + +celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) { + celix_status_t status = CELIX_SUCCESS; + struct activator *activator = userData; + + serviceTracker_close(activator->pubsubSubscribersTracker); + serviceTracker_close(activator->pubsubDiscoveryTracker); + serviceTracker_close(activator->pubsubAdminTracker); + + serviceRegistration_unregister(activator->publisherEPDiscoverService); + free(activator->publisherEPDiscover); + + serviceRegistration_unregister(activator->hook); + free(activator->hookService); + + return status; +} + +celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) { + celix_status_t status = CELIX_SUCCESS; + + struct activator *activator = userData; + if (activator == NULL) { + status = CELIX_BUNDLE_EXCEPTION; + } else { + + if(activator->pubsubSubscribersTracker!=NULL){ + serviceTracker_destroy(activator->pubsubSubscribersTracker); + } + if(activator->pubsubDiscoveryTracker!=NULL){ + serviceTracker_destroy(activator->pubsubDiscoveryTracker); + } + if(activator->pubsubAdminTracker!=NULL){ + serviceTracker_destroy(activator->pubsubAdminTracker); + } + + if(activator->manager!=NULL){ + status = pubsub_topologyManager_destroy(activator->manager); + } + + logHelper_stop(activator->loghelper); + logHelper_destroy(&activator->loghelper); + + free(activator); + } + + return status; +}
http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c ---------------------------------------------------------------------- diff --git a/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c b/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c new file mode 100644 index 0000000..2ac75c9 --- /dev/null +++ b/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.c @@ -0,0 +1,721 @@ +/** + *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. + */ +/* + * pubsub_topology_manager.c + * + * \date Sep 29, 2011 + * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> + * \copyright Apache License, Version 2.0 + */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdbool.h> + +#include "hash_map.h" +#include "array_list.h" +#include "bundle_context.h" +#include "constants.h" +#include "module.h" +#include "bundle.h" +#include "filter.h" +#include "listener_hook_service.h" +#include "utils.h" +#include "service_reference.h" +#include "service_registration.h" +#include "log_service.h" +#include "log_helper.h" + +#include "publisher_endpoint_announce.h" +#include "pubsub_topology_manager.h" +#include "pubsub_endpoint.h" +#include "pubsub_admin.h" +#include "pubsub_utils.h" + + +celix_status_t pubsub_topologyManager_create(bundle_context_pt context, log_helper_pt logHelper, pubsub_topology_manager_pt *manager) { + celix_status_t status = CELIX_SUCCESS; + + *manager = calloc(1, sizeof(**manager)); + if (!*manager) { + return CELIX_ENOMEM; + } + + (*manager)->context = context; + + celix_thread_mutexattr_t psaAttr; + celixThreadMutexAttr_create(&psaAttr); + celixThreadMutexAttr_settype(&psaAttr, CELIX_THREAD_MUTEX_RECURSIVE); + status = celixThreadMutex_create(&(*manager)->psaListLock, &psaAttr); + celixThreadMutexAttr_destroy(&psaAttr); + + status = celixThreadMutex_create(&(*manager)->publicationsLock, NULL); + status = celixThreadMutex_create(&(*manager)->subscriptionsLock, NULL); + status = celixThreadMutex_create(&(*manager)->discoveryListLock, NULL); + + arrayList_create(&(*manager)->psaList); + + (*manager)->discoveryList = hashMap_create(serviceReference_hashCode, NULL, serviceReference_equals2, NULL); + (*manager)->publications = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL); + (*manager)->subscriptions = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL); + + (*manager)->loghelper = logHelper; + + return status; +} + +celix_status_t pubsub_topologyManager_destroy(pubsub_topology_manager_pt manager) { + celix_status_t status = CELIX_SUCCESS; + + celixThreadMutex_lock(&manager->discoveryListLock); + hashMap_destroy(manager->discoveryList, false, false); + celixThreadMutex_unlock(&manager->discoveryListLock); + celixThreadMutex_destroy(&manager->discoveryListLock); + + celixThreadMutex_lock(&manager->psaListLock); + arrayList_destroy(manager->psaList); + celixThreadMutex_unlock(&manager->psaListLock); + celixThreadMutex_destroy(&manager->psaListLock); + + celixThreadMutex_lock(&manager->publicationsLock); + hash_map_iterator_pt pubit = hashMapIterator_create(manager->publications); + while(hashMapIterator_hasNext(pubit)){ + array_list_pt l = (array_list_pt)hashMapIterator_nextValue(pubit); + int i; + for(i=0;i<arrayList_size(l);i++){ + pubsubEndpoint_destroy((pubsub_endpoint_pt)arrayList_get(l,i)); + } + arrayList_destroy(l); + } + hashMapIterator_destroy(pubit); + hashMap_destroy(manager->publications, true, false); + celixThreadMutex_unlock(&manager->publicationsLock); + celixThreadMutex_destroy(&manager->publicationsLock); + + celixThreadMutex_lock(&manager->subscriptionsLock); + hash_map_iterator_pt subit = hashMapIterator_create(manager->subscriptions); + while(hashMapIterator_hasNext(subit)){ + array_list_pt l = (array_list_pt)hashMapIterator_nextValue(subit); + int i; + for(i=0;i<arrayList_size(l);i++){ + pubsubEndpoint_destroy((pubsub_endpoint_pt)arrayList_get(l,i)); + } + arrayList_destroy(l); + } + hashMapIterator_destroy(subit); + hashMap_destroy(manager->subscriptions, true, false); + celixThreadMutex_unlock(&manager->subscriptionsLock); + celixThreadMutex_destroy(&manager->subscriptionsLock); + + free(manager); + + return status; +} + +celix_status_t pubsub_topologyManager_psaAdded(void * handle, service_reference_pt reference, void * service) { + celix_status_t status = CELIX_SUCCESS; + pubsub_topology_manager_pt manager = handle; + int i; + + pubsub_admin_service_pt psa = (pubsub_admin_service_pt) service; + logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "PSTM: Added PSA"); + + celixThreadMutex_lock(&manager->psaListLock); + arrayList_add(manager->psaList, psa); + celixThreadMutex_unlock(&manager->psaListLock); + + // Add already detected subscriptions to new PSA + celixThreadMutex_lock(&manager->subscriptionsLock); + hash_map_iterator_pt subscriptionsIterator = hashMapIterator_create(manager->subscriptions); + + while (hashMapIterator_hasNext(subscriptionsIterator)) { + array_list_pt sub_ep_list = hashMapIterator_nextValue(subscriptionsIterator); + for(i=0;i<arrayList_size(sub_ep_list);i++){ + status += psa->addSubscription(psa->admin, (pubsub_endpoint_pt)arrayList_get(sub_ep_list,i)); + } + } + + hashMapIterator_destroy(subscriptionsIterator); + + celixThreadMutex_unlock(&manager->subscriptionsLock); + + // Add already detected publications to new PSA + status = celixThreadMutex_lock(&manager->publicationsLock); + hash_map_iterator_pt publicationsIterator = hashMapIterator_create(manager->publications); + + while (hashMapIterator_hasNext(publicationsIterator)) { + array_list_pt pub_ep_list = hashMapIterator_nextValue(publicationsIterator); + for(i=0;i<arrayList_size(pub_ep_list);i++){ + status += psa->addPublication(psa->admin, (pubsub_endpoint_pt)arrayList_get(pub_ep_list,i)); + } + } + + hashMapIterator_destroy(publicationsIterator); + + celixThreadMutex_unlock(&manager->publicationsLock); + + return status; +} + +celix_status_t pubsub_topologyManager_psaModified(void * handle, service_reference_pt reference, void * service) { + celix_status_t status = CELIX_SUCCESS; + + // Nop... + + return status; +} + +celix_status_t pubsub_topologyManager_psaRemoved(void * handle, service_reference_pt reference, void * service) { + celix_status_t status = CELIX_SUCCESS; + pubsub_topology_manager_pt manager = handle; + + pubsub_admin_service_pt psa = (pubsub_admin_service_pt) service; + + /* Deactivate all publications */ + celixThreadMutex_lock(&manager->publicationsLock); + + hash_map_iterator_pt pubit = hashMapIterator_create(manager->publications); + while(hashMapIterator_hasNext(pubit)){ + hash_map_entry_pt pub_entry = hashMapIterator_nextEntry(pubit); + char* scope_topic_key = (char*)hashMapEntry_getKey(pub_entry); + // Extract scope/topic name from key + char scope[MAX_SCOPE_LEN]; + char topic[MAX_TOPIC_LEN]; + sscanf(scope_topic_key, "%[^:]:%s", scope, topic ); + array_list_pt pubEP_list = (array_list_pt)hashMapEntry_getValue(pub_entry); + + status = psa->closeAllPublications(psa->admin,scope,topic); + + if(status==CELIX_SUCCESS){ + celixThreadMutex_lock(&manager->discoveryListLock); + hash_map_iterator_pt iter = hashMapIterator_create(manager->discoveryList); + while(hashMapIterator_hasNext(iter)){ + service_reference_pt disc_sr = (service_reference_pt)hashMapIterator_nextKey(iter); + publisher_endpoint_announce_pt disc = NULL; + bundleContext_getService(manager->context, disc_sr, (void**) &disc); + const char* fwUUID = NULL; + bundleContext_getProperty(manager->context,OSGI_FRAMEWORK_FRAMEWORK_UUID,&fwUUID); + int i; + for(i=0;i<arrayList_size(pubEP_list);i++){ + pubsub_endpoint_pt pubEP = (pubsub_endpoint_pt)arrayList_get(pubEP_list,i); + if(strcmp(pubEP->frameworkUUID,fwUUID)==0){ + disc->removePublisher(disc->handle,pubEP); + } + } + bundleContext_ungetService(manager->context, disc_sr, NULL); + } + hashMapIterator_destroy(iter); + celixThreadMutex_unlock(&manager->discoveryListLock); + } + } + hashMapIterator_destroy(pubit); + + celixThreadMutex_unlock(&manager->publicationsLock); + + /* Deactivate all subscriptions */ + celixThreadMutex_lock(&manager->subscriptionsLock); + hash_map_iterator_pt subit = hashMapIterator_create(manager->subscriptions); + while(hashMapIterator_hasNext(subit)){ + // TODO do some error checking + char* scope_topic = (char*)hashMapIterator_nextKey(subit); + char scope[MAX_TOPIC_LEN]; + char topic[MAX_TOPIC_LEN]; + memset(scope, 0 , MAX_TOPIC_LEN*sizeof(char)); + memset(topic, 0 , MAX_TOPIC_LEN*sizeof(char)); + sscanf(scope_topic, "%[^:]:%s", scope, topic ); + status += psa->closeAllSubscriptions(psa->admin,scope, topic); + } + hashMapIterator_destroy(subit); + celixThreadMutex_unlock(&manager->subscriptionsLock); + + celixThreadMutex_lock(&manager->psaListLock); + arrayList_removeElement(manager->psaList, psa); + celixThreadMutex_unlock(&manager->psaListLock); + + logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "PSTM: Removed PSA"); + + return status; +} + +celix_status_t pubsub_topologyManager_subscriberAdded(void * handle, service_reference_pt reference, void * service) { + celix_status_t status = CELIX_SUCCESS; + pubsub_topology_manager_pt manager = handle; + //subscriber_service_pt subscriber = (subscriber_service_pt)service; + + pubsub_endpoint_pt sub = NULL; + if(pubsubEndpoint_createFromServiceReference(reference,&sub,false) == CELIX_SUCCESS){ + celixThreadMutex_lock(&manager->subscriptionsLock); + char *sub_key = createScopeTopicKey(sub->scope, sub->topic); + + array_list_pt sub_list_by_topic = hashMap_get(manager->subscriptions,sub_key); + if(sub_list_by_topic==NULL){ + arrayList_create(&sub_list_by_topic); + hashMap_put(manager->subscriptions,strdup(sub_key),sub_list_by_topic); + } + free(sub_key); + arrayList_add(sub_list_by_topic,sub); + + celixThreadMutex_unlock(&manager->subscriptionsLock); + + int j; + double score = 0; + double best_score = 0; + pubsub_admin_service_pt best_psa = NULL; + celixThreadMutex_lock(&manager->psaListLock); + for(j=0;j<arrayList_size(manager->psaList);j++){ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,j); + psa->matchEndpoint(psa->admin,sub,&score); + if(score>best_score){ /* We have a new winner! */ + best_score = score; + best_psa = psa; + } + } + + if(best_psa != NULL && best_score>0){ + best_psa->addSubscription(best_psa->admin,sub); + } + + // Inform discoveries for interest in the topic + celixThreadMutex_lock(&manager->discoveryListLock); + hash_map_iterator_pt iter = hashMapIterator_create(manager->discoveryList); + while(hashMapIterator_hasNext(iter)){ + service_reference_pt disc_sr = (service_reference_pt)hashMapIterator_nextKey(iter); + publisher_endpoint_announce_pt disc = NULL; + bundleContext_getService(manager->context, disc_sr, (void**) &disc); + disc->interestedInTopic(disc->handle, sub->scope, sub->topic); + bundleContext_ungetService(manager->context, disc_sr, NULL); + } + hashMapIterator_destroy(iter); + celixThreadMutex_unlock(&manager->discoveryListLock); + + celixThreadMutex_unlock(&manager->psaListLock); + } + else{ + status=CELIX_INVALID_BUNDLE_CONTEXT; + } + + return status; +} + +celix_status_t pubsub_topologyManager_subscriberModified(void * handle, service_reference_pt reference, void * service) { + celix_status_t status = CELIX_SUCCESS; + + // Nop... + + return status; +} + +celix_status_t pubsub_topologyManager_subscriberRemoved(void * handle, service_reference_pt reference, void * service) { + celix_status_t status = CELIX_SUCCESS; + pubsub_topology_manager_pt manager = handle; + + pubsub_endpoint_pt subcmp = NULL; + if(pubsubEndpoint_createFromServiceReference(reference,&subcmp,false) == CELIX_SUCCESS){ + + int j,k; + + // Inform discoveries that we not interested in the topic any more + celixThreadMutex_lock(&manager->discoveryListLock); + hash_map_iterator_pt iter = hashMapIterator_create(manager->discoveryList); + while(hashMapIterator_hasNext(iter)){ + service_reference_pt disc_sr = (service_reference_pt)hashMapIterator_nextKey(iter); + publisher_endpoint_announce_pt disc = NULL; + bundleContext_getService(manager->context, disc_sr, (void**) &disc); + disc->uninterestedInTopic(disc->handle, subcmp->scope, subcmp->topic); + bundleContext_ungetService(manager->context, disc_sr, NULL); + } + hashMapIterator_destroy(iter); + celixThreadMutex_unlock(&manager->discoveryListLock); + + celixThreadMutex_lock(&manager->subscriptionsLock); + celixThreadMutex_lock(&manager->psaListLock); + + char *sub_key = createScopeTopicKey(subcmp->scope,subcmp->topic); + array_list_pt sub_list_by_topic = hashMap_get(manager->subscriptions,sub_key); + free(sub_key); + if(sub_list_by_topic!=NULL){ + for(j=0;j<arrayList_size(sub_list_by_topic);j++){ + pubsub_endpoint_pt sub = arrayList_get(sub_list_by_topic,j); + if(pubsubEndpoint_equals(sub,subcmp)){ + for(k=0;k<arrayList_size(manager->psaList);k++){ + /* No problem with invoking removal on all psa's, only the one that manage this topic will do something */ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,k); + psa->removeSubscription(psa->admin,sub); + } + + } + arrayList_remove(sub_list_by_topic,j); + + /* If it was the last subscriber for this topic, tell PSA to close the ZMQ socket */ + if(arrayList_size(sub_list_by_topic)==0){ + for(k=0;k<arrayList_size(manager->psaList);k++){ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,k); + psa->closeAllSubscriptions(psa->admin,sub->scope, sub->topic); + } + } + + pubsubEndpoint_destroy(sub); + + } + } + + celixThreadMutex_unlock(&manager->psaListLock); + celixThreadMutex_unlock(&manager->subscriptionsLock); + + pubsubEndpoint_destroy(subcmp); + + } + else{ + status=CELIX_INVALID_BUNDLE_CONTEXT; + } + + return status; + +} + +celix_status_t pubsub_topologyManager_pubsubDiscoveryAdded(void* handle, service_reference_pt reference, void* service) { + celix_status_t status = CELIX_SUCCESS; + pubsub_topology_manager_pt manager = (pubsub_topology_manager_pt)handle; + publisher_endpoint_announce_pt disc = (publisher_endpoint_announce_pt)service; + + const char* fwUUID = NULL; + + bundleContext_getProperty(manager->context,OSGI_FRAMEWORK_FRAMEWORK_UUID,&fwUUID); + if(fwUUID==NULL){ + printf("PSD: ERRROR: Cannot retrieve fwUUID.\n"); + return CELIX_INVALID_BUNDLE_CONTEXT; + } + + celixThreadMutex_lock(&manager->publicationsLock); + + celixThreadMutex_lock(&manager->discoveryListLock); + hashMap_put(manager->discoveryList, reference, NULL); + celixThreadMutex_unlock(&manager->discoveryListLock); + + hash_map_iterator_pt iter = hashMapIterator_create(manager->publications); + while(hashMapIterator_hasNext(iter)){ + array_list_pt pubEP_list = (array_list_pt)hashMapIterator_nextValue(iter); + for(int i = 0; i < arrayList_size(pubEP_list); i++) { + pubsub_endpoint_pt pubEP = (pubsub_endpoint_pt)arrayList_get(pubEP_list,i); + if( (strcmp(pubEP->frameworkUUID,fwUUID)==0) && (pubEP->endpoint!=NULL)){ + status += disc->announcePublisher(disc->handle,pubEP); + } + } + } + hashMapIterator_destroy(iter); + + celixThreadMutex_unlock(&manager->publicationsLock); + + celixThreadMutex_lock(&manager->subscriptionsLock); + iter = hashMapIterator_create(manager->subscriptions); + + while(hashMapIterator_hasNext(iter)) { + array_list_pt l = (array_list_pt)hashMapIterator_nextValue(iter); + int i; + for(i=0;i<arrayList_size(l);i++){ + pubsub_endpoint_pt subEp = (pubsub_endpoint_pt)arrayList_get(l,i); + + disc->interestedInTopic(disc->handle, subEp->scope, subEp->topic); + } + } + hashMapIterator_destroy(iter); + celixThreadMutex_unlock(&manager->subscriptionsLock); + + return status; +} + +celix_status_t pubsub_topologyManager_pubsubDiscoveryModified(void * handle, service_reference_pt reference, void * service) { + celix_status_t status = CELIX_SUCCESS; + + status = pubsub_topologyManager_pubsubDiscoveryRemoved(handle, reference, service); + if (status == CELIX_SUCCESS) { + status = pubsub_topologyManager_pubsubDiscoveryAdded(handle, reference, service); + } + + return status; +} + +celix_status_t pubsub_topologyManager_pubsubDiscoveryRemoved(void * handle, service_reference_pt reference, void * service) { + celix_status_t status = CELIX_SUCCESS; + + pubsub_topology_manager_pt manager = handle; + + celixThreadMutex_lock(&manager->discoveryListLock); + + + if (hashMap_remove(manager->discoveryList, reference)) { + logHelper_log(manager->loghelper, OSGI_LOGSERVICE_INFO, "EndpointListener Removed"); + } + + celixThreadMutex_unlock(&manager->discoveryListLock); + + return status; +} + + +celix_status_t pubsub_topologyManager_publisherTrackerAdded(void *handle, array_list_pt listeners) { + + celix_status_t status = CELIX_SUCCESS; + pubsub_topology_manager_pt manager = handle; + + int l_index; + + for (l_index = 0; l_index < arrayList_size(listeners); l_index++) { + + listener_hook_info_pt info = arrayList_get(listeners, l_index); + + pubsub_endpoint_pt pub = NULL; + if(pubsubEndpoint_createFromListenerHookInfo(info, &pub, true) == CELIX_SUCCESS){ + + celixThreadMutex_lock(&manager->publicationsLock); + char *pub_key = createScopeTopicKey(pub->scope, pub->topic); + array_list_pt pub_list_by_topic = hashMap_get(manager->publications, pub_key); + if(pub_list_by_topic==NULL){ + arrayList_create(&pub_list_by_topic); + hashMap_put(manager->publications,strdup(pub_key),pub_list_by_topic); + } + free(pub_key); + arrayList_add(pub_list_by_topic,pub); + + celixThreadMutex_unlock(&manager->publicationsLock); + + int j; + double score = 0; + double best_score = 0; + pubsub_admin_service_pt best_psa = NULL; + celixThreadMutex_lock(&manager->psaListLock); + + for(j=0;j<arrayList_size(manager->psaList);j++){ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,j); + psa->matchEndpoint(psa->admin,pub,&score); + if(score>best_score){ /* We have a new winner! */ + best_score = score; + best_psa = psa; + } + } + + if(best_psa != NULL && best_score>0){ + status = best_psa->addPublication(best_psa->admin,pub); + if(status==CELIX_SUCCESS){ + celixThreadMutex_lock(&manager->discoveryListLock); + hash_map_iterator_pt iter = hashMapIterator_create(manager->discoveryList); + while(hashMapIterator_hasNext(iter)){ + service_reference_pt disc_sr = (service_reference_pt)hashMapIterator_nextKey(iter); + publisher_endpoint_announce_pt disc = NULL; + bundleContext_getService(manager->context, disc_sr, (void**) &disc); + disc->announcePublisher(disc->handle,pub); + bundleContext_ungetService(manager->context, disc_sr, NULL); + } + hashMapIterator_destroy(iter); + celixThreadMutex_unlock(&manager->discoveryListLock); + } + } + + celixThreadMutex_unlock(&manager->psaListLock); + + } + + } + + return status; + +} + + +celix_status_t pubsub_topologyManager_publisherTrackerRemoved(void *handle, array_list_pt listeners) { + celix_status_t status = CELIX_SUCCESS; + pubsub_topology_manager_pt manager = handle; + + int l_index; + + for (l_index = 0; l_index < arrayList_size(listeners); l_index++) { + + listener_hook_info_pt info = arrayList_get(listeners, l_index); + + pubsub_endpoint_pt pubcmp = NULL; + if(pubsubEndpoint_createFromListenerHookInfo(info,&pubcmp,true) == CELIX_SUCCESS){ + + + int j,k; + celixThreadMutex_lock(&manager->psaListLock); + celixThreadMutex_lock(&manager->publicationsLock); + + char *pub_key = createScopeTopicKey(pubcmp->scope, pubcmp->topic); + array_list_pt pub_list_by_topic = hashMap_get(manager->publications,pub_key); + if(pub_list_by_topic!=NULL){ + for(j=0;j<arrayList_size(pub_list_by_topic);j++){ + pubsub_endpoint_pt pub = arrayList_get(pub_list_by_topic,j); + if(pubsubEndpoint_equals(pub,pubcmp)){ + for(k=0;k<arrayList_size(manager->psaList);k++){ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,k); + status = psa->removePublication(psa->admin,pub); + if(status==CELIX_SUCCESS){ /* We found the one that manages this endpoint */ + celixThreadMutex_lock(&manager->discoveryListLock); + hash_map_iterator_pt iter = hashMapIterator_create(manager->discoveryList); + while(hashMapIterator_hasNext(iter)){ + service_reference_pt disc_sr = (service_reference_pt)hashMapIterator_nextKey(iter); + publisher_endpoint_announce_pt disc = NULL; + bundleContext_getService(manager->context, disc_sr, (void**) &disc); + disc->removePublisher(disc->handle,pub); + bundleContext_ungetService(manager->context, disc_sr, NULL); + } + hashMapIterator_destroy(iter); + celixThreadMutex_unlock(&manager->discoveryListLock); + } + else if(status == CELIX_ILLEGAL_ARGUMENT){ /* Not a real error, just saying this psa does not handle this endpoint */ + status = CELIX_SUCCESS; + } + } + //} + arrayList_remove(pub_list_by_topic,j); + + /* If it was the last publisher for this topic, tell PSA to close the ZMQ socket and then inform the discovery */ + if(arrayList_size(pub_list_by_topic)==0){ + for(k=0;k<arrayList_size(manager->psaList);k++){ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,k); + psa->closeAllPublications(psa->admin,pub->scope, pub->topic); + } + } + + pubsubEndpoint_destroy(pub); + } + + } + } + + celixThreadMutex_unlock(&manager->publicationsLock); + celixThreadMutex_unlock(&manager->psaListLock); + + free(pub_key); + + pubsubEndpoint_destroy(pubcmp); + + } + + } + + return status; +} + +celix_status_t pubsub_topologyManager_announcePublisher(void *handle, pubsub_endpoint_pt pubEP){ + celix_status_t status = CELIX_SUCCESS; + printf("PSTM: New publisher discovered for topic %s [fwUUID=%s, ep=%s]\n",pubEP->topic,pubEP->frameworkUUID,pubEP->endpoint); + + pubsub_topology_manager_pt manager = handle; + celixThreadMutex_lock(&manager->psaListLock); + celixThreadMutex_lock(&manager->publicationsLock); + + char *pub_key = createScopeTopicKey(pubEP->scope, pubEP->topic); + + array_list_pt pub_list_by_topic = hashMap_get(manager->publications,pub_key); + if(pub_list_by_topic==NULL){ + arrayList_create(&pub_list_by_topic); + hashMap_put(manager->publications,strdup(pub_key),pub_list_by_topic); + } + free(pub_key); + + /* Shouldn't be any other duplicate, since it's filtered out by the discovery */ + pubsub_endpoint_pt p = NULL; + pubsubEndpoint_clone(pubEP, &p); + arrayList_add(pub_list_by_topic,p); + + int j; + double score = 0; + double best_score = 0; + pubsub_admin_service_pt best_psa = NULL; + + for(j=0;j<arrayList_size(manager->psaList);j++){ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,j); + psa->matchEndpoint(psa->admin,p,&score); + if(score>best_score){ /* We have a new winner! */ + best_score = score; + best_psa = psa; + } + } + + if(best_psa != NULL && best_score>0){ + best_psa->addPublication(best_psa->admin,p); + } + else{ + status = CELIX_ILLEGAL_STATE; + } + + celixThreadMutex_unlock(&manager->publicationsLock); + celixThreadMutex_unlock(&manager->psaListLock); + + return status; +} + +celix_status_t pubsub_topologyManager_removePublisher(void *handle, pubsub_endpoint_pt pubEP){ + celix_status_t status = CELIX_SUCCESS; + printf("PSTM: Publisher removed for topic %s [fwUUID=%s, ep=%s]\n",pubEP->topic,pubEP->frameworkUUID,pubEP->endpoint); + + pubsub_topology_manager_pt manager = handle; + celixThreadMutex_lock(&manager->psaListLock); + celixThreadMutex_lock(&manager->publicationsLock); + int i; + + char *pub_key = createScopeTopicKey(pubEP->scope, pubEP->topic); + array_list_pt pub_list_by_topic = hashMap_get(manager->publications,pub_key); + if(pub_list_by_topic==NULL){ + printf("PSTM: ERROR: Cannot find topic for known endpoint [%s,%s,%s]. Something is inconsistent.\n",pub_key,pubEP->frameworkUUID,pubEP->endpoint); + status = CELIX_ILLEGAL_STATE; + } + else{ + + pubsub_endpoint_pt p = NULL; + bool found = false; + + for(i=0;!found && i<arrayList_size(pub_list_by_topic);i++){ + p = (pubsub_endpoint_pt)arrayList_get(pub_list_by_topic,i); + found = pubsubEndpoint_equals(p,pubEP); + } + + if(found && p !=NULL){ + + for(i=0;i<arrayList_size(manager->psaList);i++){ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,i); + /* No problem with invoking removal on all psa's, only the one that manage this topic will do something */ + psa->removePublication(psa->admin,p); + } + + arrayList_removeElement(pub_list_by_topic,p); + + /* If it was the last publisher for this topic, tell PSA to close the ZMQ socket */ + if(arrayList_size(pub_list_by_topic)==0){ + + for(i=0;i<arrayList_size(manager->psaList);i++){ + pubsub_admin_service_pt psa = (pubsub_admin_service_pt)arrayList_get(manager->psaList,i); + psa->closeAllPublications(psa->admin,p->scope, p->topic); + } + } + + pubsubEndpoint_destroy(p); + } + + + } + free(pub_key); + celixThreadMutex_unlock(&manager->publicationsLock); + celixThreadMutex_unlock(&manager->psaListLock); + + + return status; +} + http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.h ---------------------------------------------------------------------- diff --git a/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.h b/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.h new file mode 100644 index 0000000..0074a75 --- /dev/null +++ b/pubsub/pubsub_topology_manager/src/pubsub_topology_manager.h @@ -0,0 +1,82 @@ +/** + *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. + */ +/* + * pubsub_topology_manager.h + * + * \date Sep 29, 2011 + * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> + * \copyright Apache License, Version 2.0 + */ + +#ifndef PUBSUB_TOPOLOGY_MANAGER_H_ +#define PUBSUB_TOPOLOGY_MANAGER_H_ + +#include "service_reference.h" +#include "bundle_context.h" +#include "log_helper.h" + +#include "pubsub_common.h" +#include "pubsub_endpoint.h" +#include "pubsub/publisher.h" +#include "pubsub/subscriber.h" + + +struct pubsub_topology_manager { + bundle_context_pt context; + + celix_thread_mutex_t psaListLock; + array_list_pt psaList; + + celix_thread_mutex_t discoveryListLock; + hash_map_pt discoveryList; //<serviceReference,NULL> + + celix_thread_mutex_t publicationsLock; + hash_map_pt publications; //<topic(string),list<pubsub_ep>> + + celix_thread_mutex_t subscriptionsLock; + hash_map_pt subscriptions; //<topic(string),list<pubsub_ep>> + + log_helper_pt loghelper; +}; + +typedef struct pubsub_topology_manager *pubsub_topology_manager_pt; + +celix_status_t pubsub_topologyManager_create(bundle_context_pt context, log_helper_pt logHelper, pubsub_topology_manager_pt *manager); +celix_status_t pubsub_topologyManager_destroy(pubsub_topology_manager_pt manager); +celix_status_t pubsub_topologyManager_closeImports(pubsub_topology_manager_pt manager); + +celix_status_t pubsub_topologyManager_psaAdded(void *handle, service_reference_pt reference, void *service); +celix_status_t pubsub_topologyManager_psaModified(void *handle, service_reference_pt reference, void *service); +celix_status_t pubsub_topologyManager_psaRemoved(void *handle, service_reference_pt reference, void *service); + +celix_status_t pubsub_topologyManager_pubsubDiscoveryAdded(void* handle, service_reference_pt reference, void* service); +celix_status_t pubsub_topologyManager_pubsubDiscoveryModified(void * handle, service_reference_pt reference, void* service); +celix_status_t pubsub_topologyManager_pubsubDiscoveryRemoved(void * handle, service_reference_pt reference, void* service); + +celix_status_t pubsub_topologyManager_subscriberAdded(void * handle, service_reference_pt reference, void * service); +celix_status_t pubsub_topologyManager_subscriberModified(void * handle, service_reference_pt reference, void * service); +celix_status_t pubsub_topologyManager_subscriberRemoved(void * handle, service_reference_pt reference, void * service); + +celix_status_t pubsub_topologyManager_publisherTrackerAdded(void *handle, array_list_pt listeners); +celix_status_t pubsub_topologyManager_publisherTrackerRemoved(void *handle, array_list_pt listeners); + +celix_status_t pubsub_topologyManager_announcePublisher(void *handle, pubsub_endpoint_pt pubEP); +celix_status_t pubsub_topologyManager_removePublisher(void *handle, pubsub_endpoint_pt pubEP); + +#endif /* PUBSUB_TOPOLOGY_MANAGER_H_ */ http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/pubsub/test/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/pubsub/test/CMakeLists.txt b/pubsub/test/CMakeLists.txt index 65e22e5..9fd324e 100644 --- a/pubsub/test/CMakeLists.txt +++ b/pubsub/test/CMakeLists.txt @@ -20,23 +20,21 @@ find_program(ETCD_CMD NAMES etcd) find_package(CppUTest REQUIRED) include_directories(${CPPUTEST_INCLUDE_DIR}) -include_directories( - ${CMAKE_SOURCE_DIR}/pubsub/api - test -) - add_bundle(pubsub_sut #"Vanilla" bundle which is under test SOURCES test/sut_activator.c VERSION 1.0.0 ) -target_link_libraries(pubsub_sut PRIVATE Celix::framework) +target_include_directories(pubsub_sut PRIVATE test) +target_link_libraries(pubsub_sut PRIVATE Celix::pubsub_spi) + bundle_files(pubsub_sut msg_descriptors/msg.descriptor msg_descriptors/sync.descriptor DESTINATION "META-INF/descriptors/messages" ) + add_deploy(pubsub_udpmc_sut NAME deploy_sut BUNDLES http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/remote_services/CMakeLists.txt b/remote_services/CMakeLists.txt index bb45908..ae27849 100644 --- a/remote_services/CMakeLists.txt +++ b/remote_services/CMakeLists.txt @@ -18,23 +18,24 @@ celix_subproject(REMOTE_SERVICE_ADMIN "Option to enable building the Remote Service Admin Service bundles" OFF) if (REMOTE_SERVICE_ADMIN) - add_subdirectory(examples) + add_subdirectory(remote_services_api) + add_subdirectory(rsa_spi) + add_subdirectory(rsa_common) + + add_subdirectory(civetweb) add_subdirectory(topology_manager) - add_subdirectory(civetweb) add_subdirectory(discovery_common) add_subdirectory(discovery_configured) add_subdirectory(discovery_etcd) add_subdirectory(discovery_shm) #TODO refactor shm rsa to use dfi - add_subdirectory(remote_service_admin_api) - add_subdirectory(remote_service_admin_common) #add_subdirectory(remote_service_admin_shm) add_subdirectory(remote_service_admin_dfi) - + add_subdirectory(examples) endif (REMOTE_SERVICE_ADMIN) http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/discovery_common/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/remote_services/discovery_common/CMakeLists.txt b/remote_services/discovery_common/CMakeLists.txt index c3242a6..114f485 100644 --- a/remote_services/discovery_common/CMakeLists.txt +++ b/remote_services/discovery_common/CMakeLists.txt @@ -31,7 +31,7 @@ target_include_directories(rsa_discovery_common PUBLIC $<TARGET_PROPERTY:Celix::framework,INTERFACE_INCLUDE_DIRECTORIES> $<TARGET_PROPERTY:Celix::utils,INTERFACE_INCLUDE_DIRECTORIES> $<TARGET_PROPERTY:Celix::log_helper,INTERFACE_INCLUDE_DIRECTORIES> - $<TARGET_PROPERTY:Celix::rsa_api,INTERFACE_INCLUDE_DIRECTORIES> + $<TARGET_PROPERTY:Celix::rsa_spi,INTERFACE_INCLUDE_DIRECTORIES> $<TARGET_PROPERTY:civetweb,INCLUDE_DIRECTORIES> ${LIBXML2_INCLUDE_DIR}) http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/examples/calculator_service/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/remote_services/examples/calculator_service/CMakeLists.txt b/remote_services/examples/calculator_service/CMakeLists.txt index 5d97d16..167e705 100644 --- a/remote_services/examples/calculator_service/CMakeLists.txt +++ b/remote_services/examples/calculator_service/CMakeLists.txt @@ -23,7 +23,7 @@ add_bundle(calculator VERSION 0.0.1 ) target_include_directories(calculator PRIVATE src) -target_link_libraries(calculator PRIVATE Celix::rsa_api calculator_api) +target_link_libraries(calculator PRIVATE Celix::rsa_spi calculator_api) get_target_property(DESCR calculator_api INTERFACE_CALCULATOR_DESCRIPTOR) bundle_files(calculator ${DESCR} DESTINATION .) http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/CMakeLists.txt b/remote_services/remote_service_admin_api/CMakeLists.txt deleted file mode 100644 index f665576..0000000 --- a/remote_services/remote_service_admin_api/CMakeLists.txt +++ /dev/null @@ -1,45 +0,0 @@ -# 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. - -add_library(rsa_api INTERFACE) -target_include_directories(rsa_api INTERFACE include) - -install (FILES - include/remote_endpoint_impl.h - include/remote_endpoint.h - include/remote_proxy.h - include/remote_service_admin.h - include/export_registration.h - include/import_registration.h - include/endpoint_description.h - include/endpoint_listener.h - include/remote_constants.h - DESTINATION - include/celix/remote_service_admin - COMPONENT - remote_service_admin -) -install (FILES - public/include/endpoint_listener.h - DESTINATION - include/celix/endpoint_listener - COMPONENT - remote_service_admin -) - -#Setup target aliases to match external usage -add_library(Celix::rsa_api ALIAS rsa_api) http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/README.md ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/README.md b/remote_services/remote_service_admin_api/README.md deleted file mode 100644 index 2e3d268..0000000 --- a/remote_services/remote_service_admin_api/README.md +++ /dev/null @@ -1,11 +0,0 @@ -# Remote Service Admin - -The Remote Service Admin (RSA) provides the mechanisms to import and export services when instructed to do so by the Topology Manager. - -To delegate method calls to the actual service implementation, the RSA_SHM and the RSA_HTTP are using "endpoint/proxy" bundles, which has all the knowledge about the marshalling and unmarshalling of data for the service. The RSA_DFI implementation combines a [foreign function interface](https://en.wikipedia.org/wiki/Foreign_function_interface) technique together with manualy created descriptors. - -Note that this folder contains code commonly used by the RSA implementations and therefore does not include any CMAKE configuration. - -## Properties - ENDPOINTS defines the relative directory where endpoints and proxys can be found (default: endpoints) - CELIX_FRAMEWORK_EXTENDER_PATH Used in RSA_DFI only. Can be used to define a path to use as an extender path point for the framework bundle. For normal bundles the bundle cache is used. http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/endpoint_description.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/endpoint_description.h b/remote_services/remote_service_admin_api/include/endpoint_description.h deleted file mode 100644 index de27d2e..0000000 --- a/remote_services/remote_service_admin_api/include/endpoint_description.h +++ /dev/null @@ -1,50 +0,0 @@ -/** - *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. - */ -/* - * endpoint_description.h - * - * \date 25 Jul 2014 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ - -#ifndef ENDPOINT_DESCRIPTION_H_ -#define ENDPOINT_DESCRIPTION_H_ - -#include "properties.h" -#include "array_list.h" - -struct endpoint_description { - char *frameworkUUID; - char *id; - // array_list_pt intents; - char *service; - // HASH_MAP packageVersions; - properties_pt properties; - unsigned long serviceId; -}; - -typedef struct endpoint_description endpoint_description_t; -typedef endpoint_description_t* endpoint_description_pt; - -celix_status_t endpointDescription_create(properties_pt properties, endpoint_description_pt *endpointDescription); -celix_status_t endpointDescription_destroy(endpoint_description_pt description); - - -#endif /* ENDPOINT_DESCRIPTION_H_ */ http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/endpoint_listener.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/endpoint_listener.h b/remote_services/remote_service_admin_api/include/endpoint_listener.h deleted file mode 100644 index 2e6359f..0000000 --- a/remote_services/remote_service_admin_api/include/endpoint_listener.h +++ /dev/null @@ -1,49 +0,0 @@ -/** - *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. - */ -/* - * endpoint_listener.h - * - * \date Sep 29, 2011 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ - -#ifndef ENDPOINT_LISTENER_H_ -#define ENDPOINT_LISTENER_H_ - -#include "array_list.h" -#include "properties.h" - -#include "endpoint_description.h" - -static const char * const OSGI_ENDPOINT_LISTENER_SERVICE = "endpoint_listener"; - -static const char * const OSGI_ENDPOINT_LISTENER_SCOPE = "endpoint.listener.scope"; - -struct endpoint_listener { - void *handle; - celix_status_t (*endpointAdded)(void *handle, endpoint_description_pt endpoint, char *machtedFilter); - celix_status_t (*endpointRemoved)(void *handle, endpoint_description_pt endpoint, char *machtedFilter); -}; - -typedef struct endpoint_listener endpoint_listener_t; -typedef endpoint_listener_t *endpoint_listener_pt; - - -#endif /* ENDPOINT_LISTENER_H_ */ http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/export_registration.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/export_registration.h b/remote_services/remote_service_admin_api/include/export_registration.h deleted file mode 100644 index dc3882b..0000000 --- a/remote_services/remote_service_admin_api/include/export_registration.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Licensed under Apache License v2. See LICENSE for more information. - */ -#ifndef CELIX_EXPORT_REGISTRATION_H -#define CELIX_EXPORT_REGISTRATION_H - -#include "celix_errno.h" -#include "endpoint_description.h" -#include "service_reference.h" - -typedef struct export_registration *export_registration_pt; - -typedef struct export_reference *export_reference_pt; - -celix_status_t exportRegistration_close(export_registration_pt registration); -celix_status_t exportRegistration_getException(export_registration_pt registration); -celix_status_t exportRegistration_getExportReference(export_registration_pt registration, export_reference_pt *reference); - -celix_status_t exportReference_getExportedEndpoint(export_reference_pt reference, endpoint_description_pt *endpoint); -celix_status_t exportReference_getExportedService(export_reference_pt reference, service_reference_pt *service); - -#endif //CELIX_EXPORT_REGISTRATION_H http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/import_registration.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/import_registration.h b/remote_services/remote_service_admin_api/include/import_registration.h deleted file mode 100644 index ef8193f..0000000 --- a/remote_services/remote_service_admin_api/include/import_registration.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Licensed under Apache License v2. See LICENSE for more information. - */ -#ifndef CELIX_IMPORT_REGISTRATION_H -#define CELIX_IMPORT_REGISTRATION_H - -#include "celix_errno.h" -#include "endpoint_description.h" -#include "service_reference.h" - -typedef struct import_registration *import_registration_pt; - -typedef struct import_reference *import_reference_pt; - -celix_status_t importRegistration_close(import_registration_pt registration); -celix_status_t importRegistration_getException(import_registration_pt registration); -celix_status_t importRegistration_getImportReference(import_registration_pt registration, import_reference_pt *reference); - -celix_status_t importReference_getImportedEndpoint(import_reference_pt reference); -celix_status_t importReference_getImportedService(import_reference_pt reference); - -#endif //CELIX_IMPORT_REGISTRATION_H http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/remote_constants.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/remote_constants.h b/remote_services/remote_service_admin_api/include/remote_constants.h deleted file mode 100644 index 0736685..0000000 --- a/remote_services/remote_service_admin_api/include/remote_constants.h +++ /dev/null @@ -1,38 +0,0 @@ -/** - *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. - */ -/* - * remote_constants.h - * - * \date Sep 30, 2011 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ - -#ifndef REMOTE_CONSTANTS_H_ -#define REMOTE_CONSTANTS_H_ - -static const char * const OSGI_RSA_SERVICE_EXPORTED_INTERFACES = "service.exported.interfaces"; -static const char * const OSGI_RSA_ENDPOINT_FRAMEWORK_UUID = "endpoint.framework.uuid"; -static const char * const OSGI_RSA_ENDPOINT_SERVICE_ID = "endpoint.service.id"; -static const char * const OSGI_RSA_ENDPOINT_ID = "endpoint.id"; -static const char * const OSGI_RSA_SERVICE_IMPORTED = "service.imported"; -static const char * const OSGI_RSA_SERVICE_IMPORTED_CONFIGS = "service.imported.configs"; -static const char * const OSGI_RSA_SERVICE_LOCATION = "service.location"; - -#endif /* REMOTE_CONSTANTS_H_ */ http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/remote_endpoint.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/remote_endpoint.h b/remote_services/remote_service_admin_api/include/remote_endpoint.h deleted file mode 100644 index ab80abb..0000000 --- a/remote_services/remote_service_admin_api/include/remote_endpoint.h +++ /dev/null @@ -1,44 +0,0 @@ -/** - *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. - */ -/* - * remote_endpoint.h - * - * \date Oct 7, 2011 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ - -#ifndef REMOTE_ENDPOINT_H_ -#define REMOTE_ENDPOINT_H_ - -#define OSGI_RSA_REMOTE_ENDPOINT "remote_endpoint" - -typedef struct remote_endpoint remote_endpoint_t; -typedef remote_endpoint_t* remote_endpoint_pt; - -struct remote_endpoint_service { - remote_endpoint_pt endpoint; - celix_status_t (*setService)(remote_endpoint_pt endpoint, void *service); - celix_status_t (*handleRequest)(remote_endpoint_pt endpoint, char *data, char **reply); -}; - -typedef struct remote_endpoint_service *remote_endpoint_service_pt; - - -#endif /* REMOTE_ENDPOINT_H_ */ http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/remote_endpoint_impl.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/remote_endpoint_impl.h b/remote_services/remote_service_admin_api/include/remote_endpoint_impl.h deleted file mode 100644 index 3782d62..0000000 --- a/remote_services/remote_service_admin_api/include/remote_endpoint_impl.h +++ /dev/null @@ -1,38 +0,0 @@ -/** - *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. - */ -/* - * remote_endpoint_impl.h - * - * \date Oct 11, 2011 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ - -#ifndef REMOTE_ENDPOINT_IMPL_H_ -#define REMOTE_ENDPOINT_IMPL_H_ - -#include "remote_endpoint.h" -#include "celix_threads.h" - -struct remote_endpoint { - celix_thread_mutex_t serviceLock; - void *service; -}; - -#endif /* REMOTE_ENDPOINT_IMPL_H_ */ http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/remote_proxy.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/remote_proxy.h b/remote_services/remote_service_admin_api/include/remote_proxy.h deleted file mode 100644 index 4c3f5c3..0000000 --- a/remote_services/remote_service_admin_api/include/remote_proxy.h +++ /dev/null @@ -1,76 +0,0 @@ -/** - *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. - */ -/* - * remote_proxy.h - * - * \date Oct 13, 2011 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ - -#ifndef REMOTE_PROXY_H_ -#define REMOTE_PROXY_H_ - -#include "endpoint_listener.h" -#include "remote_service_admin.h" - -#define OSGI_RSA_REMOTE_PROXY_FACTORY "remote_proxy_factory" -#define OSGI_RSA_REMOTE_PROXY_TIMEOUT "remote_proxy_timeout" - -typedef celix_status_t (*sendToHandle)(remote_service_admin_pt remote_service_admin_ptr, endpoint_description_pt endpointDescription, char *request, char **reply, int* replyStatus); -typedef celix_status_t (*createProxyService)(void *handle, endpoint_description_pt endpointDescription, remote_service_admin_pt rsa, sendToHandle sendToCallback, properties_pt properties, void **service); -typedef celix_status_t (*destroyProxyService)(void *handle, void *service); - -typedef struct remote_proxy_factory *remote_proxy_factory_pt; -typedef struct remote_proxy_factory_service *remote_proxy_factory_service_pt; - -struct remote_proxy_factory { - bundle_context_pt context_ptr; - char *service; - - remote_proxy_factory_service_pt remote_proxy_factory_service_ptr; - properties_pt properties; - service_registration_pt registration; - - hash_map_pt proxy_instances; - - void *handle; - - createProxyService create_proxy_service_ptr; - destroyProxyService destroy_proxy_service_ptr; -}; - -struct remote_proxy_factory_service { - remote_proxy_factory_pt factory; - celix_status_t (*registerProxyService)(remote_proxy_factory_pt proxyFactoryService, endpoint_description_pt endpoint, remote_service_admin_pt remote_service_admin_ptr, sendToHandle callback); - celix_status_t (*unregisterProxyService)(remote_proxy_factory_pt proxyFactoryService, endpoint_description_pt endpoint); -}; - -celix_status_t remoteProxyFactory_create(bundle_context_pt context, char *service, void *handle, - createProxyService create, destroyProxyService destroy, - remote_proxy_factory_pt *remote_proxy_factory_ptr); -celix_status_t remoteProxyFactory_destroy(remote_proxy_factory_pt *remote_proxy_factory_ptr); - -celix_status_t remoteProxyFactory_register(remote_proxy_factory_pt remote_proxy_factory_ptr); -celix_status_t remoteProxyFactory_unregister(remote_proxy_factory_pt remote_proxy_factory_ptr); - - - - -#endif /* REMOTE_PROXY_H_ */ http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_api/include/remote_service_admin.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_api/include/remote_service_admin.h b/remote_services/remote_service_admin_api/include/remote_service_admin.h deleted file mode 100644 index cc7fd98..0000000 --- a/remote_services/remote_service_admin_api/include/remote_service_admin.h +++ /dev/null @@ -1,73 +0,0 @@ -/** - *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. - */ -/* - * remote_service_admin.h - * - * \date Sep 30, 2011 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ - -#ifndef REMOTE_SERVICE_ADMIN_H_ -#define REMOTE_SERVICE_ADMIN_H_ - -#include "endpoint_listener.h" -#include "service_reference.h" -#include "export_registration.h" -#include "import_registration.h" - -#define OSGI_RSA_REMOTE_SERVICE_ADMIN "remote_service_admin" - -typedef struct import_registration_factory import_registration_factory_t; -typedef import_registration_factory_t* import_registration_factory_pt; - -typedef struct remote_service_admin remote_service_admin_t; -typedef remote_service_admin_t* remote_service_admin_pt; - -struct remote_service_admin_service { - remote_service_admin_pt admin; - celix_status_t (*exportService)(remote_service_admin_pt admin, char *serviceId, properties_pt properties, array_list_pt *registrations); - celix_status_t (*removeExportedService)(remote_service_admin_pt admin, export_registration_pt registration); - celix_status_t (*getExportedServices)(remote_service_admin_pt admin, array_list_pt *services); - celix_status_t (*getImportedEndpoints)(remote_service_admin_pt admin, array_list_pt *services); - celix_status_t (*importService)(remote_service_admin_pt admin, endpoint_description_pt endpoint, import_registration_pt *registration); - - celix_status_t (*exportReference_getExportedEndpoint)(export_reference_pt reference, endpoint_description_pt *endpoint); - celix_status_t (*exportReference_getExportedService)(export_reference_pt reference, service_reference_pt *service); - - celix_status_t (*exportRegistration_close)(remote_service_admin_pt admin, export_registration_pt registration); - celix_status_t (*exportRegistration_getException)(export_registration_pt registration); - celix_status_t (*exportRegistration_getExportReference)(export_registration_pt registration, export_reference_pt *reference); - celix_status_t (*exportRegistration_freeExportReference)(export_reference_pt *reference); - celix_status_t (*exportRegistration_getEndpointDescription)(export_registration_pt registration, endpoint_description_pt endpointDescription); - - celix_status_t (*importReference_getImportedEndpoint)(import_reference_pt reference); - celix_status_t (*importReference_getImportedService)(import_reference_pt reference); - - celix_status_t (*importRegistration_close)(remote_service_admin_pt admin, import_registration_pt registration); - celix_status_t (*importRegistration_getException)(import_registration_pt registration); - celix_status_t (*importRegistration_getImportReference)(import_registration_pt registration, import_reference_pt *reference); - -}; - -typedef struct remote_service_admin_service remote_service_admin_service_t; -typedef remote_service_admin_service_t* remote_service_admin_service_pt; - - -#endif /* REMOTE_SERVICE_ADMIN_H_ */ http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_common/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_common/CMakeLists.txt b/remote_services/remote_service_admin_common/CMakeLists.txt deleted file mode 100644 index 018d868..0000000 --- a/remote_services/remote_service_admin_common/CMakeLists.txt +++ /dev/null @@ -1,27 +0,0 @@ -# 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. - -add_library(rsa_common STATIC - src/endpoint_description.c - src/export_registration_impl.c - src/import_registration_impl.c -) -target_include_directories(rsa_common PRIVATE src) -target_link_libraries(rsa_common PUBLIC Celix::framework Celix::rsa_api Celix::log_helper) - -#Setup target aliases to match external usage -add_library(Celix::rsa_common ALIAS rsa_common) \ No newline at end of file http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_common/src/endpoint_description.c ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_common/src/endpoint_description.c b/remote_services/remote_service_admin_common/src/endpoint_description.c deleted file mode 100644 index 0d8b684..0000000 --- a/remote_services/remote_service_admin_common/src/endpoint_description.c +++ /dev/null @@ -1,89 +0,0 @@ -/** - *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. - */ -/* - * endpoint_description.c - * - * \date 25 Jul 2014 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ -#include <stdlib.h> -#include <string.h> - -#include "celix_errno.h" -#include "celix_log.h" - -#include "endpoint_description.h" -#include "remote_constants.h" -#include "constants.h" - -static celix_status_t endpointDescription_verifyLongProperty(properties_pt properties, char *propertyName, unsigned long *longProperty); - -celix_status_t endpointDescription_create(properties_pt properties, endpoint_description_pt *endpointDescription) { - celix_status_t status = CELIX_SUCCESS; - - unsigned long serviceId = 0UL; - status = endpointDescription_verifyLongProperty(properties, (char *) OSGI_RSA_ENDPOINT_SERVICE_ID, &serviceId); - if (status != CELIX_SUCCESS) { - return status; - } - - endpoint_description_pt ep = calloc(1,sizeof(*ep)); - - ep->properties = properties; - ep->frameworkUUID = (char*)properties_get(properties, OSGI_RSA_ENDPOINT_FRAMEWORK_UUID); - ep->id = (char*)properties_get(properties, OSGI_RSA_ENDPOINT_ID); - ep->service = strndup(properties_get(properties, OSGI_FRAMEWORK_OBJECTCLASS), 1024*10); - ep->serviceId = serviceId; - - if (!(ep->frameworkUUID) || !(ep->id) || !(ep->service) ) { - fw_log(logger, OSGI_FRAMEWORK_LOG_ERROR, "ENDPOINT_DESCRIPTION: incomplete description!."); - status = CELIX_BUNDLE_EXCEPTION; - } - - if(status == CELIX_SUCCESS){ - *endpointDescription = ep; - } - else{ - *endpointDescription = NULL; - free(ep); - } - - return status; -} - -celix_status_t endpointDescription_destroy(endpoint_description_pt description) { - properties_destroy(description->properties); - free(description->service); - free(description); - return CELIX_SUCCESS; -} - -static celix_status_t endpointDescription_verifyLongProperty(properties_pt properties, char *propertyName, unsigned long *longProperty) { - celix_status_t status = CELIX_SUCCESS; - - const char *value = properties_get(properties, propertyName); - if (value == NULL) { - *longProperty = 0UL; - } else { - *longProperty = strtoul(value,NULL,10); - } - - return status; -} http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_common/src/export_registration_impl.c ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_common/src/export_registration_impl.c b/remote_services/remote_service_admin_common/src/export_registration_impl.c deleted file mode 100644 index 1c684e7..0000000 --- a/remote_services/remote_service_admin_common/src/export_registration_impl.c +++ /dev/null @@ -1,257 +0,0 @@ -/** - *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. - */ -/* - * export_registration_impl.c - * - * \date Oct 6, 2011 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ -#include <stdlib.h> - -#include "constants.h" - -#include "celix_errno.h" - -#include "export_registration_impl.h" -#include "remote_service_admin_impl.h" - - -struct export_reference { - endpoint_description_pt endpoint; - service_reference_pt reference; -}; - -celix_status_t exportRegistration_endpointAdding(void * handle, service_reference_pt reference, void **service); -celix_status_t exportRegistration_endpointAdded(void * handle, service_reference_pt reference, void *service); -celix_status_t exportRegistration_endpointModified(void * handle, service_reference_pt reference, void *service); -celix_status_t exportRegistration_endpointRemoved(void * handle, service_reference_pt reference, void *service); - -celix_status_t exportRegistration_createEndpointTracker(export_registration_pt registration, service_tracker_pt *tracker); - -celix_status_t exportRegistration_create(log_helper_pt helper, service_reference_pt reference, endpoint_description_pt endpoint, remote_service_admin_pt rsa, bundle_context_pt context, export_registration_pt *registration) { - celix_status_t status = CELIX_SUCCESS; - - *registration = calloc(1, sizeof(**registration)); - if (!*registration) { - status = CELIX_ENOMEM; - } else { - (*registration)->context = context; - (*registration)->closed = false; - (*registration)->endpointDescription = endpoint; - (*registration)->reference = reference; - (*registration)->rsa = rsa; - (*registration)->tracker = NULL; - (*registration)->endpoint = NULL; - (*registration)->endpointTracker = NULL; - (*registration)->exportReference = NULL; - (*registration)->bundle = NULL; - (*registration)->loghelper = helper; - } - - return status; -} - -celix_status_t exportRegistration_destroy(export_registration_pt *registration) { - celix_status_t status = CELIX_SUCCESS; - - remoteServiceAdmin_destroyEndpointDescription(&(*registration)->endpointDescription); - free(*registration); - - return status; -} - -celix_status_t exportRegistration_startTracking(export_registration_pt registration) { - celix_status_t status = CELIX_SUCCESS; - - if (registration->endpointTracker == NULL) { - status = exportRegistration_createEndpointTracker(registration, ®istration->endpointTracker); - if (status == CELIX_SUCCESS) { - status = serviceTracker_open(registration->endpointTracker); - } - } - - return status; -} - -celix_status_t exportRegistration_stopTracking(export_registration_pt registration) { - celix_status_t status = CELIX_SUCCESS; - - if (registration->endpointTracker != NULL) { - status = serviceTracker_close(registration->endpointTracker); - if (status != CELIX_SUCCESS) { - logHelper_log(registration->loghelper, OSGI_LOGSERVICE_ERROR, "EXPORT_REGISTRATION: Could not close endpoint tracker"); - } - else { - status = serviceTracker_destroy(registration->endpointTracker); - } - } - if (registration->tracker != NULL) { - status = serviceTracker_close(registration->tracker); - if (status != CELIX_SUCCESS) { - logHelper_log(registration->loghelper, OSGI_LOGSERVICE_ERROR, "EXPORT_REGISTRATION: Could not close service tracker"); - } - else { - status = serviceTracker_destroy(registration->tracker); - } - } - - return status; -} - -celix_status_t exportRegistration_createEndpointTracker(export_registration_pt registration, service_tracker_pt *tracker) { - celix_status_t status; - - service_tracker_customizer_pt customizer = NULL; - - status = serviceTrackerCustomizer_create(registration, exportRegistration_endpointAdding, - exportRegistration_endpointAdded, exportRegistration_endpointModified, exportRegistration_endpointRemoved, &customizer); - - if (status == CELIX_SUCCESS) { - char filter[512]; - - snprintf(filter, 512, "(&(%s=%s)(remote.interface=%s))", (char*) OSGI_FRAMEWORK_OBJECTCLASS, (char*) OSGI_RSA_REMOTE_ENDPOINT, registration->endpointDescription->service); - status = serviceTracker_createWithFilter(registration->context, filter, customizer, tracker); - } - - return status; -} - -celix_status_t exportRegistration_endpointAdding(void * handle, service_reference_pt reference, void **service) { - celix_status_t status; - export_registration_pt registration = handle; - - status = bundleContext_getService(registration->context, reference, service); - - return status; -} - -celix_status_t exportRegistration_endpointAdded(void * handle, service_reference_pt reference, void *endpoint_service) { - celix_status_t status = CELIX_SUCCESS; - export_registration_pt registration = handle; - - remote_endpoint_service_pt endpoint = endpoint_service; - if (registration->endpoint == NULL) { - registration->endpoint = endpoint; - void *service = NULL; - status = bundleContext_getService(registration->context, registration->reference, &service); - if (status == CELIX_SUCCESS) { - endpoint->setService(endpoint->endpoint, service); - } - } - - return status; -} - -celix_status_t exportRegistration_endpointModified(void * handle, service_reference_pt reference, void *service) { - celix_status_t status = CELIX_SUCCESS; - - return status; -} - -celix_status_t exportRegistration_endpointRemoved(void * handle, service_reference_pt reference, void *service) { - celix_status_t status = CELIX_SUCCESS; - export_registration_pt registration = handle; - - remote_endpoint_service_pt endpoint = service; - if (registration->endpoint != NULL) { - endpoint->setService(endpoint->endpoint, NULL); - } - - return status; -} - -celix_status_t exportRegistration_open(export_registration_pt registration) { - celix_status_t status = CELIX_SUCCESS; - const char *bundleStore = NULL; - - bundleContext_getProperty(registration->context, BUNDLE_STORE_PROPERTY_NAME, &bundleStore); - - if (bundleStore == NULL) { - bundleStore = DEFAULT_BUNDLE_STORE; - } - char name[256]; - - snprintf(name, 256, "%s/%s_endpoint.zip", bundleStore, registration->endpointDescription->service); - - status = bundleContext_installBundle(registration->context, name, ®istration->bundle); - if (status == CELIX_SUCCESS) { - status = bundle_start(registration->bundle); - if (status == CELIX_SUCCESS) { - } - } - - return status; -} - -celix_status_t exportRegistration_close(export_registration_pt registration) { - celix_status_t status = CELIX_SUCCESS; - - exportRegistration_stopTracking(registration); - - bundle_uninstall(registration->bundle); - - - return status; -} - -celix_status_t exportRegistration_getException(export_registration_pt registration) { - celix_status_t status = CELIX_SUCCESS; - return status; -} - -celix_status_t exportRegistration_getExportReference(export_registration_pt registration, export_reference_pt *reference) { - celix_status_t status = CELIX_SUCCESS; - - registration->exportReference = calloc(1, sizeof(*registration->exportReference)); - - if (registration->exportReference == NULL) { - status = CELIX_ENOMEM; - } else { - registration->exportReference->endpoint = registration->endpointDescription; - registration->exportReference->reference = registration->reference; - } - - *reference = registration->exportReference; - - return status; -} - -celix_status_t exportRegistration_setEndpointDescription(export_registration_pt registration, endpoint_description_pt endpointDescription) { - celix_status_t status = CELIX_SUCCESS; - - registration->endpointDescription = endpointDescription; - - return status; -} - -celix_status_t exportReference_getExportedEndpoint(export_reference_pt reference, endpoint_description_pt *endpoint) { - celix_status_t status = CELIX_SUCCESS; - - *endpoint = reference->endpoint; - - return status; -} - -celix_status_t exportReference_getExportedService(export_reference_pt reference, service_reference_pt *service) { - celix_status_t status = CELIX_SUCCESS; - *service = reference->reference; - return status; -} - http://git-wip-us.apache.org/repos/asf/celix/blob/81804e00/remote_services/remote_service_admin_common/src/export_registration_impl.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_common/src/export_registration_impl.h b/remote_services/remote_service_admin_common/src/export_registration_impl.h deleted file mode 100644 index bb276f9..0000000 --- a/remote_services/remote_service_admin_common/src/export_registration_impl.h +++ /dev/null @@ -1,61 +0,0 @@ -/** - *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. - */ -/* - * export_registration_impl.h - * - * \date Oct 6, 2011 - * \author <a href="mailto:[email protected]";>Apache Celix Project Team</a> - * \copyright Apache License, Version 2.0 - */ - -#ifndef EXPORT_REGISTRATION_IMPL_H_ -#define EXPORT_REGISTRATION_IMPL_H_ - -#include "remote_service_admin.h" -#include "remote_endpoint.h" -#include "service_tracker.h" -#include "log_helper.h" - -struct export_registration { - bundle_context_pt context; - remote_service_admin_pt rsa; - endpoint_description_pt endpointDescription; - service_reference_pt reference; - log_helper_pt loghelper; - - service_tracker_pt tracker; - service_tracker_pt endpointTracker; - - remote_endpoint_service_pt endpoint; - - export_reference_pt exportReference; - bundle_pt bundle; - - bool closed; -}; - -celix_status_t exportRegistration_create(log_helper_pt helper, service_reference_pt reference, endpoint_description_pt endpoint, remote_service_admin_pt rsa, bundle_context_pt context, export_registration_pt *registration); -celix_status_t exportRegistration_destroy(export_registration_pt *registration); -celix_status_t exportRegistration_open(export_registration_pt registration); - -celix_status_t exportRegistration_setEndpointDescription(export_registration_pt registration, endpoint_description_pt endpointDescription); -celix_status_t exportRegistration_startTracking(export_registration_pt registration); -celix_status_t exportRegistration_stopTracking(export_registration_pt registration); - -#endif /* EXPORT_REGISTRATION_IMPL_H_ */
