int producer_getSampleRate(void* handle) { producer_pt producer = (producer_pt) handle; int sampleRate = 0; pthread_rwlock_rdlock(&producer->queueLock); hash_map_iterator_pt iter = hashMapIterator_create(producer->queueServices); while (hashMapIterator_hasNext(iter)) { producer_thread_data_pt th_data = (producer_thread_data_pt) hashMapIterator_nextValue(iter); pthread_rwlock_rdlock(&th_data->sampleRateLock); sampleRate += th_data->single_throughput; // + value->burst_throughput pthread_rwlock_unlock(&th_data->sampleRateLock); } hashMapIterator_destroy(iter); if (hashMap_size(producer->queueServices) > 0) { sampleRate /= hashMap_size(producer->queueServices); } pthread_rwlock_unlock(&producer->queueLock); return sampleRate; }
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; }
celix_status_t eventAdmin_event_equals( event_pt *event, event_pt *compare, bool *result){ celix_status_t status = CELIX_SUCCESS; if(event == compare){ (*result) = true; }else { int sizeofEvent = hashMap_size((*event)->properties); int sizeofCompare = hashMap_size((*compare)->properties); if(sizeofEvent == sizeofCompare){ (*result) = true; }else { } } 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 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 eventAdmin_getPropertyNames( event_pt *event, array_list_pt *names){ celix_status_t status = CELIX_SUCCESS; properties_pt properties = (*event)->properties; 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); char * key =hashMapEntry_getKey(entry); arrayList_add((*names),key); } } 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"); } }
celix_status_t managedServiceTracker_notifyUpdated(managed_service_tracker_pt tracker, configuration_pt configuration) { char *pid; service_reference_pt reference = NULL; bundle_pt bundle = NULL; properties_pt properties = NULL; managed_service_service_pt service = NULL; // (1) config.checkLocked if (configuration_checkLocked(configuration->handle) != CELIX_SUCCESS) { //TODO not yet implemented return CELIX_ILLEGAL_ARGUMENT; } // (2) config.getPid if (configuration_getPid(configuration->handle, &pid) != CELIX_SUCCESS) { return CELIX_ILLEGAL_ARGUMENT; } // (3) reference = getManagedServiceReference(pid) if (managedServiceTracker_getManagedServiceReference(tracker, pid, &reference) != CELIX_SUCCESS || reference == NULL) { printf("[ ERROR ]: Tracker - Notify (NULL Reference Service{PID=%s}) \n", pid); return CELIX_ILLEGAL_ARGUMENT; // Eclipse ignores, but according to Specs, callback is delayed } // (4.1) reference.getBundle if (serviceReference_getBundle(reference, &bundle) != CELIX_SUCCESS || bundle == NULL) { printf("[ ERROR ]: Tracker - Notify (NULL Bundle Service{PID=%s}) \n", pid); return CELIX_ILLEGAL_ARGUMENT; } // (4.2) config.bind(reference.getBundle) bool isBind; if (configuration_bind(configuration->handle, bundle, &isBind) != CELIX_SUCCESS || isBind == false) { printf("[ ERROR ]: Tracker - Notify (Service{PID=%s} Permission Error) \n", pid); return CELIX_ILLEGAL_STATE; } // (5) if (reference != null && config.bind(reference.getBundle())) // (5.1) properties = config.getProperties if (configuration_getProperties(configuration->handle, &properties) != CELIX_SUCCESS) { printf("[ ERROR ]: Tracker - Notify (Service{PID=%s} Wrong Properties) \n", pid); return CELIX_ILLEGAL_ARGUMENT; } // (5.2) modifyConfiguration if (configurationAdminFactory_modifyConfiguration(tracker->configurationAdminfactory, reference, properties) != CELIX_SUCCESS) { return CELIX_ILLEGAL_ARGUMENT; //TODO no yet implemented modifyConfiguration } // (5.3) service = getManagedService(pid) if (managedServiceTracker_getManagedService(tracker, pid, &service) != CELIX_SUCCESS) { printf("[ ERROR ]: Tracker - Notify (NULL Service{PID=%s}) \n", pid); return CELIX_ILLEGAL_ARGUMENT; } // (5.4) asynchUpdate(service,properties) if ((properties == NULL) || (properties != NULL && hashMap_size(properties) == 0)) { return managedServiceTracker_asynchUpdated(tracker, service, NULL); } else { return managedServiceTracker_asynchUpdated(tracker, service, properties); } return CELIX_ILLEGAL_ARGUMENT; }
static int wiringAdmin_callback(struct mg_connection *conn) { int result = 0; // 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) { wiring_admin_pt admin = request_info->user_data; if (hashMap_size(admin->wiringReceiveServices) == 0) { printf("%s: No wiringReceiveServices available\n", TAG); } if (strcmp("POST", request_info->request_method) == 0) { celixThreadMutex_lock(&admin->exportedWiringEndpointLock); uint64_t datalength = request_info->content_length; char* data = malloc(datalength + 1); mg_read(conn, data, datalength); data[datalength] = '\0'; char *response = NULL; hash_map_iterator_pt iter = hashMapIterator_create(admin->wiringReceiveServices); while (hashMapIterator_hasNext(iter)) { array_list_pt wiringReceiveServiceList = hashMapIterator_nextValue(iter); if (arrayList_size(wiringReceiveServiceList) > 0) { // printf("WIRING_ADMIN: size of wiringReceiveServiceList is %d\n", arrayList_size(wiringReceiveServiceList)); // TODO: we do not support mulitple wiringReceivers? wiring_receive_service_pt wiringReceiveService = (wiring_receive_service_pt) arrayList_get(wiringReceiveServiceList, 0); if (wiringReceiveService->receive(wiringReceiveService->handle, data, &response) != CELIX_SUCCESS) { response = NULL; } break; } else { printf("%s: wiringReceiveServiceList is empty\n", TAG); } } hashMapIterator_destroy(iter); if (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 { printf("%s: Received HTTP Request, but no RSA_Inaetics callback is installed. Discarding request.\n", TAG); } celixThreadMutex_unlock(&admin->exportedWiringEndpointLock); } else { printf("%s: Received URI is NULL\n", TAG); } return result; }