Project: blueprint-namespaces
/**
 * Licensed to the Apache Software Foundation (ASF) under one 
 * or more contributor license agreements.  See the NOTICE file 
 * distributed with this work for additional information 
 * regarding copyright ownership.  The ASF licenses this file 
 * to you under the Apache License, Version 2.0 (the 
 * "License"); you may not use this file except in compliance 
 * with the License.  You may obtain a copy of the License at 
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, 
 * software distributed under the License is distributed on an 
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
 * KIND, either express or implied.  See the License for the 
 * specific language governing permissions and limitations 
 * under the License. 
 */
package org.apache.aries.blueprint.compendium.cm; 
 
import java.lang.reflect.Method; 
import java.util.Collections; 
import java.util.Dictionary; 
import java.util.HashSet; 
import java.util.Hashtable; 
import java.util.List; 
import java.util.Map; 
import java.util.Properties; 
import java.util.Set; 
import java.util.concurrent.ConcurrentHashMap; 
 
import org.apache.aries.blueprint.BeanProcessor; 
import org.apache.aries.blueprint.ExtendedBlueprintContainer; 
import org.apache.aries.blueprint.ServiceProcessor; 
import org.apache.aries.blueprint.container.ServiceListener; 
import org.apache.aries.blueprint.utils.JavaUtils; 
import org.apache.aries.blueprint.utils.ReflectionUtils; 
import org.apache.aries.util.AriesFrameworkUtil; 
import org.osgi.framework.Bundle; 
import org.osgi.framework.Constants; 
import org.osgi.framework.ServiceReference; 
import org.osgi.framework.ServiceRegistration; 
import org.osgi.service.blueprint.reflect.ServiceMetadata; 
import org.osgi.service.cm.Configuration; 
import org.osgi.service.cm.ConfigurationAdmin; 
import org.osgi.service.cm.ConfigurationException; 
import org.osgi.service.cm.ManagedServiceFactory; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
 
/**
 * TODO: if we need to make those exported services tied to their references as for other <service/> elements 
 * TODO: it becomes a problem as currently we would have to create a specific recipe or something like that 
 * 
 * @version $Rev: 1067207 $, $Date: 2011-02-04 16:13:32 +0000 (Fri, 04 Feb 2011) $ 
 */ 
public class CmManagedServiceFactory { 
 
    static final int CONFIGURATION_ADMIN_OBJECT_DELETED = 1; 
 
    static final int BUNDLE_STOPPING = 2; 
 
    private static final Logger LOGGER = LoggerFactory.getLogger(CmManagedServiceFactory.class); 
     
    private ExtendedBlueprintContainer blueprintContainer; 
    private ConfigurationAdmin configAdmin; 
    private String id; 
    private String factoryPid; 
    private List<String> interfaces; 
    private int autoExport; 
    private int ranking; 
    private Map serviceProperties; 
    private String managedComponentName; 
    private String componentDestroyMethod; 
    private List<ServiceListener> listeners; 
    private final Object lock = new Object(); 
 
    private ServiceRegistration registration; 
    private Map<String, ServiceRegistration> pids = new ConcurrentHashMap<String, ServiceRegistration>(); 
    private Map<ServiceRegistration, Object> services = new ConcurrentHashMap<ServiceRegistration, Object>(); 
 
    public void init() throws Exception { 
        LOGGER.debug("Initializing CmManagedServiceFactory for factoryPid={}", factoryPid); 
        Properties props = new Properties(); 
        props.put(Constants.SERVICE_PID, factoryPid); 
        Bundle bundle = blueprintContainer.getBundleContext().getBundle(); 
        props.put(Constants.BUNDLE_SYMBOLICNAME, bundle.getSymbolicName()); 
        props.put(Constants.BUNDLE_VERSION, bundle.getHeaders().get(Constants.BUNDLE_VERSION)); 
         
        synchronized(lock) { 
            registration = blueprintContainer.getBundleContext().registerService(ManagedServiceFactory.class.getName(), new ConfigurationWatcher(), props); 
         
            String filter = '(' + ConfigurationAdmin.SERVICE_FACTORYPID + '=' + this.factoryPid + ')'; 
            Configuration[] configs = configAdmin.listConfigurations(filter); 
            if (configs != null) { 
                for (Configuration config : configs) { 
                    updated(config.getPid(), config.getProperties()); 
                } 
            } 
        } 
    } 
 
