// org.eclipse.equinox.internal.cm modified to fit with org.apache.felix.cm.impl
// change due to ConfigurationStore implementation
celix_status_t configuration_getAllProperties(configuration_impl_pt configuration, properties_pt *properties) {
celix_status_t status;
properties_pt copy = NULL;
// (1) configuration.lock
configuration_lock(configuration);
// (2) configuration.deleted ?
if( configuration->deleted ) {
*properties = NULL;
configuration_unlock(configuration);
return CELIX_SUCCESS;
}
// (3) configuration.getProps
if( configuration_getProperties(configuration, ©) != CELIX_SUCCESS) {
configuration_unlock(configuration);
return CELIX_ILLEGAL_ARGUMENT;
}
// (4) configuration.setProperties
if ( copy == NULL ) { //set all the automatic properties
copy = properties_create();
status = configuration_setAutoProperties(configuration, ©, true);
} else { // copy != NULL - only set service.bundleLocation
status = configuration_setBundleLocationProperty(configuration, ©);
}
// (5) return
if (status == CELIX_SUCCESS) {
*properties = copy;
} else {
*properties = NULL;
}
configuration_unlock(configuration);
return status;
}
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;
}
// org.eclipse.equinox.internal.cm.ManagedServiceTracker
celix_status_t managedServiceTracker_add(managed_service_tracker_pt tracker, service_reference_pt reference, char *pid, managed_service_service_pt service) {
celix_status_t status;
bundle_pt bundle = NULL;
const char* bundleLocation;
configuration_pt configuration = NULL;
properties_pt properties = NULL;
configurationStore_findConfiguration(tracker->configurationStore, pid, &configuration);
if (configuration == NULL) {
if (managedServiceTracker_trackManagedService(tracker, pid, reference, service) == CELIX_SUCCESS) {
// TODO : this is new code, it hasn't been tested yet
if (serviceReference_getBundle(reference, &bundle) != CELIX_SUCCESS) {
return CELIX_ILLEGAL_ARGUMENT;
}
if (bundle_getBundleLocation(bundle, &bundleLocation) != CELIX_SUCCESS) {
return CELIX_ILLEGAL_ARGUMENT;
}
// (1) creates a new Configuration for the ManagedService
if (configurationStore_getConfiguration(tracker->configurationStore, pid, (char*)bundleLocation, &configuration) != CELIX_SUCCESS || configuration == NULL) {
return CELIX_ILLEGAL_ARGUMENT;
}
// (2) bind the Configuration with the ManagedService
bool dummy;
if ((configuration_bind(configuration->handle, bundle, &dummy) != CELIX_SUCCESS)) {
return CELIX_ILLEGAL_ARGUMENT;
}
// (3) the new Configuration is persisted and visible for other ConfigAdmin instances
if (configurationStore_saveConfiguration(tracker->configurationStore, pid, configuration) != CELIX_SUCCESS) {
return CELIX_ILLEGAL_STATE;
}
// End of new code
// TODO: It must be considered in case of fail if untrack the ManagedService
return managedServiceTracker_asynchUpdated(tracker, service, NULL);
} else {
return CELIX_ILLEGAL_ARGUMENT; // the service was already tracked
}
} else {
configuration_lock(configuration->handle);
if (managedServiceTracker_trackManagedService(tracker, pid, reference, service) == CELIX_SUCCESS) {
if (serviceReference_getBundle(reference, &bundle) != CELIX_SUCCESS) {
configuration_unlock(configuration->handle);
printf("[ERROR ]: Tracker - Add (Service{PID=%s} Reference - getBundle NULL)", pid);
return CELIX_ILLEGAL_ARGUMENT;
}
// TODO configuration.isDeleted ? - with only using one calling bundle OK
bool isBind;
if ((configuration_bind(configuration->handle, bundle, &isBind) == CELIX_SUCCESS) && (isBind == true)) { // config.bind(bundle)
if (configuration_getProperties(configuration->handle, &properties) != CELIX_SUCCESS) {
configuration_unlock(configuration->handle);
return CELIX_ILLEGAL_ARGUMENT;
}
if (configurationAdminFactory_modifyConfiguration(tracker->configurationAdminfactory, reference, properties) != CELIX_SUCCESS) {
configuration_unlock(configuration->handle);
return CELIX_ILLEGAL_ARGUMENT;
}
status = managedServiceTracker_asynchUpdated(tracker, service, properties);
configuration_unlock(configuration->handle);
return status;
} else {
configuration_unlock(configuration->handle);
return CELIX_ILLEGAL_STATE;
}
} else {
configuration_unlock(configuration->handle);
return CELIX_ILLEGAL_ARGUMENT; // the service was already tracked
}
}
}
