celix_status_t serviceRegistry_create(framework_pt framework, serviceChanged_function_pt serviceChanged, service_registry_pt *registry) { celix_status_t status = CELIX_SUCCESS; *registry = malloc(sizeof(**registry)); if (!*registry) { status = CELIX_ENOMEM; } else { (*registry)->serviceChanged = serviceChanged; (*registry)->inUseMap = hashMap_create(NULL, NULL, NULL, NULL); (*registry)->serviceRegistrations = hashMap_create(NULL, NULL, NULL, NULL); (*registry)->framework = framework; (*registry)->currentServiceId = 1l; (*registry)->serviceReferences = hashMap_create(NULL, NULL, NULL, NULL);; arrayList_create(&(*registry)->listenerHooks); status = celixThreadMutexAttr_create(&(*registry)->mutexAttr); status = CELIX_DO_IF(status, celixThreadMutexAttr_settype(&(*registry)->mutexAttr, CELIX_THREAD_MUTEX_RECURSIVE)); status = CELIX_DO_IF(status, celixThreadMutex_create(&(*registry)->mutex, &(*registry)->mutexAttr)); status = CELIX_DO_IF(status, celixThreadMutex_create(&(*registry)->referencesMapMutex, NULL)); } framework_logIfError(logger, status, NULL, "Cannot create service registry"); return status; }
celix_status_t bundle_revise(bundle_pt bundle, char * location, char *inputFile) { celix_status_t status = CELIX_SUCCESS; bundle_archive_pt archive = NULL; status = bundle_getArchive(bundle, &archive); if (status == CELIX_SUCCESS) { status = bundleArchive_revise(archive, location, inputFile); if (status == CELIX_SUCCESS) { module_pt module; status = bundle_createModule(bundle, &module); if (status == CELIX_SUCCESS) { status = bundle_addModule(bundle, module); } else { bool rolledback; status = bundleArchive_rollbackRevise(archive, &rolledback); if (status == CELIX_SUCCESS) { status = CELIX_BUNDLE_EXCEPTION; } } } } framework_logIfError(bundle->framework->logger, status, NULL, "Failed to revise bundle"); return status; }
celix_status_t bundle_unlock(bundle_pt bundle, bool *unlocked) { celix_status_t status = CELIX_SUCCESS; bool equals; celixThreadMutex_lock(&bundle->lock); if (bundle->lockCount == 0) { *unlocked = false; } else { status = thread_equalsSelf(bundle->lockThread, &equals); if (status == CELIX_SUCCESS) { if ((bundle->lockCount > 0) && !equals) { return false; } bundle->lockCount--; if (bundle->lockCount == 0) { bundle->lockThread = 0; } *unlocked = true; } } celixThreadMutex_unlock(&bundle->lock); framework_logIfError(bundle->framework->logger, status, NULL, "Failed to unlock bundle"); return status; }
celix_status_t serviceRegistry_getRegisteredServices(service_registry_pt registry, bundle_pt bundle, array_list_pt *services) { celix_status_t status = CELIX_SUCCESS; celixThreadMutex_lock(®istry->mutex); array_list_pt regs = (array_list_pt) hashMap_get(registry->serviceRegistrations, bundle); if (regs != NULL) { unsigned int i; arrayList_create(services); for (i = 0; i < arrayList_size(regs); i++) { service_registration_pt reg = arrayList_get(regs, i); if (serviceRegistration_isValid(reg)) { service_reference_pt reference = NULL; status = serviceRegistry_createServiceReference(registry, bundle, reg, &reference); if (status == CELIX_SUCCESS) { arrayList_add(*services, reference); } } } } celixThreadMutex_unlock(®istry->mutex); framework_logIfError(logger, status, NULL, "Cannot get registered services"); return status; }
celix_status_t requirement_create(hash_map_pt directives, hash_map_pt attributes, requirement_pt *requirement) { celix_status_t status = CELIX_SUCCESS; *requirement = (requirement_pt) malloc(sizeof(**requirement)); if (!*requirement) { status = CELIX_ENOMEM; } else { attribute_pt serviceAttribute = NULL; attribute_pt versionAttribute = NULL; (*requirement)->attributes = attributes; (*requirement)->directives = directives; serviceAttribute = (attribute_pt) hashMap_get(attributes, "service"); status = attribute_getValue(serviceAttribute, &(*requirement)->targetName); if (status == CELIX_SUCCESS) { (*requirement)->versionRange = NULL; status = versionRange_createInfiniteVersionRange(&(*requirement)->versionRange); if (status == CELIX_SUCCESS) { versionAttribute = (attribute_pt) hashMap_get(attributes, "version"); if (versionAttribute != NULL) { char *versionStr = NULL; attribute_getValue(versionAttribute, &versionStr); (*requirement)->versionRange = NULL; status = versionRange_parse(versionStr, &(*requirement)->versionRange); } } } } framework_logIfError(logger, status, NULL, "Cannot create requirement"); return status; }
celix_status_t serviceTracker_open(service_tracker_pt tracker) { service_listener_pt listener; array_list_pt initial = NULL; celix_status_t status = CELIX_SUCCESS; listener = (service_listener_pt) malloc(sizeof(*listener)); status = bundleContext_getServiceReferences(tracker->context, NULL, tracker->filter, &initial); if (status == CELIX_SUCCESS) { service_reference_pt initial_reference; unsigned int i; listener->handle = tracker; listener->serviceChanged = (void *) serviceTracker_serviceChanged; status = bundleContext_addServiceListener(tracker->context, listener, tracker->filter); if (status == CELIX_SUCCESS) { tracker->listener = listener; for (i = 0; i < arrayList_size(initial); i++) { initial_reference = (service_reference_pt) arrayList_get(initial, i); serviceTracker_track(tracker, initial_reference, NULL); } arrayList_clear(initial); arrayList_destroy(initial); initial = NULL; } } framework_logIfError(logger, status, NULL, "Cannot open tracker"); return status; }
celix_status_t bundleCache_create(properties_pt configurationMap, framework_logger_pt logger, bundle_cache_pt *bundle_cache) { celix_status_t status; bundle_cache_pt cache; cache = (bundle_cache_pt) malloc((sizeof(*cache))); if (cache == NULL) { status = CELIX_ENOMEM; } else { if (configurationMap != NULL && *bundle_cache == NULL) { char * cacheDir = properties_get(configurationMap, (char *) OSGI_FRAMEWORK_FRAMEWORK_STORAGE); cache->configurationMap = configurationMap; if (cacheDir == NULL) { cacheDir = ".cache"; } cache->cacheDir = cacheDir; cache->logger = logger; *bundle_cache = cache; status = CELIX_SUCCESS; } else { status = CELIX_ILLEGAL_ARGUMENT; } } framework_logIfError(cache->logger, status, NULL, "Failed to create bundle cache"); return status; }
static celix_status_t serviceTracker_addingService(service_tracker_pt tracker, service_reference_pt reference, void **service) { celix_status_t status = CELIX_SUCCESS; if (tracker->customizer != NULL) { void *handle = NULL; adding_callback_pt function = NULL; status = serviceTrackerCustomizer_getHandle(tracker->customizer, &handle); if (status == CELIX_SUCCESS) { status = serviceTrackerCustomizer_getAddingFunction(tracker->customizer, &function); if (status == CELIX_SUCCESS) { if (function != NULL) { status = function(handle, reference, service); } else { status = bundleContext_getService(tracker->context, reference, service); } } } } else { status = bundleContext_getService(tracker->context, reference, service); } framework_logIfError(logger, status, NULL, "Cannot handle addingService"); return status; }
celix_status_t bundle_getRegisteredServices(bundle_pt bundle, array_list_pt *list) { celix_status_t status = CELIX_SUCCESS; status = fw_getBundleRegisteredServices(bundle->framework, bundle, list); framework_logIfError(bundle->framework->logger, status, NULL, "Failed to get registered services"); return status; }
celix_status_t bundle_getServicesInUse(bundle_pt bundle, array_list_pt *list) { celix_status_t status = CELIX_SUCCESS; status = fw_getBundleServicesInUse(bundle->framework, bundle, list); framework_logIfError(bundle->framework->logger, status, NULL, "Failed to get in use services"); return status; }
static celix_status_t serviceTracker_track(service_tracker_pt tracker, service_reference_pt reference, service_event_pt event) { celix_status_t status = CELIX_SUCCESS; tracked_pt tracked = NULL; int found = -1; unsigned int i; for (i = 0; i < arrayList_size(tracker->tracked); i++) { bool equals; tracked = (tracked_pt) arrayList_get(tracker->tracked, i); serviceReference_equals(reference, tracked->reference, &equals); if (equals) { found = 0; break; } } if (found) { void * service = NULL; status = serviceTracker_addingService(tracker, reference, &service); if (status == CELIX_SUCCESS) { if (service != NULL) { tracked = (tracked_pt) malloc(sizeof(*tracked)); tracked->reference = reference; tracked->service = service; arrayList_add(tracker->tracked, tracked); if (tracker->customizer != NULL) { void *handle = NULL; added_callback_pt function = NULL; serviceTrackerCustomizer_getHandle(tracker->customizer, &handle); serviceTrackerCustomizer_getAddedFunction(tracker->customizer, &function); if (function != NULL) { function(handle, reference, service); } } } } } else { if (tracker->customizer != NULL) { void *handle = NULL; modified_callback_pt function = NULL; serviceTrackerCustomizer_getHandle(tracker->customizer, &handle); serviceTrackerCustomizer_getModifiedFunction(tracker->customizer, &function); if (function != NULL) { function(handle, reference, tracked->service); } } } framework_logIfError(logger, status, NULL, "Cannot track reference"); return status; }
celix_status_t serviceRegistry_getServiceReferences(service_registry_pt registry, bundle_pt owner, const char *serviceName, filter_pt filter, array_list_pt *references) { celix_status_t status = CELIX_SUCCESS; hash_map_values_pt registrations; hash_map_iterator_pt iterator; arrayList_create(references); celixThreadMutex_lock(®istry->mutex); registrations = hashMapValues_create(registry->serviceRegistrations); iterator = hashMapValues_iterator(registrations); while (hashMapIterator_hasNext(iterator)) { array_list_pt regs = (array_list_pt) hashMapIterator_nextValue(iterator); unsigned int regIdx; for (regIdx = 0; (regs != NULL) && regIdx < arrayList_size(regs); regIdx++) { service_registration_pt registration = (service_registration_pt) arrayList_get(regs, regIdx); properties_pt props = NULL; status = serviceRegistration_getProperties(registration, &props); if (status == CELIX_SUCCESS) { bool matched = false; bool matchResult = false; if (filter != NULL) { filter_match(filter, props, &matchResult); } if ((serviceName == NULL) && ((filter == NULL) || matchResult)) { matched = true; } else if (serviceName != NULL) { char *className = NULL; bool matchResult = false; serviceRegistration_getServiceName(registration, &className); if (filter != NULL) { filter_match(filter, props, &matchResult); } if ((strcmp(className, serviceName) == 0) && ((filter == NULL) || matchResult)) { matched = true; } } if (matched) { if (serviceRegistration_isValid(registration)) { service_reference_pt reference = NULL; serviceRegistry_createServiceReference(registry, owner, registration, &reference); arrayList_add(*references, reference); } } } } } hashMapIterator_destroy(iterator); hashMapValues_destroy(registrations); celixThreadMutex_unlock(®istry->mutex); framework_logIfError(logger, status, NULL, "Cannot get service references"); return status; }
celix_status_t bundleRevision_getNumber(bundle_revision_pt revision, long *revisionNr) { celix_status_t status = CELIX_SUCCESS; if (revision == NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { *revisionNr = revision->revisionNr; } framework_logIfError(logger, status, NULL, "Failed to get revision number"); return status; }
celix_status_t bundleRevision_getHandles(bundle_revision_pt revision, array_list_pt *handles) { celix_status_t status = CELIX_SUCCESS; if (revision == NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { *handles = revision->libraryHandles; } framework_logIfError(logger, status, NULL, "Failed to get handles"); return status; }
celix_status_t bundleRevision_getManifest(bundle_revision_pt revision, manifest_pt *manifest) { celix_status_t status = CELIX_SUCCESS; if (revision == NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { *manifest = revision->manifest; } framework_logIfError(logger, status, NULL, "Failed to get manifest"); return status; }
celix_status_t bundle_getBundleId(bundle_pt bundle, long *id) { celix_status_t status = CELIX_SUCCESS; bundle_archive_pt archive = NULL; status = bundle_getArchive(bundle, &archive); if (status == CELIX_SUCCESS) { status = bundleArchive_getId(archive, id); } framework_logIfError(bundle->framework->logger, status, NULL, "Failed to get bundle id"); return status; }
celix_status_t bundleRevision_getLocation(bundle_revision_pt revision, char **location) { celix_status_t status = CELIX_SUCCESS; if (revision == NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { *location = revision->location; } framework_logIfError(logger, status, NULL, "Failed to get revision location"); return status; }
celix_status_t bundleRevision_getRoot(bundle_revision_pt revision, char **root) { celix_status_t status = CELIX_SUCCESS; if (revision == NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { *root = revision->root; } framework_logIfError(logger, status, NULL, "Failed to get revision root"); return status; }
celix_status_t bundleContext_getService(bundle_context_pt context, service_reference_pt reference, void **service_instance) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && reference != NULL && *service_instance == NULL) { status = fw_getService(context->framework, context->bundle, reference, service_instance); } else { status = CELIX_ILLEGAL_ARGUMENT; } framework_logIfError(logger, status, NULL, "Failed to get service"); return status; }
celix_status_t bundleContext_getFramework(bundle_context_pt context, framework_pt *framework) { celix_status_t status = CELIX_SUCCESS; if (context == NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { *framework = context->framework; } framework_logIfError(logger, status, NULL, "Failed to get framework"); return status; }
celix_status_t bundleContext_getBundle(bundle_context_pt context, bundle_pt *bundle) { celix_status_t status = CELIX_SUCCESS; if (context == NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { *bundle = context->bundle; } framework_logIfError(logger, status, NULL, "Failed to get bundle"); return status; }
celix_status_t bundleContext_getProperty(bundle_context_pt context, const char *name, char **value) { celix_status_t status = CELIX_SUCCESS; if (context == NULL || name == NULL || *value != NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { fw_getProperty(context->framework, name, value); } framework_logIfError(logger, status, NULL, "Failed to get property [name=%s]", name); return status; }
celix_status_t bundleContext_removeFrameworkListener(bundle_context_pt context, framework_listener_pt listener) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && listener != NULL) { fw_removeFrameworkListener(context->framework, context->bundle, listener); } else { status = CELIX_ILLEGAL_ARGUMENT; } framework_logIfError(logger, status, NULL, "Failed to remove framework listener"); return status; }
celix_status_t bundleContext_addServiceListener(bundle_context_pt context, service_listener_pt listener, char * filter) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && listener != NULL) { fw_addServiceListener(context->framework, context->bundle, listener, filter); } else { status = CELIX_ILLEGAL_ARGUMENT; } framework_logIfError(logger, status, NULL, "Failed to add service listener"); return status; }
celix_status_t bundleContext_getBundles(bundle_context_pt context, array_list_pt *bundles) { celix_status_t status = CELIX_SUCCESS; if (context == NULL || *bundles != NULL) { status = CELIX_ILLEGAL_ARGUMENT; } else { *bundles = framework_getBundles(context->framework); } framework_logIfError(logger, status, NULL, "Failed to get bundles"); return status; }
celix_status_t bundleContext_ungetService(bundle_context_pt context, service_reference_pt reference, bool *result) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && reference != NULL) { status = framework_ungetService(context->framework, context->bundle, reference, result); } else { status = CELIX_ILLEGAL_ARGUMENT; } framework_logIfError(logger, status, NULL, "Failed to unget service"); return status; }
celix_status_t bundleContext_getServiceReferences(bundle_context_pt context, const char * serviceName, char * filter, array_list_pt *service_references) { celix_status_t status = CELIX_SUCCESS; if (context != NULL && *service_references == NULL) { fw_getServiceReferences(context->framework, service_references, context->bundle, serviceName, filter); } else { status = CELIX_ILLEGAL_ARGUMENT; } framework_logIfError(logger, status, NULL, "Failed to get service references"); return status; }
celix_status_t manifest_createFromFile(char *filename, manifest_pt *manifest) { celix_status_t status; status = manifest_create(manifest); if (status == CELIX_SUCCESS) { manifest_read(*manifest, filename); } framework_logIfError(logger, status, NULL, "Cannot create manifest from file"); return status; }
celix_status_t serviceRegistration_getBundle(service_registration_pt registration, bundle_pt *bundle) { celix_status_t status = CELIX_SUCCESS; if (registration != NULL && *bundle == NULL) { *bundle = registration->bundle; } else { status = CELIX_ILLEGAL_ARGUMENT; } framework_logIfError(logger, status, NULL, "Cannot get bundle"); return status; }
celix_status_t serviceRegistration_getServiceName(service_registration_pt registration, char **serviceName) { celix_status_t status = CELIX_SUCCESS; if (registration != NULL && *serviceName == NULL) { *serviceName = registration->className; } else { status = CELIX_ILLEGAL_ARGUMENT; } framework_logIfError(logger, status, NULL, "Cannot get service name"); return status; }