    public void destroy() { 
        AriesFrameworkUtil.safeUnregisterService(registration); 
        for (Map.Entry<ServiceRegistration, Object> entry : services.entrySet()) { 
            destroy(entry.getValue(), entry.getKey(), BUNDLE_STOPPING); 
        } 
        services.clear(); 
        pids.clear(); 
    } 
 
    private void destroy(Object component, ServiceRegistration registration, int code) { 
        if (listeners != null) { 
            ServiceReference ref = registration.getReference(); 
            for (ServiceListener listener : listeners) { 
                Hashtable props = JavaUtils.getProperties(ref); 
                listener.unregister(component, props); 
            } 
        } 
        destroyComponent(component, code); 
        AriesFrameworkUtil.safeUnregisterService(registration); 
    } 
     
    public Map<ServiceRegistration, Object> getServiceMap() { 
        return Collections.unmodifiableMap(services); 
    } 
 
    public void setBlueprintContainer(ExtendedBlueprintContainer blueprintContainer) { 
        this.blueprintContainer = blueprintContainer; 
    } 
 
    public void setConfigAdmin(ConfigurationAdmin configAdmin) { 
        this.configAdmin = configAdmin; 
    } 
 
    public void setListeners(List<ServiceListener> listeners) { 
        this.listeners = listeners; 
    } 
     
    public void setId(String id) { 
        this.id = id; 
    } 
     
    public void setFactoryPid(String factoryPid) { 
        this.factoryPid = factoryPid; 
    } 
 
    public void setInterfaces(List<String> interfaces) { 
        this.interfaces = interfaces; 
    } 
 
    public void setAutoExport(int autoExport) { 
        this.autoExport = autoExport; 
    } 
 
    public void setRanking(int ranking) { 
        this.ranking = ranking; 
    } 
 
    public void setServiceProperties(Map serviceProperties) { 
        this.serviceProperties = serviceProperties; 
    } 
     
    public void setManagedComponentName(String managedComponentName) { 
        this.managedComponentName = managedComponentName; 
    } 
 
    public void setComponentDestroyMethod(String componentDestroyMethod) { 
        this.componentDestroyMethod = componentDestroyMethod; 
    } 
     
    protected void updated(String pid, Dictionary props) { 
        LOGGER.debug("Updated configuration {} with props {}", pid, props); 
        ServiceRegistration reg = pids.get(pid); 
        if (reg == null) {       
            updateComponentProperties(props); 
 
            Object component = blueprintContainer.getComponentInstance(managedComponentName); 
             
            //  TODO: call listeners, etc... 
                     
            Hashtable regProps = getRegistrationProperties(pid);             
            CmProperties cm = findServiceProcessor(); 
            if (cm != null) { 
                if ("".equals(cm.getPersistentId())) { 
                    JavaUtils.copy(regProps, props); 
                } 
                cm.updateProperties(new PropertiesUpdater(pid), regProps); 
            } 
             
            Set<String> classes = getClasses(component); 
            String[] classArray = classes.toArray(new String[classes.size()]); 
            reg = blueprintContainer.getBundleContext().registerService(classArray, component, regProps); 
 
            LOGGER.debug("Service {} registered with interfaces {} and properties {}", new Object [] { component, classes, regProps }); 
             
            services.put(reg, component); 
            pids.put(pid, reg); 
             
            if (listeners != null) { 
                for (ServiceListener listener : listeners) { 
                    listener.register(component, regProps); 
                } 
            } 
        } else { 
            updateComponentProperties(props); 
             
            CmProperties cm = findServiceProcessor(); 
            if (cm != null && "".equals(cm.getPersistentId())) { 
                Dictionary regProps = getRegistrationProperties(pid);     
                JavaUtils.copy(regProps, props); 
                cm.updated(regProps); 
            } 
        } 
    } 
 
    private Hashtable getRegistrationProperties(String pid) { 
        Hashtable regProps = new Hashtable(); 
        if (serviceProperties != null) { 
            regProps.putAll(serviceProperties); 
        } 
        regProps.put(Constants.SERVICE_PID, pid); 
        regProps.put(Constants.SERVICE_RANKING, ranking); 
        return regProps; 
    } 
     
