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 shellMediator_create(bundle_context_pt context, shell_mediator_pt *instance) {
celix_status_t status = CELIX_SUCCESS;
service_tracker_customizer_pt customizer = NULL;
(*instance) = (shell_mediator_pt) calloc(1, sizeof(**instance));
if ((*instance) != NULL) {
(*instance)->context = context;
(*instance)->tracker = NULL;
(*instance)->shellService = NULL;
status = logHelper_create(context, &(*instance)->loghelper);
status = CELIX_DO_IF(status, celixThreadMutex_create(&(*instance)->mutex, NULL));
status = CELIX_DO_IF(status, serviceTrackerCustomizer_create((*instance), shellMediator_addingService, shellMediator_addedService,
shellMediator_modifiedService, shellMediator_removedService, &customizer));
status = CELIX_DO_IF(status, serviceTracker_create(context, (char * )OSGI_SHELL_SERVICE_NAME, customizer, &(*instance)->tracker));
if (status == CELIX_SUCCESS) {
logHelper_start((*instance)->loghelper);
serviceTracker_open((*instance)->tracker);
}
} else {
status = CELIX_ENOMEM;
}
if (status != CELIX_SUCCESS) {
logHelper_log((*instance)->loghelper, OSGI_LOGSERVICE_ERROR, "Error creating shell_mediator, error code is %i\n", status);
}
return status;
}
int main(void) {
apr_status_t rv = APR_SUCCESS;
apr_status_t s = APR_SUCCESS;
properties_pt config = NULL;
char *autoStart = NULL;
apr_pool_t *pool = NULL;
bundle_pt fwBundle = NULL;
rv = apr_initialize();
if (rv != APR_SUCCESS) {
return CELIX_START_ERROR;
}
apr_pool_t *memoryPool;
s = apr_pool_create(&memoryPool, NULL);
if (s != APR_SUCCESS) {
return CELIX_START_ERROR;
}
struct framework * framework = NULL;
celix_status_t status = CELIX_SUCCESS;
status = framework_create(&framework, memoryPool, config);
if (status == CELIX_SUCCESS) {
status = fw_init(framework);
if (status == CELIX_SUCCESS) {
// Start the system bundle
framework_getFrameworkBundle(framework, &fwBundle);
bundle_start(fwBundle);
bundle_context_pt context = NULL;
bundle_getContext(fwBundle, &context);
// do some stuff
bundle_pt bundle = NULL;
status = CELIX_DO_IF(status, bundleContext_installBundle(context, "../test_bundle1/test_bundle1.zip", &bundle));
status = CELIX_DO_IF(status, bundle_start(bundle));
// Stop the system bundle, sleep a bit to let stuff settle down
sleep(5);
bundle_stop(fwBundle);
framework_destroy(framework);
}
}
if (status != CELIX_SUCCESS) {
printf("Problem creating framework\n");
}
apr_pool_destroy(memoryPool);
apr_terminate();
printf("LAUNCHER: Exit\n");
return 0;
}
celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
celix_status_t status = CELIX_SUCCESS;
bundle_instance_pt bi = (bundle_instance_pt) userData;
int port = bundleActivator_getPort(bi, context);
int maxConn = bundleActivator_getMaximumConnections(bi, context);
status = logHelper_start(bi->loghelper);
status = CELIX_DO_IF(status, shellMediator_create(context, &bi->shellMediator));
status = CELIX_DO_IF(status, remoteShell_create(bi->shellMediator, maxConn, &bi->remoteShell));
status = CELIX_DO_IF(status, connectionListener_create(bi->remoteShell, port, &bi->connectionListener));
status = CELIX_DO_IF(status, connectionListener_start(bi->connectionListener));
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 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_start(void * userData, bundle_context_pt context) {
celix_status_t status = CELIX_SUCCESS;
struct activator * act = userData;
act->reg = NULL;
status = bundleContext_registerService(context, (char *)TST_SERVICE_NAME, &act->serv, NULL, &act->reg);
status = CELIX_DO_IF(status, serviceTracker_open(act->tracker));
return status;
}
celix_status_t bundleRevision_create(framework_logger_pt loggera, char *root, char *location, long revisionNr, char *inputFile, bundle_revision_pt *bundle_revision) {
celix_status_t status = CELIX_SUCCESS;
bundle_revision_pt revision = NULL;
revision = (bundle_revision_pt) malloc(sizeof(*revision));
if (!revision) {
status = CELIX_ENOMEM;
} else {
// TODO: This overwrites an existing revision, is this supposed to happen?
int state = mkdir(root, S_IRWXU);
if ((state != 0) && (errno != EEXIST)) {
free(revision);
status = CELIX_FILE_IO_EXCEPTION;
} else {
if (inputFile != NULL) {
status = extractBundle(inputFile, root);
} else if (strcmp(location, "inputstream:") != 0) {
// TODO how to handle this correctly?
// If location != inputstream, extract it, else ignore it and assume this is a cache entry.
status = extractBundle(location, root);
}
status = CELIX_DO_IF(status, arrayList_create(&(revision->libraryHandles)));
if (status == CELIX_SUCCESS) {
revision->revisionNr = revisionNr;
revision->root = strdup(root);
revision->location = strdup(location);
revision->logger = loggera;
*bundle_revision = revision;
char manifest[512];
snprintf(manifest, sizeof(manifest), "%s/META-INF/MANIFEST.MF", revision->root);
status = manifest_createFromFile(manifest, &revision->manifest);
}
else {
free(revision);
}
}
}
framework_logIfError(logger, status, NULL, "Failed to create revision");
return status;
}
celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
celix_status_t status;
struct activator *activator = userData;
endpoint_listener_pt endpointListener = malloc(sizeof(*endpointListener));
endpointListener->handle = activator->manager;
endpointListener->endpointAdded = topologyManager_addImportedService;
endpointListener->endpointRemoved = topologyManager_removeImportedService;
activator->endpointListener = endpointListener;
char *uuid = NULL;
status = bundleContext_getProperty(activator->context, (char *) OSGI_FRAMEWORK_FRAMEWORK_UUID, &uuid);
if (!uuid) {
logHelper_log(activator->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: no framework UUID defined?!");
return CELIX_ILLEGAL_STATE;
}
size_t len = 14 + strlen(OSGI_FRAMEWORK_OBJECTCLASS) + strlen(OSGI_RSA_ENDPOINT_FRAMEWORK_UUID) + strlen(uuid);
char *scope = malloc(len);
if (!scope) {
return CELIX_ENOMEM;
}
snprintf(scope, len, "(&(%s=*)(!(%s=%s)))", OSGI_FRAMEWORK_OBJECTCLASS, OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, uuid);
logHelper_log(activator->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: endpoint listener scope is %s", scope);
properties_pt props = properties_create();
properties_set(props, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, scope);
// We can release the scope, as properties_set makes a copy of the key & value...
free(scope);
bundleContext_registerService(context, (char *) OSGI_ENDPOINT_LISTENER_SERVICE, endpointListener, props, &activator->endpointListenerService);
listener_hook_service_pt hookService = malloc(sizeof(*hookService));
hookService->handle = activator->manager;
hookService->added = topologyManager_listenerAdded;
hookService->removed = topologyManager_listenerRemoved;
activator->hookService = hookService;
bundleContext_registerService(context, (char *) OSGI_FRAMEWORK_LISTENER_HOOK_SERVICE_NAME, hookService, NULL, &activator->hook);
bundleContext_addServiceListener(context, activator->serviceListener, "(service.exported.interfaces=*)");
if (status == CELIX_SUCCESS) {
serviceTracker_open(activator->remoteServiceAdminTracker);
}
if (status == CELIX_SUCCESS) {
status = serviceTracker_open(activator->endpointListenerTracker);
}
bundleContext_registerService(context, (char *) TOPOLOGYMANAGER_SCOPE_SERVICE, activator->scopeService, NULL, &activator->scopeReg);
array_list_pt references = NULL;
bundleContext_getServiceReferences(context, NULL, "(service.exported.interfaces=*)", &references);
int i;
for (i = 0; i < arrayList_size(references); i++) {
service_reference_pt reference = arrayList_get(references, i);
char *serviceId = NULL;
status = CELIX_DO_IF(status, serviceReference_getProperty(reference, (char *)OSGI_FRAMEWORK_SERVICE_ID, &serviceId));
CELIX_DO_IF(status, topologyManager_addExportedService(activator->manager, reference, serviceId));
}
arrayList_destroy(references);
return status;
}
celix_status_t bundle_createModule(bundle_pt bundle, module_pt *module) {
celix_status_t status = CELIX_SUCCESS;
bundle_archive_pt archive = NULL;
bundle_revision_pt revision = NULL;
manifest_pt headerMap = NULL;
status = CELIX_DO_IF(status, bundle_getArchive(bundle, &archive));
status = CELIX_DO_IF(status, bundleArchive_getCurrentRevision(archive, &revision));
status = CELIX_DO_IF(status, bundleRevision_getManifest(revision, &headerMap));
if (status == CELIX_SUCCESS) {
long bundleId;
status = bundleArchive_getId(bundle->archive, &bundleId);
if (status == CELIX_SUCCESS) {
int revision = 0;
char moduleId[512];
char *mId;
snprintf(moduleId, sizeof(moduleId), "%ld.%d", bundleId, revision);
mId = strdup(moduleId);
*module = module_create(headerMap, mId, bundle);
free(mId);
if (*module != NULL) {
version_pt bundleVersion = module_getVersion(*module);
char * symName = NULL;
status = module_getSymbolicName(*module, &symName);
if (status == CELIX_SUCCESS) {
array_list_pt bundles = framework_getBundles(bundle->framework);
unsigned int i;
for (i = 0; i < arrayList_size(bundles); i++) {
bundle_pt check = (bundle_pt) arrayList_get(bundles, i);
long id;
if (bundleArchive_getId(check->archive, &id) == CELIX_SUCCESS) {
if (id != bundleId) {
module_pt mod = NULL;
char * sym = NULL;
version_pt version;
int cmp;
status = bundle_getCurrentModule(check, &mod);
status = module_getSymbolicName(mod, &sym);
version = module_getVersion(mod);
version_compareTo(bundleVersion, version, &cmp);
if ((symName != NULL) && (sym != NULL) && !strcmp(symName, sym) &&
!cmp) {
char *versionString = NULL;
version_toString(version, &versionString);
printf("Bundle symbolic name and version are not unique: %s:%s\n", sym, versionString);
free(versionString);
status = CELIX_BUNDLE_EXCEPTION;
break;
}
}
}
}
arrayList_destroy(bundles);
}
}
}
}
framework_logIfError(bundle->framework->logger, status, NULL, "Failed to create module");
return status;
}
