celix_status_t serviceRegistry_unregisterServices(service_registry_pt registry, bundle_pt bundle) { array_list_pt regs = NULL; unsigned int i; celixThreadMutex_lock(®istry->mutex); regs = (array_list_pt) hashMap_get(registry->serviceRegistrations, bundle); celixThreadMutex_unlock(®istry->mutex); for (i = 0; (regs != NULL) && i < arrayList_size(regs); i++) { service_registration_pt reg = arrayList_get(regs, i); if (serviceRegistration_isValid(reg)) { serviceRegistration_unregister(reg); } } if (regs != NULL && arrayList_isEmpty(regs)) { celixThreadMutex_lock(®istry->mutex); array_list_pt removed = hashMap_remove(registry->serviceRegistrations, bundle); celixThreadMutex_unlock(®istry->mutex); arrayList_destroy(removed); removed = NULL; } celixThreadMutex_lock(®istry->mutex); hashMap_remove(registry->serviceRegistrations, bundle); celixThreadMutex_unlock(®istry->mutex); return CELIX_SUCCESS; }
void test_hashMap_remove(void) { char * key = "key"; char * value = "value"; char * key2 = NULL; char * value2 = "value2"; char * removeKey; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry with null key hashMap_put(map, key2, value2); // Remove unexisting entry for map removeKey = "unexisting"; hashMap_remove(map, removeKey); CU_ASSERT_EQUAL(map->size, 2); CU_ASSERT_FALSE(hashMap_isEmpty(map)); hashMap_remove(map, key); CU_ASSERT_EQUAL(map->size, 1); hashMap_remove(map, key2); CU_ASSERT_EQUAL(map->size, 0); CU_ASSERT_TRUE(hashMap_isEmpty(map)); // Remove unexisting entry for empty map removeKey = "unexisting"; hashMap_remove(map, removeKey); CU_ASSERT_EQUAL(map->size, 0); CU_ASSERT_TRUE(hashMap_isEmpty(map)); }
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 pubsubAdmin_closeAllSubscriptions(pubsub_admin_pt admin,char* scope,char* topic){ celix_status_t status = CELIX_SUCCESS; printf("PSA_ZMQ: Closing all subscriptions\n"); celixThreadMutex_lock(&admin->subscriptionsLock); char *scope_topic = createScopeTopicKey(scope, topic); hash_map_entry_pt sub_entry = (hash_map_entry_pt)hashMap_getEntry(admin->subscriptions,scope_topic); if(sub_entry!=NULL){ char* topic = (char*)hashMapEntry_getKey(sub_entry); topic_subscription_pt ts = (topic_subscription_pt)hashMapEntry_getValue(sub_entry); status += pubsub_topicSubscriptionStop(ts); disconnectTopicPubSubFromSerializer(admin, ts, false); status += pubsub_topicSubscriptionDestroy(ts); hashMap_remove(admin->subscriptions,scope_topic); free(topic); } free(scope_topic); celixThreadMutex_unlock(&admin->subscriptionsLock); return status; }
celix_status_t pubsubAdmin_closeAllPublications(pubsub_admin_pt admin, char *scope, char* topic){ celix_status_t status = CELIX_SUCCESS; printf("PSA_ZMQ: Closing all publications\n"); celixThreadMutex_lock(&admin->localPublicationsLock); char *scope_topic = createScopeTopicKey(scope, topic); hash_map_entry_pt pubsvc_entry = (hash_map_entry_pt)hashMap_getEntry(admin->localPublications,scope_topic); if(pubsvc_entry!=NULL){ char* key = (char*)hashMapEntry_getKey(pubsvc_entry); service_factory_pt factory= (service_factory_pt)hashMapEntry_getValue(pubsvc_entry); topic_publication_pt pub = (topic_publication_pt)factory->handle; status += pubsub_topicPublicationStop(pub); disconnectTopicPubSubFromSerializer(admin, pub, true); status += pubsub_topicPublicationDestroy(pub); hashMap_remove(admin->localPublications,scope_topic); free(key); free(factory); } free(scope_topic); celixThreadMutex_unlock(&admin->localPublicationsLock); return status; }
static celix_status_t etcdWatcher_removeEntry(etcd_watcher_pt watcher, char* key, char* value) { celix_status_t status = CELIX_BUNDLE_EXCEPTION; endpoint_discovery_poller_pt poller = watcher->discovery->poller; hash_map_entry_pt entry = hashMap_getEntry(watcher->entries, key); if (entry != NULL) { void* origKey = hashMapEntry_getKey(entry); void* value = hashMap_remove(watcher->entries, key); free(origKey); // check if there is another entry with the same value hash_map_iterator_pt iter = hashMapIterator_create(watcher->entries); unsigned int valueFound = 0; while (hashMapIterator_hasNext(iter) && valueFound <= 1) { if (strcmp(value, hashMapIterator_nextValue(iter)) == 0) valueFound++; } hashMapIterator_destroy(iter); if (valueFound == 0) status = endpointDiscoveryPoller_removeDiscoveryEndpoint(poller, value); free(value); } return status; }
celix_status_t pubsub_topicSubscriptionDisconnectPublisher(topic_subscription_pt ts, char* pubURL){ printf("pubsub_topicSubscriptionDisconnectPublisher : pubURL = %s\n", pubURL); celix_status_t status = CELIX_SUCCESS; struct epoll_event ev; memset(&ev, 0, sizeof(ev)); celixThreadMutex_lock(&ts->socketMap_lock); if (hashMap_containsKey(ts->socketMap, pubURL)){ #if defined(__APPLE__) && defined(__MACH__) //TODO: Use kqueue for OSX #else int *s = hashMap_remove(ts->socketMap, pubURL); if(epoll_ctl(ts->topicEpollFd, EPOLL_CTL_DEL, *s, &ev) == -1) { printf("in if error()\n"); perror("epoll_ctl() EPOLL_CTL_DEL"); status = CELIX_SERVICE_EXCEPTION; } free(s); #endif } celixThreadMutex_unlock(&ts->socketMap_lock); return status; }
celix_status_t serviceRegistry_ungetServiceReference(service_registry_pt registry, bundle_pt owner, service_reference_pt reference) { celix_status_t status = CELIX_SUCCESS; bool valid = false; serviceRefernce_isValid(reference, &valid); if (valid) { bool ungetResult = true; while (ungetResult) { serviceRegistry_ungetService(registry, owner, reference, &ungetResult); } } celixThreadMutex_lock(®istry->referencesMapMutex); array_list_pt references = hashMap_get(registry->serviceReferences, owner); if (references != NULL) { arrayList_removeElement(references, reference); serviceReference_destroy(&reference); if (arrayList_size(references) > 0) { hashMap_put(registry->serviceReferences, owner, references); } else { array_list_pt removed = hashMap_remove(registry->serviceReferences, owner); arrayList_destroy(removed); } } celixThreadMutex_unlock(®istry->referencesMapMutex); return status; }
/** * Removes an endpoint URL from the list of polled endpoints. */ celix_status_t endpointDiscoveryPoller_removeDiscoveryEndpoint(endpoint_discovery_poller_pt poller, char *url) { celix_status_t status = CELIX_SUCCESS; if (celixThreadMutex_lock(&poller->pollerLock) != CELIX_SUCCESS) { status = CELIX_BUNDLE_EXCEPTION; } else { hash_map_entry_pt entry = hashMap_getEntry(poller->entries, url); if (entry == NULL) { logHelper_log(*poller->loghelper, OSGI_LOGSERVICE_DEBUG, "ENDPOINT_POLLER: There was no entry found belonging to url %s - maybe already removed?", url); } else { char* origKey = hashMapEntry_getKey(entry); logHelper_log(*poller->loghelper, OSGI_LOGSERVICE_DEBUG, "ENDPOINT_POLLER: remove discovery endpoint with url %s", url); array_list_pt entries = hashMap_remove(poller->entries, url); for (unsigned int i = arrayList_size(entries); i > 0; i--) { endpoint_description_pt endpoint = arrayList_get(entries, i - 1); discovery_removeDiscoveredEndpoint(poller->discovery, endpoint); arrayList_remove(entries, i - 1); endpointDescription_destroy(endpoint); } if (entries != NULL) { arrayList_destroy(entries); } free(origKey); } status = celixThreadMutex_unlock(&poller->pollerLock); } return status; }
static celix_status_t remoteProxyFactory_unregisterProxyService(remote_proxy_factory_pt remote_proxy_factory_ptr, endpoint_description_pt endpointDescription) { celix_status_t status = CELIX_SUCCESS; proxy_instance_pt proxy_instance_ptr = NULL; if (!remote_proxy_factory_ptr || !endpointDescription || !remote_proxy_factory_ptr->proxy_instances || !remote_proxy_factory_ptr->handle) { status = CELIX_ILLEGAL_ARGUMENT; } if (status == CELIX_SUCCESS) { proxy_instance_ptr = hashMap_remove(remote_proxy_factory_ptr->proxy_instances, endpointDescription); if (proxy_instance_ptr == NULL) { status = CELIX_BUNDLE_EXCEPTION; } } if (status == CELIX_SUCCESS) { if (proxy_instance_ptr->registration_ptr) { status = serviceRegistration_unregister(proxy_instance_ptr->registration_ptr); proxy_instance_ptr->properties = NULL; } if (proxy_instance_ptr->service) { status = remote_proxy_factory_ptr->destroy_proxy_service_ptr(remote_proxy_factory_ptr->handle, proxy_instance_ptr->service); } if (proxy_instance_ptr->properties) { properties_destroy(proxy_instance_ptr->properties); } if (proxy_instance_ptr) { free(proxy_instance_ptr); } } return status; }
celix_status_t wiringAdmin_removeExportedWiringEndpoint(wiring_admin_pt admin, wiring_endpoint_description_pt wEndpointDescription) { celix_status_t status = CELIX_SUCCESS; if (wEndpointDescription == NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { celixThreadMutex_lock(&admin->exportedWiringEndpointLock); service_tracker_pt wiringReceiveTracker = NULL; wiringReceiveTracker = hashMap_remove(admin->wiringReceiveTracker, wEndpointDescription); if (wiringReceiveTracker != NULL) { if (serviceTracker_close(wiringReceiveTracker) == CELIX_SUCCESS) { serviceTracker_destroy(wiringReceiveTracker); } if (hashMap_size(admin->wiringReceiveTracker) == 0) { wiringAdmin_stopWebserver(admin); } } wiringEndpointDescription_destroy(&wEndpointDescription); celixThreadMutex_unlock(&admin->exportedWiringEndpointLock); } return status; }
celix_status_t pubsub_discovery_uninterestedInTopic(void *handle, const char* scope, const char* topic) { pubsub_discovery_pt pubsub_discovery = (pubsub_discovery_pt) handle; char *scope_topic_key = createScopeTopicKey(scope, topic); celixThreadMutex_lock(&pubsub_discovery->watchersMutex); hash_map_entry_pt entry = hashMap_getEntry(pubsub_discovery->watchers, scope_topic_key); if(entry) { struct watcher_info * wi = hashMapEntry_getValue(entry); wi->nr_references--; if(wi->nr_references == 0) { char *key = hashMapEntry_getKey(entry); hashMap_remove(pubsub_discovery->watchers, scope_topic_key); free(key); free(scope_topic_key); etcdWatcher_stop(wi->watcher); etcdWatcher_destroy(wi->watcher); free(wi); } } else { fprintf(stderr, "[DISC] Inconsistency error: Removing unknown topic %s\n", topic); } celixThreadMutex_unlock(&pubsub_discovery->watchersMutex); return CELIX_SUCCESS; }
celix_status_t deviceManager_driverRemoved(void * handle, service_reference_pt ref, void * service) { celix_status_t status = CELIX_SUCCESS; device_manager_pt manager = handle; logHelper_log(manager->loghelper, OSGI_LOGSERVICE_DEBUG, "DEVICE_MANAGER: Remove driver"); hashMap_remove(manager->drivers, ref); array_list_pt idleDevices = NULL; status = deviceManager_getIdleDevices(manager, &idleDevices); if (status == CELIX_SUCCESS) { int i; for (i = 0; i < arrayList_size(idleDevices); i++) { celix_status_t forStatus = CELIX_SUCCESS; service_reference_pt ref = arrayList_get(idleDevices, i); const char *bsn = NULL; bundle_pt bundle = NULL; forStatus = serviceReference_getBundle(ref, &bundle); if (forStatus == CELIX_SUCCESS) { module_pt module = NULL; forStatus = bundle_getCurrentModule(bundle, &module); if (forStatus == CELIX_SUCCESS) { forStatus = module_getSymbolicName(module, &bsn); if (forStatus == CELIX_SUCCESS) { logHelper_log(manager->loghelper, OSGI_LOGSERVICE_DEBUG, "DEVICE_MANAGER: IDLE: %s", bsn); // #TODO attachDriver (idle device) // #TODO this can result in a loop? // Locate and install a driver // Let the match fail, the device is idle // The driver is removed, idle check is performed // Attach is tried again // .. loop .. void *device = hashMap_get(manager->devices, ref); forStatus = deviceManager_attachAlgorithm(manager, ref, device); } } } if (forStatus != CELIX_SUCCESS) { break; //Got error, stop loop and return status } } hash_map_iterator_pt iter = hashMapIterator_create(manager->drivers); while (hashMapIterator_hasNext(iter)) { hashMapIterator_nextValue(iter); // driver_attributes_pt da = hashMapIterator_nextValue(iter); // driverAttributes_tryUninstall(da); } hashMapIterator_destroy(iter); } if (idleDevices != NULL) { arrayList_destroy(idleDevices); } return status; }
// 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; }
celix_status_t wiringAdmin_removeImportedWiringEndpoint(wiring_admin_pt admin, wiring_endpoint_description_pt wEndpointDescription) { celix_status_t status; celixThreadMutex_lock(&admin->importedWiringEndpointLock); char* wireId = properties_get(wEndpointDescription->properties, WIRING_ENDPOINT_DESCRIPTION_WIRE_ID_KEY); printf("%s: remove Wiring Endpoint w/ wireId %s\n", TAG, wireId); wiring_send_service_pt wiringSendService = hashMap_remove(admin->wiringSendServices, wEndpointDescription); service_registration_pt wiringSendRegistration = hashMap_remove(admin->wiringSendRegistrations, wEndpointDescription); status = serviceRegistration_unregister(wiringSendRegistration); if (status == CELIX_SUCCESS) { free(wiringSendService); } celixThreadMutex_unlock(&admin->importedWiringEndpointLock); return status; }
celix_status_t shell_removeCommand(shell_pt shell_ptr, service_reference_pt reference_ptr) { celix_status_t status = CELIX_SUCCESS; command_service_pt command_ptr = NULL; char *name_str = NULL; if (!shell_ptr || !reference_ptr) { status = CELIX_ILLEGAL_ARGUMENT; } if (status == CELIX_SUCCESS) { command_ptr = hashMap_remove(shell_ptr->command_reference_map_ptr, reference_ptr); if (!command_ptr) { status = CELIX_ILLEGAL_ARGUMENT; } } if (status == CELIX_SUCCESS) { status = serviceReference_getProperty(reference_ptr, "command.name", &name_str); if (!name_str) { status = CELIX_BUNDLE_EXCEPTION; } } if (status == CELIX_SUCCESS) { hashMap_remove(shell_ptr->command_name_map_ptr, name_str); } celix_status_t sub_status = bundleContext_ungetService(shell_ptr->bundle_context_ptr, reference_ptr, NULL); if (sub_status != CELIX_SUCCESS && status == CELIX_SUCCESS) { status = sub_status; } sub_status = bundleContext_ungetServiceReference(shell_ptr->bundle_context_ptr, reference_ptr); if (sub_status != CELIX_SUCCESS && status == CELIX_SUCCESS) { status = sub_status; } return status; }
celix_status_t pubsub_discovery_tmPublisherAnnounceRemoved(void * handle, service_reference_pt reference, void * service) { celix_status_t status = CELIX_SUCCESS; pubsub_discovery_pt pubsub_discovery = handle; celixThreadMutex_lock(&pubsub_discovery->listenerReferencesMutex); if (pubsub_discovery->listenerReferences != NULL) { if (hashMap_remove(pubsub_discovery->listenerReferences, reference)) { printf("PSD: pubsub_tm_announce_publisher removed.\n"); } } celixThreadMutex_unlock(&pubsub_discovery->listenerReferencesMutex); return status; }
celix_status_t wiringTopologyManager_wiringEndpointListenerRemoved(void * handle, service_reference_pt reference, void * service) { celix_status_t status; wiring_topology_manager_pt manager = handle; status = celixThreadMutex_lock(&manager->listenerListLock); if (status == CELIX_SUCCESS) { if (hashMap_remove(manager->listenerList, reference)) { printf("WTM: EndpointListener Removed"); } status = celixThreadMutex_unlock(&manager->listenerListLock); } return status; }
void test_hashMap_isEmpty(void) { char * key = "key"; char * value = "value"; hashMap_clear(map, false, false); CU_ASSERT_EQUAL(map->size, 0); CU_ASSERT_TRUE(hashMap_isEmpty(map)); // Add one entry hashMap_put(map, key, value); CU_ASSERT_EQUAL(map->size, 1); CU_ASSERT_FALSE(hashMap_isEmpty(map)); // Remove entry hashMap_remove(map, key); CU_ASSERT_EQUAL(map->size, 0); CU_ASSERT_TRUE(hashMap_isEmpty(map)); }
static celix_status_t topicsub_subscriberUntracked(void * handle, service_reference_pt reference, void * service){ celix_status_t status = CELIX_SUCCESS; topic_subscription_pt ts = handle; celixThreadMutex_lock(&ts->ts_lock); if (hashMap_containsKey(ts->servicesMap, service)) { hash_map_pt msgTypes = hashMap_remove(ts->servicesMap, service); if(msgTypes!=NULL && ts->serializer!=NULL){ ts->serializer->destroySerializerMap(ts->serializer->handle,msgTypes); printf("PSA_ZMQ_TS: Subscriber unregistered.\n"); } else{ printf("PSA_ZMQ_TS: Cannot unregister subscriber.\n"); status = CELIX_SERVICE_EXCEPTION; } } celixThreadMutex_unlock(&ts->ts_lock); printf("PSA_UDP_MC_TS: Subscriber unregistered.\n"); return status; }
celix_status_t statistic_tracker_statServiceRemoved(void *handle, service_reference_pt reference, void *service) { celix_status_t status = CELIX_BUNDLE_EXCEPTION; statistic_tracker_pt statTracker = (statistic_tracker_pt) handle; pthread_t* thread_pt = NULL; pthread_rwlock_wrlock(&statTracker->statLock); hash_map_iterator_pt iter = hashMapIterator_create(statTracker->statServices); while (hashMapIterator_hasNext(iter) && thread_pt == NULL) { hash_map_entry_pt entry = hashMapIterator_nextEntry(iter); if (service == hashMapEntry_getValue(entry)) { struct stats_provider_service* statService = (struct stats_provider_service*) service; char* name = NULL; statService->getName(statService->statsProvider, &name); thread_pt = hashMapEntry_getKey(entry); msg(1, "STAT_TRACKER: Service %s Removed. ", name); hashMap_remove(statTracker->statServices, thread_pt); } } hashMapIterator_destroy(iter); pthread_rwlock_unlock(&statTracker->statLock); if (thread_pt != NULL) { pthread_join(*thread_pt, NULL); msg(1, "STAT_TRACKER: Service Removed. Thread %lu stopped.", (unsigned long) *thread_pt); free(thread_pt); status = CELIX_SUCCESS; } return status; }
celix_status_t producer_queueServiceRemoved(void *handle, service_reference_pt reference, void *service) { celix_status_t status = CELIX_SUCCESS; producer_pt producer = (producer_pt) handle; printf("PRODUCER: QueueService Removed.\n"); pthread_rwlock_wrlock(&producer->queueLock); producer_thread_data_pt th_data = (producer_thread_data_pt) hashMap_get(producer->queueServices, service); th_data->running = false; pthread_join(th_data->thread, NULL); pthread_rwlock_destroy(&th_data->sampleRateLock); hashMap_remove(producer->queueServices, service); free(th_data); pthread_rwlock_unlock(&producer->queueLock); return status; }
static celix_status_t wiringAdmin_wiringReceiveRemoved(void * handle, service_reference_pt reference, void * service) { celix_status_t status = CELIX_SUCCESS; wiring_admin_pt admin = handle; wiring_receive_service_pt wiringReceiveService = (wiring_receive_service_pt) service; array_list_pt wiringReceiveServiceList = hashMap_get(admin->wiringReceiveServices, wiringReceiveService->wireId); if (wiringReceiveServiceList != NULL) { arrayList_removeElement(wiringReceiveServiceList, wiringReceiveService); printf("%s: wiringAdmin_wiringReceiveRemoved, service w/ wireId %s removed!\n", TAG, wiringReceiveService->wireId); if (arrayList_size(wiringReceiveServiceList) == 0) { arrayList_destroy(wiringReceiveServiceList); hashMap_remove(admin->wiringReceiveServices, wiringReceiveService->wireId); } } else { printf("%s: wiringAdmin_wiringReceiveRemoved, service w/ wireId %s not found!\n", TAG, wiringReceiveService->wireId); } return status; }
static celix_status_t serviceRegistry_flushUsageCount(service_registry_pt registry, bundle_pt bundle, service_reference_pt reference) { array_list_pt usages = hashMap_get(registry->inUseMap, bundle); if (usages != NULL) { array_list_iterator_pt iter = arrayListIterator_create(usages); while (arrayListIterator_hasNext(iter)) { usage_count_pt usage = arrayListIterator_next(iter); bool equals = false; serviceReference_equals(usage->reference, reference, &equals); if (equals) { arrayListIterator_remove(iter); free(usage); } } arrayListIterator_destroy(iter); if (arrayList_size(usages) > 0) { hashMap_put(registry->inUseMap, bundle, usages); } else { array_list_pt removed = hashMap_remove(registry->inUseMap, bundle); arrayList_destroy(removed); } } return CELIX_SUCCESS; }
celix_status_t pubsubAdmin_addPublication(pubsub_admin_pt admin, pubsub_endpoint_pt pubEP) { celix_status_t status = CELIX_SUCCESS; printf("PSA_ZMQ: Received publication [FWUUID=%s bundleID=%ld scope=%s, topic=%s]\n", pubEP->frameworkUUID, pubEP->serviceID, pubEP->scope, pubEP->topic); const char* fwUUID = NULL; bundleContext_getProperty(admin->bundle_context, OSGI_FRAMEWORK_FRAMEWORK_UUID, &fwUUID); if (fwUUID == NULL) { printf("PSA_ZMQ: Cannot retrieve fwUUID.\n"); return CELIX_INVALID_BUNDLE_CONTEXT; } char *scope_topic = createScopeTopicKey(pubEP->scope, pubEP->topic); if ((strcmp(pubEP->frameworkUUID, fwUUID) == 0) && (pubEP->endpoint == NULL)) { celixThreadMutex_lock(&admin->localPublicationsLock); service_factory_pt factory = (service_factory_pt) hashMap_get(admin->localPublications, scope_topic); if (factory == NULL) { topic_publication_pt pub = NULL; pubsub_serializer_service_t *best_serializer = NULL; if( (status=pubsubAdmin_getBestSerializer(admin, pubEP, &best_serializer)) == CELIX_SUCCESS){ status = pubsub_topicPublicationCreate(admin->bundle_context, pubEP, best_serializer, admin->ipAddress, admin->basePort, admin->maxPort, &pub); } else{ printf("PSA_ZMQ: Cannot find a serializer for publishing topic %s. Adding it to pending list.\n", pubEP->topic); celixThreadMutex_lock(&admin->noSerializerPendingsLock); arrayList_add(admin->noSerializerPublications,pubEP); celixThreadMutex_unlock(&admin->noSerializerPendingsLock); } if (status == CELIX_SUCCESS) { status = pubsub_topicPublicationStart(admin->bundle_context, pub, &factory); if (status == CELIX_SUCCESS && factory != NULL) { hashMap_put(admin->localPublications, strdup(scope_topic), factory); connectTopicPubSubToSerializer(admin, best_serializer, pub, true); } } else { printf("PSA_ZMQ: Cannot create a topicPublication for scope=%s, topic=%s (bundle %ld).\n", pubEP->scope, pubEP->topic, pubEP->serviceID); } } else { //just add the new EP to the list topic_publication_pt pub = (topic_publication_pt) factory->handle; pubsub_topicPublicationAddPublisherEP(pub, pubEP); } celixThreadMutex_unlock(&admin->localPublicationsLock); } else{ celixThreadMutex_lock(&admin->externalPublicationsLock); array_list_pt ext_pub_list = (array_list_pt) hashMap_get(admin->externalPublications, scope_topic); if (ext_pub_list == NULL) { arrayList_create(&ext_pub_list); hashMap_put(admin->externalPublications, strdup(scope_topic), ext_pub_list); } arrayList_add(ext_pub_list, pubEP); celixThreadMutex_unlock(&admin->externalPublicationsLock); } /* Re-evaluate the pending subscriptions */ celixThreadMutex_lock(&admin->pendingSubscriptionsLock); hash_map_entry_pt pendingSub = hashMap_getEntry(admin->pendingSubscriptions, scope_topic); if (pendingSub != NULL) { //There were pending subscription for the just published topic. Let's connect them. char* topic = (char*) hashMapEntry_getKey(pendingSub); array_list_pt pendingSubList = (array_list_pt) hashMapEntry_getValue(pendingSub); int i; for (i = 0; i < arrayList_size(pendingSubList); i++) { pubsub_endpoint_pt subEP = (pubsub_endpoint_pt) arrayList_get(pendingSubList, i); pubsubAdmin_addSubscription(admin, subEP); } hashMap_remove(admin->pendingSubscriptions, scope_topic); arrayList_clear(pendingSubList); arrayList_destroy(pendingSubList); free(topic); } celixThreadMutex_unlock(&admin->pendingSubscriptionsLock); /* Connect the new publisher to the subscription for his topic, if there is any */ celixThreadMutex_lock(&admin->subscriptionsLock); topic_subscription_pt sub = (topic_subscription_pt) hashMap_get(admin->subscriptions, scope_topic); if (sub != NULL && pubEP->endpoint != NULL) { pubsub_topicSubscriptionAddConnectPublisherToPendingList(sub, pubEP->endpoint); } /* And check also for ANY subscription */ topic_subscription_pt any_sub = (topic_subscription_pt) hashMap_get(admin->subscriptions, PUBSUB_ANY_SUB_TOPIC); if (any_sub != NULL && pubEP->endpoint != NULL) { pubsub_topicSubscriptionAddConnectPublisherToPendingList(any_sub, pubEP->endpoint); } free(scope_topic); celixThreadMutex_unlock(&admin->subscriptionsLock); return status; }
celix_status_t pubsubAdmin_removePublication(pubsub_admin_pt admin,pubsub_endpoint_pt pubEP){ celix_status_t status = CELIX_SUCCESS; int count = 0; printf("PSA_ZMQ: Removing publication [FWUUID=%s bundleID=%ld topic=%s]\n",pubEP->frameworkUUID,pubEP->serviceID,pubEP->topic); const char* fwUUID = NULL; bundleContext_getProperty(admin->bundle_context,OSGI_FRAMEWORK_FRAMEWORK_UUID,&fwUUID); if(fwUUID==NULL){ printf("PSA_ZMQ: Cannot retrieve fwUUID.\n"); return CELIX_INVALID_BUNDLE_CONTEXT; } char *scope_topic = createScopeTopicKey(pubEP->scope, pubEP->topic); if(strcmp(pubEP->frameworkUUID,fwUUID)==0){ celixThreadMutex_lock(&admin->localPublicationsLock); service_factory_pt factory = (service_factory_pt)hashMap_get(admin->localPublications,scope_topic); if(factory!=NULL){ topic_publication_pt pub = (topic_publication_pt)factory->handle; pubsub_topicPublicationRemovePublisherEP(pub,pubEP); } celixThreadMutex_unlock(&admin->localPublicationsLock); if(factory==NULL){ /* Maybe the endpoint was pending */ celixThreadMutex_lock(&admin->noSerializerPendingsLock); if(!arrayList_removeElement(admin->noSerializerPublications, pubEP)){ status = CELIX_ILLEGAL_STATE; } celixThreadMutex_unlock(&admin->noSerializerPendingsLock); } } else{ celixThreadMutex_lock(&admin->externalPublicationsLock); array_list_pt ext_pub_list = (array_list_pt)hashMap_get(admin->externalPublications,scope_topic); if(ext_pub_list!=NULL){ int i; bool found = false; for(i=0;!found && i<arrayList_size(ext_pub_list);i++){ pubsub_endpoint_pt p = (pubsub_endpoint_pt)arrayList_get(ext_pub_list,i); found = pubsubEndpoint_equals(pubEP,p); if (found){ arrayList_remove(ext_pub_list,i); } } // Check if there are more publishers on the same endpoint (happens when 1 celix-instance with multiple bundles publish in same topic) for(i=0; i<arrayList_size(ext_pub_list);i++) { pubsub_endpoint_pt p = (pubsub_endpoint_pt)arrayList_get(ext_pub_list,i); if (strcmp(pubEP->endpoint,p->endpoint) == 0) { count++; } } if(arrayList_size(ext_pub_list)==0){ hash_map_entry_pt entry = hashMap_getEntry(admin->externalPublications,scope_topic); char* topic = (char*)hashMapEntry_getKey(entry); array_list_pt list = (array_list_pt)hashMapEntry_getValue(entry); hashMap_remove(admin->externalPublications,topic); arrayList_destroy(list); free(topic); } } celixThreadMutex_unlock(&admin->externalPublicationsLock); } /* Check if this publisher was connected to one of our subscribers*/ celixThreadMutex_lock(&admin->subscriptionsLock); topic_subscription_pt sub = (topic_subscription_pt)hashMap_get(admin->subscriptions,scope_topic); if(sub!=NULL && pubEP->endpoint!=NULL && count == 0){ pubsub_topicSubscriptionAddDisconnectPublisherToPendingList(sub,pubEP->endpoint); } /* And check also for ANY subscription */ topic_subscription_pt any_sub = (topic_subscription_pt)hashMap_get(admin->subscriptions,PUBSUB_ANY_SUB_TOPIC); if(any_sub!=NULL && pubEP->endpoint!=NULL && count == 0){ pubsub_topicSubscriptionAddDisconnectPublisherToPendingList(any_sub,pubEP->endpoint); } free(scope_topic); celixThreadMutex_unlock(&admin->subscriptionsLock); return status; }
celix_status_t wiringTopologyManager_waRemoved(void * handle, service_reference_pt reference, void * service) { celix_status_t status = CELIX_SUCCESS; wiring_topology_manager_pt manager = handle; wiring_admin_service_pt wiringAdminService = (wiring_admin_service_pt) service; /* check whether one of the exported Wires can be exported here via the newly available wiringAdmin*/ celixThreadMutex_lock(&manager->exportedWiringEndpointsLock); hash_map_iterator_pt iter = hashMapIterator_create(manager->exportedWiringEndpoints); while (hashMapIterator_hasNext(iter)) { hash_map_entry_pt entry = hashMapIterator_nextEntry(iter); hash_map_pt wiringAdminMap = hashMapEntry_getValue(entry); if (hashMap_containsKey(wiringAdminMap, wiringAdminService)) { wiring_endpoint_description_pt wEndpoint = (wiring_endpoint_description_pt) hashMap_remove(wiringAdminMap, wiringAdminService); status = wiringTopologyManager_notifyListenersWiringEndpointRemoved(manager, wEndpoint); if (status == CELIX_SUCCESS) { status = wiringAdminService->removeExportedWiringEndpoint(wiringAdminService->admin, wEndpoint); } else { printf("WTM: failed while removing WiringAdmin.\n"); } } } hashMapIterator_destroy(iter); celixThreadMutex_unlock(&manager->exportedWiringEndpointsLock); /* Check if the added WA can match one of the imported WiringEndpoints */ celixThreadMutex_lock(&manager->importedWiringEndpointsLock); iter = hashMapIterator_create(manager->importedWiringEndpoints); while (hashMapIterator_hasNext(iter)) { hash_map_entry_pt entry = hashMapIterator_nextEntry(iter); wiring_endpoint_description_pt importedWiringEndpointDesc = hashMapEntry_getKey(entry); array_list_pt wiringAdminList = hashMapEntry_getValue(entry); if (arrayList_contains(wiringAdminList, wiringAdminService)) { status = wiringAdminService->removeImportedWiringEndpoint(wiringAdminService->admin, importedWiringEndpointDesc); arrayList_removeElement(wiringAdminList, wiringAdminService); } if (status == CELIX_SUCCESS) { arrayList_add(wiringAdminList, wiringAdminService); } } hashMapIterator_destroy(iter); celixThreadMutex_unlock(&manager->importedWiringEndpointsLock); celixThreadMutex_lock(&manager->waListLock); arrayList_removeElement(manager->waList, wiringAdminService); celixThreadMutex_unlock(&manager->waListLock); printf("WTM: Removed WA\n"); return status; }
celix_status_t deviceManager_deviceRemoved(void * handle, service_reference_pt ref, void * service) { printf("DEVICE_MANAGER: Remove device\n"); device_manager_pt manager = handle; hashMap_remove(manager->devices, ref); return CELIX_SUCCESS; }
celix_status_t deviceManager_deviceRemoved(void * handle, service_reference_pt ref, void * service) { device_manager_pt manager = handle; logHelper_log(manager->loghelper, OSGI_LOGSERVICE_DEBUG, "DEVICE_MANAGER: Remove device"); hashMap_remove(manager->devices, ref); return CELIX_SUCCESS; }
celix_status_t pubsubAdmin_serializerRemoved(void * handle, service_reference_pt reference, void * service){ pubsub_admin_pt admin = (pubsub_admin_pt)handle; int i=0, j=0; const char *serType = NULL; serviceReference_getProperty(reference, PUBSUB_SERIALIZER_TYPE_KEY,&serType); if(serType == NULL){ printf("Serializer serviceReference %p has no pubsub_serializer.type property specified\n",reference); return CELIX_SERVICE_EXCEPTION; } celixThreadMutex_lock(&admin->serializerListLock); /* Remove the serializer from the list */ arrayList_removeElement(admin->serializerList, reference); celixThreadMutex_unlock(&admin->serializerListLock); celixThreadMutex_lock(&admin->usedSerializersLock); array_list_pt topicPubList = (array_list_pt)hashMap_remove(admin->topicPublicationsPerSerializer, service); array_list_pt topicSubList = (array_list_pt)hashMap_remove(admin->topicSubscriptionsPerSerializer, service); celixThreadMutex_unlock(&admin->usedSerializersLock); /* Now destroy the topicPublications, but first put back the pubsub_endpoints back to the noSerializer pending list */ if(topicPubList!=NULL){ for(i=0;i<arrayList_size(topicPubList);i++){ topic_publication_pt topicPub = (topic_publication_pt)arrayList_get(topicPubList,i); /* Stop the topic publication */ pubsub_topicPublicationStop(topicPub); /* Get the endpoints that are going to be orphan */ array_list_pt pubList = pubsub_topicPublicationGetPublisherList(topicPub); for(j=0;j<arrayList_size(pubList);j++){ pubsub_endpoint_pt pubEP = (pubsub_endpoint_pt)arrayList_get(pubList,j); /* Remove the publication */ pubsubAdmin_removePublication(admin, pubEP); /* Reset the endpoint field, so that will be recreated from scratch when a new serializer will be found */ if(pubEP->endpoint!=NULL){ free(pubEP->endpoint); pubEP->endpoint = NULL; } /* Add the orphan endpoint to the noSerializer pending list */ celixThreadMutex_lock(&admin->noSerializerPendingsLock); arrayList_add(admin->noSerializerPublications,pubEP); celixThreadMutex_unlock(&admin->noSerializerPendingsLock); } arrayList_destroy(pubList); /* Cleanup also the localPublications hashmap*/ celixThreadMutex_lock(&admin->localPublicationsLock); hash_map_iterator_pt iter = hashMapIterator_create(admin->localPublications); char *key = NULL; service_factory_pt factory = NULL; while(hashMapIterator_hasNext(iter)){ hash_map_entry_pt entry = hashMapIterator_nextEntry(iter); factory = (service_factory_pt)hashMapEntry_getValue(entry); topic_publication_pt pub = (topic_publication_pt)factory->handle; if(pub==topicPub){ key = (char*)hashMapEntry_getKey(entry); break; } } hashMapIterator_destroy(iter); if(key!=NULL){ hashMap_remove(admin->localPublications, key); free(factory); free(key); } celixThreadMutex_unlock(&admin->localPublicationsLock); /* Finally destroy the topicPublication */ pubsub_topicPublicationDestroy(topicPub); } arrayList_destroy(topicPubList); } /* Now destroy the topicSubscriptions, but first put back the pubsub_endpoints back to the noSerializer pending list */ if(topicSubList!=NULL){ for(i=0;i<arrayList_size(topicSubList);i++){ topic_subscription_pt topicSub = (topic_subscription_pt)arrayList_get(topicSubList,i); /* Stop the topic subscription */ pubsub_topicSubscriptionStop(topicSub); /* Get the endpoints that are going to be orphan */ array_list_pt subList = pubsub_topicSubscriptionGetSubscribersList(topicSub); for(j=0;j<arrayList_size(subList);j++){ pubsub_endpoint_pt subEP = (pubsub_endpoint_pt)arrayList_get(subList,j); /* Remove the subscription */ pubsubAdmin_removeSubscription(admin, subEP); /* Reset the endpoint field, so that will be recreated from scratch when a new serializer will be found */ if(subEP->endpoint!=NULL){ free(subEP->endpoint); subEP->endpoint = NULL; } /* Add the orphan endpoint to the noSerializer pending list */ celixThreadMutex_lock(&admin->noSerializerPendingsLock); arrayList_add(admin->noSerializerSubscriptions,subEP); celixThreadMutex_unlock(&admin->noSerializerPendingsLock); } /* Cleanup also the subscriptions hashmap*/ celixThreadMutex_lock(&admin->subscriptionsLock); hash_map_iterator_pt iter = hashMapIterator_create(admin->subscriptions); char *key = NULL; while(hashMapIterator_hasNext(iter)){ hash_map_entry_pt entry = hashMapIterator_nextEntry(iter); topic_subscription_pt sub = (topic_subscription_pt)hashMapEntry_getValue(entry); if(sub==topicSub){ key = (char*)hashMapEntry_getKey(entry); break; } } hashMapIterator_destroy(iter); if(key!=NULL){ hashMap_remove(admin->subscriptions, key); free(key); } celixThreadMutex_unlock(&admin->subscriptionsLock); /* Finally destroy the topicSubscription */ pubsub_topicSubscriptionDestroy(topicSub); } arrayList_destroy(topicSubList); } printf("PSA_ZMQ: %s serializer removed\n",serType); return CELIX_SUCCESS; }