    private void updateComponentProperties(Dictionary props) { 
        CmManagedProperties cm = findBeanProcessor(); 
        if (cm != null) { 
            cm.updated(props); 
        } 
    } 
     
    private CmManagedProperties findBeanProcessor() { 
        for (BeanProcessor beanProcessor : blueprintContainer.getProcessors(BeanProcessor.class)) { 
            if (beanProcessor instanceof CmManagedProperties) { 
                CmManagedProperties cm = (CmManagedProperties) beanProcessor; 
                if (managedComponentName.equals(cm.getBeanName()) && "".equals(cm.getPersistentId())) { 
                    return cm; 
                } 
            } 
        } 
        return null; 
    } 
         
    private CmProperties findServiceProcessor() { 
        for (ServiceProcessor processor : blueprintContainer.getProcessors(ServiceProcessor.class)) { 
            if (processor instanceof CmProperties) { 
                CmProperties cm = (CmProperties) processor; 
                if (id.equals(cm.getServiceId())) { 
                    return cm; 
                } 
            } 
        } 
        return null; 
    } 
         
    private void destroyComponent(Object instance, int reason) { 
        Method method = findDestroyMethod(instance.getClass()); 
        if (method != null) { 
            try { 
                method.invoke(instance, new Object [] { reason }); 
            } catch (Exception e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
     
    private Method findDestroyMethod(Class clazz) { 
        Method method = null;         
        if (componentDestroyMethod != null && componentDestroyMethod.length() > 0) { 
            List<Method> methods = ReflectionUtils.findCompatibleMethods(clazz, componentDestroyMethod, new Class [] { int.class }); 
            if (methods != null && !methods.isEmpty()) { 
                method = methods.get(0); 
            } 
        } 
        return method; 
    } 
     
    protected void deleted(String pid) { 
        LOGGER.debug("Deleted configuration {}", pid); 
        ServiceRegistration reg = pids.remove(pid); 
        if (reg != null) { 
            Object component = services.remove(reg); 
            destroy(component, reg, CONFIGURATION_ADMIN_OBJECT_DELETED); 
        } 
    } 
 
    private Set<String> getClasses(Object service) { 
        Class serviceClass = service.getClass(); 
        Set<String> classes; 
        switch (autoExport) { 
            case ServiceMetadata.AUTO_EXPORT_INTERFACES: 
                classes = ReflectionUtils.getImplementedInterfaces(new HashSet<String>(), serviceClass); 
                break; 
            case ServiceMetadata.AUTO_EXPORT_CLASS_HIERARCHY: 
                classes = ReflectionUtils.getSuperClasses(new HashSet<String>(), serviceClass); 
                break; 
            case ServiceMetadata.AUTO_EXPORT_ALL_CLASSES: 
                classes = ReflectionUtils.getSuperClasses(new HashSet<String>(), serviceClass); 
                classes = ReflectionUtils.getImplementedInterfaces(classes, serviceClass); 
                break; 
            default: 
                classes = new HashSet<String>(interfaces); 
                break; 
        } 
        return classes; 
    } 
     
    private class ConfigurationWatcher implements ManagedServiceFactory { 
 
        public String getName() { 
            return null; 
        } 
 
        public void updated(String pid, Dictionary props) throws ConfigurationException { 
            CmManagedServiceFactory.this.updated(pid, props); 
        } 
 
        public void deleted(String pid) { 
            CmManagedServiceFactory.this.deleted(pid); 
        } 
    } 
 
    private class PropertiesUpdater implements ServiceProcessor.ServicePropertiesUpdater { 
 
        private String pid; 
         
        public PropertiesUpdater(String pid) { 
            this.pid = pid; 
        } 
         
        public String getId() { 
            return id; 
        } 
 
        public void updateProperties(Dictionary properties) { 
            ServiceRegistration reg = pids.get(pid); 
            if (reg != null) { 
                ServiceReference ref = reg.getReference(); 
                if (ref != null) { 
                    Hashtable table = JavaUtils.getProperties(ref); 
                    JavaUtils.copy(table, properties); 
                    reg.setProperties(table); 
                } 
            } 
        } 
    } 
    
}