celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) { celix_status_t status = CELIX_SUCCESS; struct activator *activator = userData; if (serviceTracker_close(activator->remoteServiceAdminTracker) == CELIX_SUCCESS) { serviceTracker_destroy(activator->remoteServiceAdminTracker); } if (serviceTracker_close(activator->endpointListenerTracker) == CELIX_SUCCESS) { serviceTracker_destroy(activator->endpointListenerTracker); } bundleContext_removeServiceListener(context, activator->serviceListener); free(activator->serviceListener); serviceRegistration_unregister(activator->hook); free(activator->hookService); serviceRegistration_unregister(activator->endpointListenerService); free(activator->endpointListener); serviceRegistration_unregister(activator->scopeReg); topologyManager_closeImports(activator->manager); return status; }
celix_status_t bundleActivator_create(bundle_context_pt context, void **out) { celix_status_t status = CELIX_SUCCESS; struct activator *act = calloc(1, sizeof(*act)); if (act != NULL) { act->context = context; act->serv.handle = act; act->serv.test = test; status = serviceTrackerCustomizer_create(act, NULL, addCalc, NULL, removeCalc, &act->cust); status = CELIX_DO_IF(status, serviceTracker_create(context, CALCULATOR2_SERVICE, act->cust, &act->tracker)); } else { status = CELIX_ENOMEM; } if (status == CELIX_SUCCESS) { *out = act; } else if (act != NULL) { if (act->cust != NULL) { free(act->cust); act->cust = NULL; } if (act->tracker != NULL) { serviceTracker_destroy(act->tracker); act->tracker = NULL; } free(act); } return CELIX_SUCCESS; }
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 serviceDependency_stop(dm_service_dependency_pt dependency) { celix_status_t status = CELIX_SUCCESS; celix_status_t tmp_status; if (!dependency) { status = CELIX_ILLEGAL_ARGUMENT; } if (status == CELIX_SUCCESS) { if (dependency->tracker) { tmp_status = serviceTracker_close(dependency->tracker); if (tmp_status != CELIX_SUCCESS) { status = tmp_status; } tmp_status = serviceTracker_destroy(dependency->tracker); if (tmp_status != CELIX_SUCCESS && status == CELIX_SUCCESS) { status = tmp_status; } } } if (status == CELIX_SUCCESS) { dependency->isStarted = false; } return status; }
celix_status_t wiringAdmin_stop(wiring_admin_pt admin) { celix_status_t status = CELIX_SUCCESS; celixThreadMutex_lock(&admin->exportedWiringEndpointLock); // stop tracker hash_map_iterator_pt iter = hashMapIterator_create(admin->wiringReceiveTracker); while (hashMapIterator_hasNext(iter)) { service_tracker_pt wiringReceiveTracker = (service_tracker_pt) hashMapIterator_nextValue(iter); if (serviceTracker_close(wiringReceiveTracker) == CELIX_SUCCESS) { serviceTracker_destroy(wiringReceiveTracker); } } hashMapIterator_destroy(iter); hashMap_clear(admin->wiringReceiveTracker, false, false); wiringAdmin_stopWebserver(admin); iter = hashMapIterator_create(admin->wiringReceiveServices); while (hashMapIterator_hasNext(iter)) { array_list_pt wiringReceiveServiceList = hashMapIterator_nextValue(iter); arrayList_destroy(wiringReceiveServiceList); } hashMapIterator_destroy(iter); hashMap_clear(admin->wiringReceiveServices, false, false); celixThreadMutex_unlock(&admin->exportedWiringEndpointLock); return status; }
celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) { struct activator *act = userData; if (act != NULL) { if (act->tracker != NULL) { serviceTracker_destroy(act->tracker); act->tracker = NULL; } free(act); } return CELIX_SUCCESS; }
celix_status_t wiringAdmin_exportWiringEndpoint(wiring_admin_pt admin, wiring_endpoint_description_pt* wEndpointDescription) { celix_status_t status = CELIX_SUCCESS; celixThreadMutex_lock(&admin->exportedWiringEndpointLock); if (hashMap_size(admin->wiringReceiveTracker) == 0) { status = wiringAdmin_startWebserver(admin->context, &admin); } if (status == CELIX_SUCCESS) { char* fwuuid = NULL; status = bundleContext_getProperty(admin->context, OSGI_FRAMEWORK_FRAMEWORK_UUID, &fwuuid); if (status == CELIX_SUCCESS) { char* wireId = NULL; properties_pt props = properties_create(); printf("%s: HTTP Wiring Endpoint running at %s\n", TAG, admin->url); status = wiringEndpointDescription_create(NULL, props, wEndpointDescription); properties_set(props, WIRING_ADMIN_PROPERTIES_CONFIG_KEY, WIRING_ADMIN_PROPERTIES_CONFIG_VALUE); properties_set(props, WIRING_ENDPOINT_DESCRIPTION_HTTP_URL_KEY, admin->url); properties_set(props, (char*) OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, fwuuid); wireId = properties_get(props, WIRING_ENDPOINT_DESCRIPTION_WIRE_ID_KEY); printf("%s: wiringEndpointDescription_create w/ wireId %s started\n", TAG, wireId); if (status == CELIX_SUCCESS) { service_tracker_pt tracker = NULL; status = wiringAdmin_createWiringReceiveTracker(admin, &tracker, wireId); if (status == CELIX_SUCCESS) { status = serviceTracker_open(tracker); if (status == CELIX_SUCCESS) { hashMap_put(admin->wiringReceiveTracker, *wEndpointDescription, tracker); printf("%s: WiringReceiveTracker w/ wireId %s started\n", TAG, wireId); } else { serviceTracker_destroy(tracker); } } } } } else { printf("%s: Cannot export Wiring Endpoint\n", TAG); } celixThreadMutex_unlock(&admin->exportedWiringEndpointLock); return status; }
celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) { celix_status_t status = CELIX_SUCCESS; struct activator *activator = userData; serviceTracker_destroy(activator->serializerTracker); pubsubAdmin_destroy(activator->admin); activator->admin = NULL; free(activator); return status; }
celix_status_t managedServiceTracker_destroy(bundle_context_pt context, managed_service_tracker_pt mgServTr, service_tracker_pt tracker) { updatedThreadPool_destroy(mgServTr->updatedThreadPool); celixThreadMutex_destroy(&mgServTr->managedServicesReferencesMutex); serviceTracker_destroy(tracker); hashMap_destroy(mgServTr->managedServices, true, true); hashMap_destroy(mgServTr->managedServicesReferences, true, true); free(mgServTr); return CELIX_SUCCESS; }
celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) { celix_status_t status = CELIX_SUCCESS; bundle_activator_pt activator = userData; printf("PROCESSOR: Stopping bundle...\n"); serviceTracker_close(activator->queueTracker); serviceTracker_close(activator->dataStoreTracker); serviceTracker_destroy(activator->queueTracker); serviceTracker_destroy(activator->dataStoreTracker); serviceRegistration_unregister(activator->processorStatsRegistration); processor_stop(activator->processor); free(activator->processorStatsService); processor_destroy(activator->processor); return status; }
celix_status_t importRegistrationFactory_destroy(import_registration_factory_pt* registration_factory) { celix_status_t status = CELIX_SUCCESS; if (*registration_factory != NULL) { free((*registration_factory)->serviceName); arrayList_destroy((*registration_factory)->registrations); serviceTracker_destroy((*registration_factory)->proxyFactoryTracker); free(*registration_factory); *registration_factory = NULL; } return status; }
celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) { celix_status_t status = CELIX_SUCCESS; bundle_activator_pt activator = (bundle_activator_pt) userData; printf("PRODUCER: Stopping bundle...\n"); serviceTracker_close(activator->tracker); serviceTracker_destroy(activator->tracker); serviceRegistration_unregister(activator->producerStatsRegistration); serviceRegistration_unregister(activator->producerRegistration); producer_stop(activator->producer); return status; }
celix_status_t bundleActivator_destroy(void * userData, bundle_context_pt context) { celix_status_t status = CELIX_SUCCESS; struct activator *activator = userData; status = serviceTracker_destroy(activator->endpointListenerTracker); // status = serviceRegistration_destroy(activator->endpointListenerService); status = discovery_destroy(activator->discovery); activator->endpointListenerTracker = NULL; activator->endpointListenerService = NULL; activator->discovery = NULL; activator->context = NULL; free(activator); return status; }
celix_status_t pubsub_topicSubscriptionDestroy(topic_subscription_pt ts){ celix_status_t status = CELIX_SUCCESS; celixThreadMutex_lock(&ts->ts_lock); ts->running = false; free(ts->ifIpAddress); serviceTracker_destroy(ts->tracker); arrayList_clear(ts->sub_ep_list); arrayList_destroy(ts->sub_ep_list); hashMap_destroy(ts->servicesMap,false,false); celixThreadMutex_lock(&ts->socketMap_lock); hashMap_destroy(ts->socketMap,true,true); celixThreadMutex_unlock(&ts->socketMap_lock); celixThreadMutex_destroy(&ts->socketMap_lock); celixThreadMutex_lock(&ts->pendingConnections_lock); arrayList_destroy(ts->pendingConnections); celixThreadMutex_unlock(&ts->pendingConnections_lock); celixThreadMutex_destroy(&ts->pendingConnections_lock); celixThreadMutex_lock(&ts->pendingDisconnections_lock); arrayList_destroy(ts->pendingDisconnections); celixThreadMutex_unlock(&ts->pendingDisconnections_lock); celixThreadMutex_destroy(&ts->pendingDisconnections_lock); largeUdp_destroy(ts->largeUdpHandle); #if defined(__APPLE__) && defined(__MACH__) //TODO: Use kqueue for OSX #else close(ts->topicEpollFd); #endif celixThreadMutex_unlock(&ts->ts_lock); celixThreadMutex_destroy(&ts->ts_lock); free(ts); return status; }