platform.scripting/src/main/java/org/apache/clerezza/platform/scripting/ScriptEngineFactoryManager.java

/*
 * 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.clerezza.platform.scripting;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.script.ScriptEngineFactory;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.BundleListener;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.component.ComponentContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @scr.component
 *
 * @author hasan
 */
public class ScriptEngineFactoryManager implements BundleListener {

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

    private ComponentContext componentContext = null;

    private Map<Long, List<ServiceRegistration>> registeredFactories =
            new HashMap<Long, List<ServiceRegistration>>();

    private final String SERVICE_DEF_PATH = "/META-INF/services/";
    private final String SERVICE_DEF_FILE = "javax.script.ScriptEngineFactory";

    protected void activate(final ComponentContext componentContext) {
        this.componentContext = componentContext;
        registerExistingEngineFactories();
        componentContext.getBundleContext().addBundleListener(this);
    }

    private void registerExistingEngineFactories() {
        if (componentContext == null) {
            logger.warn("componentContext is null while trying to register" +
                    "script engine factories in started bundles");
            return;
        }
        Bundle[] bundles = componentContext.getBundleContext().getBundles();
        for (Bundle bundle : bundles) {
            if (bundle.getState() == Bundle.ACTIVE) {
                List<String> engineFactoryNames = getEngineFactoryNames(bundle);
                registerEngineFactories(bundle, engineFactoryNames);
            }
        }
    }

    private List<String> getEngineFactoryNames(Bundle bundle) {
        List<String> engineFactoryNames = new ArrayList<String>();
        BufferedReader in = null;
        try {
            URL entry = bundle.getEntry(SERVICE_DEF_PATH+SERVICE_DEF_FILE);
            if (entry == null) {
                return null;
            }
            in = new BufferedReader(new InputStreamReader(entry.openStream()));
            String engineFactoryName;
            while ((engineFactoryName = in.readLine()) != null) {
                engineFactoryName = engineFactoryName.trim();
                if (!engineFactoryName.isEmpty()) {
                    engineFactoryNames.add(engineFactoryName);
                }
            }
            in.close();
        } catch (IOException ex) {
            // ignored, since this bundle seems to not contain a script engine
            logger.info("Cannot read {} in bundle {}",
                    SERVICE_DEF_PATH + SERVICE_DEF_FILE, bundle.getSymbolicName());
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException ex) {
                    // ignored
                }
            }
        }
        return engineFactoryNames;
    }

    private void registerEngineFactories(Bundle bundle, List<String> engineFactoryNames) {
        if (engineFactoryNames == null || engineFactoryNames.isEmpty()) {
            return;
        }
        List<ServiceRegistration> serviceRegList = new ArrayList<ServiceRegistration>();
        for (String engineFactoryName : engineFactoryNames) {
            try {
                Class factoryClass = Class.forName(engineFactoryName);
                ScriptEngineFactory factory = (ScriptEngineFactory) factoryClass.newInstance();
                String[] clazzes = {engineFactoryName, SERVICE_DEF_FILE};
                ServiceRegistration serviceReg = componentContext.getBundleContext().registerService(clazzes, factory, null);
                serviceRegList.add(serviceReg);

                if (engineFactoryName.equals("com.sun.script.jruby.JRubyScriptEngineFactory")) {
                    factory = new JRubyScriptEngineFactoryWrapper(
                            (ScriptEngineFactory) factoryClass.newInstance());
                    String[] wrappedClazzes = {
                        "org.apache.clerezza.platform.scripting.JRubyScriptEngineFactoryWrapper",
                        SERVICE_DEF_FILE
                    };
                    serviceRegList.add(componentContext.getBundleContext().registerService(wrappedClazzes, factory, null));
                }

            } catch (InstantiationException ex) {
                logger.warn("Cannot instantiate {}", engineFactoryName);
                throw new RuntimeException(ex);
            } catch (IllegalAccessException ex) {
                throw new RuntimeException(ex);
            } catch (ClassNotFoundException ex) {
                logger.warn("Cannot find class {}", engineFactoryName);
                throw new RuntimeException(ex);
            }
        }
        long bundleId = bundle.getBundleId();
        registeredFactories.put(bundleId, serviceRegList);
    }

    protected void deactivate(final ComponentContext componentContext) {
        deregisterEngineFactories();
        componentContext.getBundleContext().removeBundleListener(this);
        this.componentContext = null;
    }

    private void deregisterEngineFactories() {
        Iterator<List<ServiceRegistration>> serviceRegLists =
                registeredFactories.values().iterator();
        while (serviceRegLists.hasNext()) {
            for (ServiceRegistration serviceReg : serviceRegLists.next()) {
                serviceReg.unregister();
            }
        }
        registeredFactories.clear();
    }

    @Override
    public void bundleChanged(BundleEvent event) {
        Bundle bundle = event.getBundle();
        switch (event.getType()) {
            case BundleEvent.STARTED:
                registerEngineFactories(bundle, getEngineFactoryNames(bundle));
                break;
            case BundleEvent.STOPPED:
                long bundleId = bundle.getBundleId();
                List<ServiceRegistration> serviceRegList = registeredFactories.get(bundleId);
                if (serviceRegList != null && !serviceRegList.isEmpty()) {
                    for (ServiceRegistration serviceReg : serviceRegList) {
                        serviceReg.unregister();
                    }
                    registeredFactories.remove(bundleId);
                }
                break;
        }
    }
}