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 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_stop(void * userData, bundle_context_pt context) {
celix_status_t status = CELIX_SUCCESS;
struct activator * act = userData;
status = serviceRegistration_unregister(act->reg);
status = CELIX_DO_IF(status, serviceTracker_close(act->tracker));
return status;
}
celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context __attribute__((unused))) {
struct activator * activator = userData;
serviceTracker_close(activator->tracker);
serviceRegistration_unregister(activator->reg);
return CELIX_SUCCESS;
}
celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
celix_status_t status = CELIX_SUCCESS;
struct activator * data = userData;
serviceTracker_close(data->tracker);
status = logHelper_stop(data->loghelper);
return status;
}
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 bundleActivator_stop(void * userData, bundle_context_pt context) {
celix_status_t status = CELIX_SUCCESS;
struct activator *activator = userData;
status = serviceTracker_close(activator->endpointListenerTracker);
status = serviceRegistration_unregister(activator->endpointListenerService);
status = discovery_stop(activator->discovery);
return status;
}
celix_status_t bundleActivator_stop(void * userData, bundle_context_pt context) {
celix_status_t status = CELIX_SUCCESS;
struct activator *activator = userData;
status += serviceTracker_close(activator->serializerTracker);
status += serviceRegistration_unregister(activator->registration);
activator->registration = NULL;
free(activator->adminService);
activator->adminService = NULL;
return status;
}
celix_status_t shellMediator_destroy(shell_mediator_pt instance) {
celix_status_t status = CELIX_SUCCESS;
celixThreadMutex_lock(&instance->mutex);
instance->shellService = NULL;
serviceTracker_close(instance->tracker);
celixThreadMutex_unlock(&instance->mutex);
logHelper_stop(instance->loghelper);
status = logHelper_destroy(&instance->loghelper);
return status;
}
celix_status_t importRegistrationFactory_close(import_registration_factory_pt registration_factory)
{
celix_status_t status = CELIX_SUCCESS;
if (registration_factory->proxyFactoryTracker != NULL) {
serviceTracker_close(registration_factory->proxyFactoryTracker);
}
if (registration_factory->bundle != NULL) {
bundle_uninstall(registration_factory->bundle);
}
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 pubsub_topicSubscriptionStop(topic_subscription_pt ts){
celix_status_t status = CELIX_SUCCESS;
struct epoll_event ev;
memset(&ev, 0, sizeof(ev));
ts->running = false;
pthread_kill(ts->recv_thread.thread,SIGUSR1);
celixThread_join(ts->recv_thread,NULL);
status = serviceTracker_close(ts->tracker);
celixThreadMutex_lock(&ts->socketMap_lock);
hash_map_iterator_pt it = hashMapIterator_create(ts->socketMap);
while(hashMapIterator_hasNext(it)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(it);
char *url = hashMapEntry_getKey(entry);
int *s = hashMapEntry_getValue(entry);
memset(&ev, 0, sizeof(ev));
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);
free(url);
//hashMapIterator_remove(it);
}
hashMapIterator_destroy(it);
hashMap_clear(ts->socketMap, false, false);
celixThreadMutex_unlock(&ts->socketMap_lock);
return status;
}
