ServiceBundleContextRegistrar.java

package com.github.dynamicextensionsalfresco.osgi;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

import org.alfresco.service.descriptor.Descriptor;
import org.alfresco.service.descriptor.DescriptorService;
import org.alfresco.util.VersionNumber;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

/**
 * Registers beans from an {@link ApplicationContext} as services in a {@link BundleContext}.
 * 
 * @author Laurens Fridael
 * 
 */
@Service
public class ServiceBundleContextRegistrar implements BundleContextRegistrar, ApplicationContextAware {

	/* Service property */
	private static final String ALFRESCO_SERVICE_TYPE = "alfresco.service.type";

	/* Service property for the Blueprint component name. */
	private static final String OSGI_SERVICE_BLUEPRINT_COMPNAME = "osgi.service.blueprint.compname";

	private final Logger logger = LoggerFactory.getLogger(getClass());

	/* Dependencies */

	private ApplicationContext applicationContext;

	private DescriptorService descriptorService;

	/* Configuration */

	private List<ServiceDefinition> serviceDefinitions = Collections.emptyList();

	private List<ServicePropertiesProvider> servicePropertiesProviders = Collections.emptyList();

	private final List<ServiceRegistration<?>> serviceRegistrations = new ArrayList<ServiceRegistration<?>>();

	/* Operations */

	@Override
	public List<ServiceRegistration<?>> registerInBundleContext(final BundleContext bundleContext) {
		Assert.notNull(bundleContext, "BundleContext cannot be null.");

		final Descriptor descriptor = getDescriptorService().getServerDescriptor();
		if (descriptor == null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Could not obtain Descriptor. This is normal when running an integration test.");
			}
		}

		for (final ServiceDefinition serviceDefinition : getServiceDefinitions()) {
			int serviceRanking = 0;
			for (final String beanName : serviceDefinition.getBeanNames()) {
				final List<String> serviceNames = serviceDefinition.getServiceNames();
				final String requiredPlatformVersion = serviceDefinition.getPlatformVersion();
				if (StringUtils.hasText(requiredPlatformVersion)) {
					final VersionNumber versionNumber = new VersionNumber(requiredPlatformVersion);
					if (descriptor != null && versionNumber.compareTo(descriptor.getVersionNumber()) > 0) {
						if (logger.isDebugEnabled()) {
							logger.debug(
									"Skipping registration of ServiceDefinitions {} because they require Alfresco version {}",
									serviceNames, requiredPlatformVersion);
						}
						continue;
					}
				}
				if (getApplicationContext().containsBean(beanName) == false) {
					if (logger.isWarnEnabled()) {
						logger.warn(
								"Could not find service \"{}\". This service will not be registered in the OSGI container.",
								beanName);
					}
					continue;
				}
				if (getApplicationContext().isSingleton(beanName) == false) {
					if (logger.isWarnEnabled()) {
						logger.warn(String.format(
								"Service \"%s\" is not a singleton. Can only register singleton beans.", beanName));
					}
					continue;
				}
				final Object service = getApplicationContext().getBean(beanName);
				if (service == null) {
					if (logger.isWarnEnabled()) {
						logger.warn("Cannot find bean '{}'", beanName);
					}
					continue;
				}
				try {
					final ServiceRegistration<?> serviceRegistration = registerService(bundleContext, service,
							serviceNames, beanName, serviceDefinition.getServiceType(), serviceRanking);
					serviceRanking -= 1;
					serviceRegistrations.add(serviceRegistration);
				} catch (final RuntimeException e) {
					logger.error("Could not register bean \"{} \" as service", beanName);
				}
			}
		}
		if (logger.isInfoEnabled()) {
			logger.info("Registered {} OSGI services.", serviceRegistrations.size());
		}
		return Collections.unmodifiableList(serviceRegistrations);
	}

	protected ServiceRegistration<?> registerService(final BundleContext bundleContext, final Object service,
			final List<String> serviceNames, final String beanName, final String serviceType, final int serviceRanking) {
		Assert.notNull(service, "Service cannot be null.");
		Assert.notEmpty(serviceNames, "Service names cannot be empty.");

		final Hashtable<String, Object> serviceProperties = new Hashtable<String, Object>();
		serviceProperties.put(OSGI_SERVICE_BLUEPRINT_COMPNAME, beanName);
		serviceProperties.put("hostApplication", "alfresco");
		if (StringUtils.hasText(serviceType)) {
			serviceProperties.put(ALFRESCO_SERVICE_TYPE, serviceType);
		}
		serviceProperties.put(Constants.SERVICE_RANKING, serviceRanking);
		for (final ServicePropertiesProvider servicePropertiesProvider : getServicePropertiesProviders()) {
			final Map<String, Object> props = servicePropertiesProvider.getServiceProperties(service, serviceNames);
			if (CollectionUtils.isEmpty(props) == false) {
				serviceProperties.putAll(props);
			}
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Registering bean \"{}\" under service names {} with properties {}", beanName,
                serviceNames, serviceProperties);
		}
        return bundleContext.registerService(
                serviceNames.toArray(new String[serviceNames.size()]), service, serviceProperties);
	}

	public void unregisterFromBundleContext() {
		for (final ServiceRegistration<?> serviceRegistration : serviceRegistrations) {
			try {
				if (logger.isDebugEnabled()) {
					logger.debug("Unregistering service: {}",
							serviceRegistration.getReference().getProperty(Constants.OBJECTCLASS));
				}
				serviceRegistration.unregister();
			} catch (final RuntimeException e) {
				logger.error("Error unregistering service.", e);
			}
		}
		serviceRegistrations.clear();
	}

	/* Dependencies */

	@Override
	public void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
	}

	protected ApplicationContext getApplicationContext() {
		return applicationContext;
	}

	public void setDescriptorService(final DescriptorService descriptorService) {
		this.descriptorService = descriptorService;
	}

	protected DescriptorService getDescriptorService() {
		return descriptorService;
	}

	/* Configuration */

	@Required
	public void setServiceDefinitions(final List<ServiceDefinition> serviceDefinitions) {
		Assert.notNull(serviceDefinitions);
		this.serviceDefinitions = serviceDefinitions;
	}

	protected List<ServiceDefinition> getServiceDefinitions() {
		return serviceDefinitions;
	}

	public void setServicePropertiesProviders(final List<ServicePropertiesProvider> servicePropertiesProviders) {
		Assert.notNull(servicePropertiesProviders);
		this.servicePropertiesProviders = servicePropertiesProviders;
	}

	protected List<ServicePropertiesProvider> getServicePropertiesProviders() {
		return servicePropertiesProviders;
	}

}