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;
}
int producer_getUtilizationStatsValue(producer_pt producer, double* statVal) {
double total_average = 0;
pthread_rwlock_rdlock(&producer->queueLock);
hash_map_iterator_pt iter = hashMapIterator_create(producer->queueServices);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
if (entry != NULL) {
producer_thread_data_pt value = (producer_thread_data_pt) hashMapEntry_getValue(entry);
if (value != NULL) {
total_average += (double) (((double) (value->single_throughput + value->burst_throughput)) / ((double) 2.0f));
}
}
}
hashMapIterator_destroy(iter);
if (hashMap_size(producer->queueServices) > 0) {
total_average /= hashMap_size(producer->queueServices);
}
pthread_rwlock_unlock(&producer->queueLock);
(*statVal) = total_average;
return (int) CELIX_SUCCESS;
}
array_list_pt serviceRegistry_getUsingBundles(service_registry_pt registry, service_reference_pt reference) {
array_list_pt bundles = NULL;
hash_map_iterator_pt iter;
arrayList_create(&bundles);
celixThreadMutex_lock(®istry->mutex);
iter = hashMapIterator_create(registry->inUseMap);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
bundle_pt bundle = hashMapEntry_getKey(entry);
array_list_pt usages = hashMapEntry_getValue(entry);
unsigned int i;
for (i = 0; i < arrayList_size(usages); i++) {
usage_count_pt usage = arrayList_get(usages, i);
bool equals = false;
serviceReference_equals(usage->reference, reference, &equals);
if (equals) {
arrayList_add(bundles, bundle);
}
}
}
hashMapIterator_destroy(iter);
celixThreadMutex_unlock(®istry->mutex);
return bundles;
}
static void *endpointDiscoveryPoller_performPeriodicPoll(void *data) {
endpoint_discovery_poller_pt poller = (endpoint_discovery_poller_pt) data;
useconds_t interval = (useconds_t) (poller->poll_interval * 1000000L);
while (poller->running) {
usleep(interval);
celix_status_t status = celixThreadMutex_lock(&poller->pollerLock);
if (status != CELIX_SUCCESS) {
logHelper_log(*poller->loghelper, OSGI_LOGSERVICE_WARNING, "ENDPOINT_POLLER: failed to obtain lock; retrying...");
} else {
hash_map_iterator_pt iterator = hashMapIterator_create(poller->entries);
while (hashMapIterator_hasNext(iterator)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iterator);
char *url = hashMapEntry_getKey(entry);
array_list_pt currentEndpoints = hashMapEntry_getValue(entry);
endpointDiscoveryPoller_poll(poller, url, currentEndpoints);
}
hashMapIterator_destroy(iterator);
}
status = celixThreadMutex_unlock(&poller->pollerLock);
if (status != CELIX_SUCCESS) {
logHelper_log(*poller->loghelper, OSGI_LOGSERVICE_WARNING, "ENDPOINT_POLLER: failed to release lock; retrying...");
}
}
return NULL;
}
/// \TEST_CASE_ID{2}
/// \TEST_CASE_TITLE{Test scope initialisation}
/// \TEST_CASE_REQ{REQ-2}
/// \TEST_CASE_DESC Checks if scopes can be added, but not twice
static void testScope(void) {
int nr_exported;
int nr_imported;
array_list_pt epList;
printf("\nBegin: %s\n", __func__);
scopeInit("scope.json", &nr_exported, &nr_imported);
CHECK_EQUAL(1, nr_exported);
CHECK_EQUAL(0, nr_imported);
discMock->getEPDescriptors(discMock->handle, &epList);
// We export two services: Calculator and Calculator2, but only 1 has DFI bundle info
CHECK_EQUAL(1, arrayList_size(epList));
for (unsigned int i = 0; i < arrayList_size(epList); i++) {
endpoint_description_pt ep = (endpoint_description_pt) arrayList_get(epList, i);
properties_pt props = ep->properties;
hash_map_entry_pt entry = hashMap_getEntry(props, (void*)"key2");
char* value = (char*) hashMapEntry_getValue(entry);
STRCMP_EQUAL("inaetics", value);
/*
printf("Service: %s ", ep->service);
hash_map_iterator_pt iter = hashMapIterator_create(props);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
printf("%s - %s\n", (char*)hashMapEntry_getKey(entry),
(char*)hashMapEntry_getValue(entry));
}
printf("\n");
hashMapIterator_destroy(iter);
*/
}
printf("End: %s\n", __func__);
}
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;
}
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;
}
void properties_destroy(properties_pt properties) {
hash_map_iterator_pt iter = hashMapIterator_create(properties);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
free(hashMapEntry_getKey(entry));
free(hashMapEntry_getValue(entry));
}
hashMapIterator_destroy(iter);
hashMap_destroy(properties, false, false);
}
static void process_msg(topic_subscription_pt sub,pubsub_udp_msg_t *msg){
celixThreadMutex_lock(&sub->ts_lock);
hash_map_iterator_pt iter = hashMapIterator_create(sub->servicesMap);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
pubsub_subscriber_pt subsvc = hashMapEntry_getKey(entry);
hash_map_pt msgTypes = hashMapEntry_getValue(entry);
pubsub_msg_serializer_t *msgSer = hashMap_get(msgTypes,(void*)(uintptr_t )msg->header.type);
if (msgSer == NULL) {
printf("PSA_UDP_MC_TS: Serializer not available for message %d.\n",msg->header.type);
}
else{
void *msgInst = NULL;
bool validVersion = checkVersion(msgSer->msgVersion,&msg->header);
if(validVersion){
celix_status_t status = msgSer->deserialize(msgSer, (const void *) msg->payload, 0, &msgInst);
if (status == CELIX_SUCCESS) {
bool release = true;
pubsub_multipart_callbacks_t mp_callbacks;
mp_callbacks.handle = sub;
mp_callbacks.localMsgTypeIdForMsgType = pubsub_localMsgTypeIdForMsgType;
mp_callbacks.getMultipart = NULL;
subsvc->receive(subsvc->handle, msgSer->msgName, msg->header.type, msgInst, &mp_callbacks, &release);
if(release){
msgSer->freeMsg(msgSer,msgInst);
}
}
else{
printf("PSA_UDP_MC_TS: Cannot deserialize msgType %s.\n",msgSer->msgName);
}
}
else{
int major=0,minor=0;
version_getMajor(msgSer->msgVersion,&major);
version_getMinor(msgSer->msgVersion,&minor);
printf("PSA_UDP_MC_TS: Version mismatch for primary message '%s' (have %d.%d, received %u.%u). NOT sending any part of the whole message.\n",
msgSer->msgName,major,minor,msg->header.major,msg->header.minor);
}
}
}
hashMapIterator_destroy(iter);
celixThreadMutex_unlock(&sub->ts_lock);
}
static void importRegistration_clearProxies(import_registration_pt import) {
if (import != NULL) {
pthread_mutex_lock(&import->proxiesMutex);
if (import->proxies != NULL) {
hash_map_iterator_pt iter = hashMapIterator_create(import->proxies);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
struct service_proxy *proxy = hashMapEntry_getValue(entry);
importRegistration_destroyProxy(proxy);
}
hashMapIterator_destroy(iter);
}
pthread_mutex_unlock(&import->proxiesMutex);
}
}
static celix_status_t remoteProxyFactory_registerProxyService(remote_proxy_factory_pt remote_proxy_factory_ptr, endpoint_description_pt endpointDescription, remote_service_admin_pt rsa, sendToHandle sendToCallback) {
celix_status_t status = CELIX_SUCCESS;
proxy_instance_pt proxy_instance_ptr = NULL;
if (!remote_proxy_factory_ptr || !remote_proxy_factory_ptr->create_proxy_service_ptr) {
status = CELIX_ILLEGAL_ARGUMENT;
}
if (status == CELIX_SUCCESS) {
proxy_instance_ptr = calloc(1, sizeof(*proxy_instance_ptr));
if (!proxy_instance_ptr) {
status = CELIX_ENOMEM;
}
}
if (status == CELIX_SUCCESS) {
proxy_instance_ptr->properties = properties_create();
if (!proxy_instance_ptr->properties) {
status = CELIX_BUNDLE_EXCEPTION;
}
}
if (status == CELIX_SUCCESS) {
status = remote_proxy_factory_ptr->create_proxy_service_ptr(remote_proxy_factory_ptr->handle, endpointDescription, rsa, sendToCallback, proxy_instance_ptr->properties, &proxy_instance_ptr->service);
}
if (status == CELIX_SUCCESS) {
properties_set(proxy_instance_ptr->properties, "proxy.interface", remote_proxy_factory_ptr->service);
hash_map_iterator_pt iter = hashMapIterator_create(endpointDescription->properties);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
char *key = hashMapEntry_getKey(entry);
char *value = hashMapEntry_getValue(entry);
properties_set(proxy_instance_ptr->properties, key, value);
}
}
if (status == CELIX_SUCCESS) {
status = bundleContext_registerService(remote_proxy_factory_ptr->context_ptr, remote_proxy_factory_ptr->service, proxy_instance_ptr->service, proxy_instance_ptr->properties, &proxy_instance_ptr->registration_ptr);
}
if (status == CELIX_SUCCESS) {
hashMap_put(remote_proxy_factory_ptr->proxy_instances, endpointDescription, proxy_instance_ptr);
}
return status;
}
/// \TEST_CASE_ID{4}
/// \TEST_CASE_TITLE{Test scope initialisation}
/// \TEST_CASE_REQ{REQ-4}
/// \TEST_CASE_DESC Checks if scopes can be added, but not twice
static void testScope3(void) {
int nr_exported;
int nr_imported;
array_list_pt epList;
printf("\nBegin: %s\n", __func__);
scopeInit("scope3.json", &nr_exported, &nr_imported);
CHECK_EQUAL(2, nr_exported);
discMock->getEPDescriptors(discMock->handle, &epList);
// We export two services: Calculator and Calculator2, but only 1 has DFI bundle info
CHECK_EQUAL(1, arrayList_size(epList));
for (unsigned int i = 0; i < arrayList_size(epList); i++) {
endpoint_description_pt ep = (endpoint_description_pt) arrayList_get(epList, i);
properties_pt props = ep->properties;
hash_map_entry_pt entry = hashMap_getEntry(props, (void *)"key2");
char* value = (char*) hashMapEntry_getValue(entry);
STRCMP_EQUAL("inaetics", value);
}
printf("End: %s\n", __func__);
}
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 deploymentPackage_processEntries(deployment_package_pt package) {
celix_status_t status = CELIX_SUCCESS;
hash_map_pt entries = NULL;
manifest_getEntries(package->manifest, &entries);
hash_map_iterator_pt iter = hashMapIterator_create(entries);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
char *name = hashMapEntry_getKey(entry);
properties_pt values = hashMapEntry_getValue(entry);
bool isBundleResource;
deploymentPackage_isBundleResource(values, &isBundleResource);
if (isBundleResource) {
bundle_info_pt info = apr_palloc(package->pool, sizeof(*info));
info->path = name;
info->attributes = values;
info->symbolicName = properties_get(values, (char *) OSGI_FRAMEWORK_BUNDLE_SYMBOLICNAME);
char *version = properties_get(values, (char *) OSGI_FRAMEWORK_BUNDLE_VERSION);
info->version = NULL;
status = version_createVersionFromString(version, &info->version);
char *customizer = properties_get(values, (char *) DEPLOYMENTPACKAGE_CUSTOMIZER);
deploymentPackage_parseBooleanHeader(customizer, &info->customizer);
arrayList_add(package->bundleInfos, info);
} else {
resource_info_pt info = apr_palloc(package->pool, sizeof(*info));
info->path = name;
info->attributes = values;
info->resourceProcessor = properties_get(values, (char *) RESOURCE_PROCESSOR);
arrayList_add(package->resourceInfos, info);
}
}
hashMapIterator_destroy(iter);
return status;
}
/**
* Header is ignored for now, cannot handle comments yet
*/
void properties_store(properties_pt properties, char * filename, char * header) {
FILE *file = fopen ( filename, "w+" );
int i;
char *str;
if (file != NULL) {
if (hashMap_size(properties) > 0) {
hash_map_iterator_pt iterator = hashMapIterator_create(properties);
while (hashMapIterator_hasNext(iterator)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iterator);
str = hashMapEntry_getKey(entry);
for (int i = 0; i < strlen(str); i += 1) {
if (str[i] == '#' || str[i] == '!' || str[i] == '=' || str[i] == ':') {
fputc('\\', file);
}
fputc(str[i], file);
}
fputc('=', file);
str = hashMapEntry_getValue(entry);
for (int i = 0; i < strlen(str); i += 1) {
if (str[i] == '#' || str[i] == '!' || str[i] == '=' || str[i] == ':') {
fputc('\\', file);
}
fputc(str[i], file);
}
fputc('\n', file);
}
hashMapIterator_destroy(iterator);
}
fclose(file);
} else {
perror("File is null");
}
}
static celix_status_t endpointDescriptorWriter_writeEndpoint(endpoint_descriptor_writer_pt writer, endpoint_description_pt endpoint) {
celix_status_t status = CELIX_SUCCESS;
if (endpoint == NULL || writer == NULL) {
status = CELIX_ILLEGAL_ARGUMENT;
} else {
xmlTextWriterStartElement(writer->writer, ENDPOINT_DESCRIPTION);
hash_map_iterator_pt iter = hashMapIterator_create(endpoint->properties);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
void* propertyName = hashMapEntry_getKey(entry);
const xmlChar* propertyValue = (const xmlChar*) hashMapEntry_getValue(entry);
xmlTextWriterStartElement(writer->writer, PROPERTY);
xmlTextWriterWriteAttribute(writer->writer, NAME, propertyName);
if (strcmp(OSGI_FRAMEWORK_OBJECTCLASS, (char*) propertyName) == 0) {
// objectClass *must* be represented as array of string values...
endpointDescriptorWriter_writeArrayValue(writer->writer, propertyValue);
} else if (strcmp(OSGI_RSA_ENDPOINT_SERVICE_ID, (char*) propertyName) == 0) {
// endpoint.service.id *must* be represented as long value...
endpointDescriptorWriter_writeTypedValue(writer->writer, VALUE_TYPE_LONG, propertyValue);
} else {
// represent all other values as plain string values...
endpointDescriptorWriter_writeUntypedValue(writer->writer, propertyValue);
}
xmlTextWriterEndElement(writer->writer);
}
hashMapIterator_destroy(iter);
xmlTextWriterEndElement(writer->writer);
}
return status;
}
celix_status_t discovery_stop(discovery_pt discovery) {
celix_status_t status;
status = etcdWatcher_destroy(discovery->watcher);
if (status != CELIX_SUCCESS) {
return CELIX_BUNDLE_EXCEPTION;
}
status = endpointDiscoveryServer_destroy(discovery->server);
if (status != CELIX_SUCCESS) {
return CELIX_BUNDLE_EXCEPTION;
}
status = endpointDiscoveryPoller_destroy(discovery->poller);
if (status != CELIX_SUCCESS) {
return CELIX_BUNDLE_EXCEPTION;
}
hash_map_iterator_pt iter;
celixThreadMutex_lock(&discovery->discoveredServicesMutex);
iter = hashMapIterator_create(discovery->discoveredServices);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
endpoint_description_pt endpoint = hashMapEntry_getValue(entry);
discovery_informEndpointListeners(discovery, endpoint, false);
}
hashMapIterator_destroy(iter);
celixThreadMutex_unlock(&discovery->discoveredServicesMutex);
logHelper_stop(discovery->loghelper);
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;
}
celix_status_t pubsubAdmin_destroy(pubsub_admin_pt admin)
{
celix_status_t status = CELIX_SUCCESS;
free(admin->ipAddress);
celixThreadMutex_lock(&admin->pendingSubscriptionsLock);
hash_map_iterator_pt iter = hashMapIterator_create(admin->pendingSubscriptions);
while(hashMapIterator_hasNext(iter)){
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
free((char*)hashMapEntry_getKey(entry));
arrayList_destroy((array_list_pt)hashMapEntry_getValue(entry));
}
hashMapIterator_destroy(iter);
hashMap_destroy(admin->pendingSubscriptions,false,false);
celixThreadMutex_unlock(&admin->pendingSubscriptionsLock);
celixThreadMutex_lock(&admin->subscriptionsLock);
hashMap_destroy(admin->subscriptions,false,false);
celixThreadMutex_unlock(&admin->subscriptionsLock);
celixThreadMutex_lock(&admin->localPublicationsLock);
hashMap_destroy(admin->localPublications,true,false);
celixThreadMutex_unlock(&admin->localPublicationsLock);
celixThreadMutex_lock(&admin->externalPublicationsLock);
iter = hashMapIterator_create(admin->externalPublications);
while(hashMapIterator_hasNext(iter)){
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
free((char*)hashMapEntry_getKey(entry));
arrayList_destroy((array_list_pt)hashMapEntry_getValue(entry));
}
hashMapIterator_destroy(iter);
hashMap_destroy(admin->externalPublications,false,false);
celixThreadMutex_unlock(&admin->externalPublicationsLock);
celixThreadMutex_lock(&admin->serializerListLock);
arrayList_destroy(admin->serializerList);
celixThreadMutex_unlock(&admin->serializerListLock);
celixThreadMutex_lock(&admin->noSerializerPendingsLock);
arrayList_destroy(admin->noSerializerSubscriptions);
arrayList_destroy(admin->noSerializerPublications);
celixThreadMutex_unlock(&admin->noSerializerPendingsLock);
celixThreadMutex_lock(&admin->usedSerializersLock);
iter = hashMapIterator_create(admin->topicSubscriptionsPerSerializer);
while(hashMapIterator_hasNext(iter)){
arrayList_destroy((array_list_pt)hashMapIterator_nextValue(iter));
}
hashMapIterator_destroy(iter);
hashMap_destroy(admin->topicSubscriptionsPerSerializer,false,false);
iter = hashMapIterator_create(admin->topicPublicationsPerSerializer);
while(hashMapIterator_hasNext(iter)){
arrayList_destroy((array_list_pt)hashMapIterator_nextValue(iter));
}
hashMapIterator_destroy(iter);
hashMap_destroy(admin->topicPublicationsPerSerializer,false,false);
celixThreadMutex_unlock(&admin->usedSerializersLock);
celixThreadMutex_destroy(&admin->usedSerializersLock);
celixThreadMutex_destroy(&admin->serializerListLock);
celixThreadMutex_destroy(&admin->pendingSubscriptionsLock);
celixThreadMutexAttr_destroy(&admin->noSerializerPendingsAttr);
celixThreadMutex_destroy(&admin->noSerializerPendingsLock);
celixThreadMutexAttr_destroy(&admin->pendingSubscriptionsAttr);
celixThreadMutex_destroy(&admin->subscriptionsLock);
celixThreadMutex_destroy(&admin->localPublicationsLock);
celixThreadMutex_destroy(&admin->externalPublicationsLock);
logHelper_stop(admin->loghelper);
logHelper_destroy(&admin->loghelper);
#ifdef BUILD_WITH_ZMQ_SECURITY
if (admin->zmq_auth != NULL){
zactor_destroy(&(admin->zmq_auth));
}
#endif
free(admin);
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 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;
}
celix_status_t inspectCommand_printImportedServices(command_pt command, array_list_pt ids, void (*out)(char *), void (*err)(char *)) {
celix_status_t status = CELIX_SUCCESS;
array_list_pt bundles = NULL;
if (arrayList_isEmpty(ids)) {
celix_status_t status = bundleContext_getBundles(command->bundleContext, &bundles);
} else {
unsigned int i;
arrayList_create(&bundles);
for (i = 0; i < arrayList_size(ids); i++) {
char *idStr = (char *) arrayList_get(ids, i);
long id = atol(idStr);
bundle_pt b = NULL;
celix_status_t st = bundleContext_getBundleById(command->bundleContext, id, &b);
if (st == CELIX_SUCCESS) {
arrayList_add(bundles, b);
} else {
char line[256];
sprintf(line, "INSPECT: Invalid bundle ID: %ld\n", id);
out(line);
}
}
}
if (status == CELIX_SUCCESS) {
unsigned int i = 0;
for (i = 0; i < arrayList_size(bundles); i++) {
bundle_pt bundle = (bundle_pt) arrayList_get(bundles, i);
if (i > 0) {
out("\n");
}
if (bundle != NULL) {
array_list_pt refs = NULL;
if (bundle_getServicesInUse(bundle, &refs) == CELIX_SUCCESS) {
char line[256];
module_pt module = NULL;
char * name = NULL;
status = bundle_getCurrentModule(bundle, &module);
if (status == CELIX_SUCCESS) {
status = module_getSymbolicName(module, &name);
if (status == CELIX_SUCCESS) {
sprintf(line, "%s requires services:\n", name);
out(line);
out("==============\n");
if (refs == NULL || arrayList_size(refs) == 0) {
out("Nothing\n");
} else {
unsigned int j = 0;
for (j = 0; j < arrayList_size(refs); j++) {
service_reference_pt ref = (service_reference_pt) arrayList_get(refs, j);
service_registration_pt reg = NULL;
properties_pt props = NULL;
char line[256];
bundle_pt usedBundle = NULL;
module_pt usedModule = NULL;
char *usedSymbolicName = NULL;
long usedBundleId;
serviceReference_getBundle(ref, &usedBundle);
bundle_getBundleId(usedBundle, &usedBundleId);
bundle_getCurrentModule(usedBundle, &usedModule);
module_getSymbolicName(usedModule, &usedSymbolicName);
sprintf(line, "%s [%ld]\n", usedSymbolicName, usedBundleId);
out(line);
serviceReference_getServiceRegistration(ref, ®);
serviceRegistration_getProperties(reg, &props);
hash_map_iterator_pt iter = hashMapIterator_create(props);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
sprintf(line, "%s = %s\n", hashMapEntry_getKey(entry), hashMapEntry_getValue(entry));
out(line);
}
hashMapIterator_destroy(iter);
// objectClass = properties_get(props, (char *) OSGI_FRAMEWORK_OBJECTCLASS);
// sprintf(line, "ObjectClass = %s\n", objectClass);
if ((j + 1) < arrayList_size(refs)) {
out("----\n");
}
}
}
}
}
}
}
}
}
return status;
}
static int remoteServiceAdmin_callback(struct mg_connection *conn) {
int result = 1; // zero means: let civetweb handle it further, any non-zero value means it is handled by us...
const struct mg_request_info *request_info = mg_get_request_info(conn);
if (request_info->uri != NULL) {
remote_service_admin_pt rsa = request_info->user_data;
if (strncmp(request_info->uri, "/service/", 9) == 0 && strcmp("POST", request_info->request_method) == 0) {
// uri = /services/myservice/call
const char *uri = request_info->uri;
// rest = myservice/call
const char *rest = uri+9;
char *interfaceStart = strchr(rest, '/');
int pos = interfaceStart - rest;
char service[pos+1];
strncpy(service, rest, pos);
service[pos] = '\0';
long serviceId = atol(service);
celixThreadMutex_lock(&rsa->exportedServicesLock);
//find endpoint
export_registration_pt export = NULL;
hash_map_iterator_pt iter = hashMapIterator_create(rsa->exportedServices);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
array_list_pt exports = hashMapEntry_getValue(entry);
int expIt = 0;
for (expIt = 0; expIt < arrayList_size(exports); expIt++) {
export_registration_pt check = arrayList_get(exports, expIt);
export_reference_pt ref = NULL;
exportRegistration_getExportReference(check, &ref);
endpoint_description_pt checkEndpoint = NULL;
exportReference_getExportedEndpoint(ref, &checkEndpoint);
if (serviceId == checkEndpoint->serviceId) {
export = check;
free(ref);
break;
}
free(ref);
}
}
hashMapIterator_destroy(iter);
if (export != NULL) {
uint64_t datalength = request_info->content_length;
char* data = malloc(datalength + 1);
mg_read(conn, data, datalength);
data[datalength] = '\0';
char *response = NULL;
int responceLength = 0;
int rc = exportRegistration_call(export, data, -1, &response, &responceLength);
if (rc != CELIX_SUCCESS) {
RSA_LOG_ERROR(rsa, "Error trying to invoke remove service, got error %i\n", rc);
}
if (rc == CELIX_SUCCESS && response != NULL) {
mg_write(conn, data_response_headers, strlen(data_response_headers));
mg_write(conn, response, strlen(response));
free(response);
} else {
mg_write(conn, no_content_response_headers, strlen(no_content_response_headers));
}
result = 1;
free(data);
} else {
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 wiringTopologyManager_waAdded(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;
celixThreadMutex_lock(&manager->waListLock);
arrayList_add(manager->waList, wiringAdminService);
celixThreadMutex_unlock(&manager->waListLock);
/* check whether one of the exported Wires can be exported via the newly available wiringAdmin */
celixThreadMutex_lock(&manager->exportedWiringEndpointsLock);
hash_map_iterator_pt iter = hashMapIterator_create(manager->exportedWiringEndpoints);
// is the properties_match missing here>
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
properties_pt exportedWireProperties = hashMapEntry_getKey(entry);
hash_map_pt wiringAdminList = hashMapEntry_getValue(entry);
wiring_endpoint_description_pt wEndpoint = NULL;
char* serviceId = properties_get(exportedWireProperties, "service.id");
printf("WTM: wiringTopologyManager_waAdded export Wire for %s \n", serviceId);
status = wiringTopologyManager_WiringAdminServiceExportWiringEndpoint(manager, wiringAdminService, exportedWireProperties, &wEndpoint);
if (status == CELIX_SUCCESS) {
hashMap_put(wiringAdminList, wiringAdminService, wEndpoint);
} else {
printf("WTM: Could not export wire with new WA\n");
}
}
hashMapIterator_destroy(iter);
/* check whether the waiting exports can be exported */
array_list_iterator_pt waitList = arrayListIterator_create(manager->waitingForExport);
while (arrayListIterator_hasNext(waitList)) {
properties_pt srvcProperties = arrayListIterator_next(waitList);
char* serviceId = properties_get(srvcProperties, "service.id");
printf("WTM: wiringTopologyManager_waAdded export Wire for %s \n", serviceId);
wiring_endpoint_description_pt wEndpoint = NULL;
status = wiringTopologyManager_WiringAdminServiceExportWiringEndpoint(manager, wiringAdminService, srvcProperties, &wEndpoint);
if (status == CELIX_SUCCESS) {
arrayListIterator_remove(waitList);
arrayListIterator_destroy(waitList);
waitList = arrayListIterator_create(manager->waitingForExport);
hash_map_pt wiringAdminList = hashMap_create(NULL, NULL, NULL, NULL);
hashMap_put(wiringAdminList, wiringAdminService, wEndpoint);
hashMap_put(manager->exportedWiringEndpoints, srvcProperties, wiringAdminList);
} else {
printf("WTM: Could not export wire with new WA\n");
}
}
arrayListIterator_destroy(waitList);
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 wEndpoint = hashMapEntry_getKey(entry);
array_list_pt wiringAdminList = hashMapEntry_getValue(entry);
status = wiringTopologyManager_checkWiringAdminForImportWiringEndpoint(manager, wiringAdminService, wEndpoint);
if (status == CELIX_SUCCESS) {
arrayList_add(wiringAdminList, wiringAdminService);
}
}
hashMapIterator_destroy(iter);
/* check wether waiting service can be exported */
wiringTopologyManager_checkWaitingForImportServices(manager);
celixThreadMutex_unlock(&manager->importedWiringEndpointsLock);
printf("WTM: Added WA\n");
return status;
}