src/main/java/org/apache/sling/scripting/core/impl/jsr223/SlingScriptEngineManager.java - sling-org-apache-sling-scripting-core - Git at Google

 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  ~ 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.sling.scripting.core.impl.jsr223;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Dictionary;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;

 import javax.script.ScriptEngine;
 import javax.script.ScriptEngineFactory;
 import javax.script.ScriptEngineManager;

 import org.apache.sling.api.scripting.SlingScriptConstants;
 import org.apache.sling.commons.osgi.PropertiesUtil;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.BundleEvent;
 import org.osgi.framework.BundleListener;
 import org.osgi.framework.Constants;
 import org.osgi.framework.ServiceReference;
 import org.osgi.framework.wiring.BundleWiring;
 import org.osgi.service.component.annotations.Activate;
 import org.osgi.service.component.annotations.Component;
 import org.osgi.service.component.annotations.Deactivate;
 import org.osgi.service.component.annotations.Reference;
 import org.osgi.service.component.annotations.ReferenceCardinality;
 import org.osgi.service.component.annotations.ReferencePolicy;
 import org.osgi.service.component.annotations.ReferencePolicyOption;
 import org.osgi.service.event.Event;
 import org.osgi.service.event.EventAdmin;
 import org.osgi.service.metatype.annotations.AttributeDefinition;
 import org.osgi.service.metatype.annotations.Designate;
 import org.osgi.service.metatype.annotations.ObjectClassDefinition;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 @Component(
     service = {
         ScriptEngineManager.class,
         SlingScriptEngineManager.class
     },
     reference = @Reference(
         name = "ScriptEngineFactory",
         bind = "bindScriptEngineFactory",
         unbind = "unbindScriptEngineFactory",
         updated = "updatedScriptEngineFactory",
         service = ScriptEngineFactory.class,
         cardinality = ReferenceCardinality.MULTIPLE,
         policy = ReferencePolicy.DYNAMIC
     )
 )
 @Designate(ocd=SlingScriptEngineManager.Config.class)
 public class SlingScriptEngineManager extends ScriptEngineManager implements BundleListener {

     @ObjectClassDefinition(name ="Apache Sling Script Engine Manager",
             description="Configures options for the Script Engine Manager")
     public @interface Config {

         @AttributeDefinition(name = "Includes", description = "A script engine with a short name that matches any of these expressions is included")
         String[] includes() default {".*"};

         @AttributeDefinition(name = "Excludes", description = "A script engine with a short name that matches any of these (optional) expressions is NOT included, even if it was accepted by the 'Includes' configuration")
         String[] excludes();

     }

     private ScriptEngineManager internalManager;

     private final Set<Bundle> engineSpiBundles = new HashSet<>();

     private final Set<ServiceReference<ScriptEngineFactory>> serviceReferences = new HashSet<>();

     private final SortedSet<SortableScriptEngineFactory> factories = new TreeSet<>();

     private BundleContext bundleContext;

     @Reference(
         policy = ReferencePolicy.DYNAMIC,
         policyOption = ReferencePolicyOption.GREEDY,
         cardinality = ReferenceCardinality.OPTIONAL
     )
     private volatile EventAdmin eventAdmin;

     static final String EVENT_TOPIC_SCRIPT_MANAGER_UPDATED = "org/apache/sling/scripting/core/impl/jsr223/SlingScriptEngineManager/UPDATED";

     static final String META_INF_SERVICES = "META-INF/services";
     static final String FACTORY_NAME = ScriptEngineFactory.class.getName();

     private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

     private final Logger logger = LoggerFactory.getLogger(SlingScriptEngineManager.class);

     private Set<Pattern> includePatterns = Collections.emptySet();
     private Set<Pattern> excludePatterns = Collections.emptySet();

     @Override
     public ScriptEngine getEngineByName(String shortName) {
         readWriteLock.readLock().lock();
         try {
             SortableScriptEngineFactory ssef = factories.stream()
                 .filter(factory -> factory.getNames().contains(shortName))
                 .findFirst()
                 .orElse(null);
             return ssef == null ? null : ssef.getScriptEngine();
         } finally {
             readWriteLock.readLock().unlock();
         }
     }

     public List<ScriptEngine> getEnginesByName(final String shortName) {
         readWriteLock.readLock().lock();
         try {
             return factories.stream()
                                    // first, check exact match of short names
                 .filter(factory -> factory.getNames().contains(shortName) ||
                                    // then, check contains match of long name
                                    //   for backward compatibility
                                    factory.getEngineName().contains(shortName))
                 .map(factory -> factory.getDelegate().getScriptEngine())
                 .collect(Collectors.toList());
         } finally {
             readWriteLock.readLock().unlock();
         }
     }

     @Override
     public ScriptEngine getEngineByExtension(String extension) {
         readWriteLock.readLock().lock();
         try {
             SortableScriptEngineFactory ssef = factories.stream()
                     .filter(factory -> factory.getExtensions().contains(extension))
                     .findFirst()
                     .orElse(null);
             return ssef == null ? null : ssef.getScriptEngine();
         } finally {
             readWriteLock.readLock().unlock();
         }
     }

     public List<ScriptEngine> getEnginesByExtension(final String extension) {
         readWriteLock.readLock().lock();
         try {
             return factories.stream()
                 .filter(factory -> factory.getExtensions().contains(extension))
                 .map(factory -> factory.getDelegate().getScriptEngine())
                 .collect(Collectors.toList());
         } finally {
             readWriteLock.readLock().unlock();
         }
     }

     @Override
     public ScriptEngine getEngineByMimeType(String mimeType) {
         readWriteLock.readLock().lock();
         try {
             SortableScriptEngineFactory ssef = factories.stream()
                     .filter(factory -> factory.getMimeTypes().contains(mimeType))
                     .findFirst()
                     .orElse(null);
             return ssef == null ? null : ssef.getScriptEngine();
         } finally {
             readWriteLock.readLock().unlock();
         }
     }

     public List<ScriptEngine> getEnginesByMimeType(final String mimeType) {
         readWriteLock.readLock().lock();
         try {
             return factories.stream()
                 .filter(factory -> factory.getMimeTypes().contains(mimeType))
                 .map(factory -> factory.getDelegate().getScriptEngine())
                 .collect(Collectors.toList());
         } finally {
             readWriteLock.readLock().unlock();
         }
     }

     @Override
     public List<ScriptEngineFactory> getEngineFactories() {
         readWriteLock.readLock().lock();
         try {
             ArrayList<ScriptEngineFactory> list = new ArrayList<>(factories.size());
             list.addAll(factories);
             return Collections.unmodifiableList(list);
         } finally {
             readWriteLock.readLock().unlock();
         }
     }

     @Override
     public void registerEngineName(String name, ScriptEngineFactory factory) {
         readWriteLock.writeLock().lock();
         try {
             internalManager.registerEngineName(name, factory);
         } finally {
             readWriteLock.writeLock().unlock();
         }
     }

     @Override
     public void registerEngineMimeType(String type, ScriptEngineFactory factory) {
         readWriteLock.writeLock().lock();
         try {
             internalManager.registerEngineMimeType(type, factory);
         } finally {
             readWriteLock.writeLock().unlock();
         }
     }

     @Override
     public void registerEngineExtension(String extension, ScriptEngineFactory factory) {
         readWriteLock.writeLock().lock();
         try {
             internalManager.registerEngineExtension(extension, factory);
         } finally {
             readWriteLock.writeLock().unlock();
         }
     }

     @Override
     public void bundleChanged(BundleEvent event) {
         if (event.getType() == BundleEvent.STARTED
                 && event.getBundle().getBundleId() > 0
                    // SLING-11398 - use findEntries instead of getEntry to support fragments
                 && event.getBundle().findEntries(META_INF_SERVICES, FACTORY_NAME, false) != null) {
             synchronized (this.engineSpiBundles) {
                 this.engineSpiBundles.add(event.getBundle());
             }
             updateFactories();
         } else if (event.getType() == BundleEvent.STOPPED) {
             boolean refresh;
             synchronized (this.engineSpiBundles) {
                 refresh = this.engineSpiBundles.remove(event.getBundle());
             }
             if (refresh) {
                 updateFactories();
             }
         }
     }

     public Map<String, Object> getServiceProperties(final ScriptEngineFactory factory) {
         readWriteLock.readLock().lock();
         try {
             return factories.stream().filter(f -> f.getDelegate().equals(factory)).findFirst().map(SortableScriptEngineFactory::getServiceProperties).orElse(null);
         } finally {
             readWriteLock.readLock().unlock();
         }
     }

     @Activate
     private void activate(final Config config, final BundleContext bundleContext) {
         String[] includes = config.includes();
         if (includes == null) {
             this.includePatterns = Collections.emptySet();
         } else {
             this.includePatterns = new HashSet<>();
             for (String pattern : includes) {
                 if (!pattern.isEmpty()) {
                     Pattern p = Pattern.compile(pattern);
                     includePatterns.add(p);
                 }
             }
         }

         String[] excludes = config.excludes();
         if (excludes == null) {
             this.excludePatterns = Collections.emptySet();
         } else {
             this.excludePatterns = new HashSet<>();
             for (String pattern : excludes) {
                 if (!pattern.isEmpty()) {
                     Pattern p = Pattern.compile(pattern);
                     excludePatterns.add(p);
                 }
             }
         }

         this.bundleContext = bundleContext;
         bundleContext.addBundleListener(this);
         registerInitialScriptEngineFactories();
     }

     /**
      * Handles any spi bundles that were already started before we started listening
      */
     private void registerInitialScriptEngineFactories() {
         Bundle[] bundles = this.bundleContext.getBundles();
         for (Bundle bundle : bundles) {
             if (bundle.getState() == Bundle.ACTIVE
                     && bundle.getBundleId() > 0
                     && bundle.findEntries(META_INF_SERVICES, FACTORY_NAME, false) != null) {
                 synchronized (this.engineSpiBundles) {
                     this.engineSpiBundles.add(bundle);
                 }
             }
         }
         updateFactories();
     }

     /**
      * Check if the given factory matches any of the include/excludes patterns
      *
      * @param sef the factory to check
      * @return true if included, false otherwise
      */
     private boolean isIncluded(ScriptEngineFactory sef) {
         boolean include = false;

         if (!this.includePatterns.isEmpty()) {
             List<String> names = sef.getNames();
             for (String name : names) {
                 for (Pattern p : this.includePatterns) {
                     if (p.matcher(name).matches()) {
                         include = true;
                         if (logger.isDebugEnabled()) {
                             logger.debug("ScriptEngineFactory \"{}\" matches the include pattern \"{}\" for name \"{}\"", sef.getEngineName(), p.pattern(), name);
                         }
                         break; // found a match so stop looking further
                     }
                 }
                 if (include) {
                     break; // break out of the outer loop too
                 }
             }
         }

         if (include && !this.excludePatterns.isEmpty()) {
             List<String> names = sef.getNames();
             for (String name : names) {
                 for (Pattern p : this.excludePatterns) {
                     if (p.matcher(name).matches()) {
                         include = false;
                         if (logger.isDebugEnabled()) {
                             logger.debug("ScriptEngineFactory \"{}\" matches the exclude pattern \"{}\" for name \"{}\" so it is not included", sef.getEngineName(), p.pattern(), name);
                         }
                         break; // found a match so stop looking further
                     }
                 }
                 if (!include) {
                     break; // break out of the outer loop too
                 }
             }
         }
         return include;
     }

     @Deactivate
     private void deactivate(final BundleContext bundleContext) {
         bundleContext.removeBundleListener(this);
     }

     @SuppressWarnings("unused")
     private void bindScriptEngineFactory(final ServiceReference<ScriptEngineFactory> serviceReference, final ScriptEngineFactory factory) {
         synchronized (this.serviceReferences) {
             serviceReferences.add(serviceReference);
         }
         updateFactories();
         postEvent(SlingScriptConstants.TOPIC_SCRIPT_ENGINE_FACTORY_ADDED, factory);
     }

     @SuppressWarnings("unused")
     private void unbindScriptEngineFactory(final ServiceReference<ScriptEngineFactory> serviceReference, final ScriptEngineFactory factory) {
         synchronized (this.serviceReferences) {
             serviceReferences.remove(serviceReference);
             if (bundleContext != null) {
                 bundleContext.ungetService(serviceReference);
             }
         }
         updateFactories();
         postEvent(SlingScriptConstants.TOPIC_SCRIPT_ENGINE_FACTORY_REMOVED, factory);
     }

     @SuppressWarnings("unused")
     private void updatedScriptEngineFactory(final ServiceReference<ScriptEngineFactory> serviceReference, final ScriptEngineFactory factory) {
         updateFactories();
         postEvent(SlingScriptConstants.TOPIC_SCRIPT_ENGINE_FACTORY_UPDATED, factory);
     }

     private void updateFactories() {
         readWriteLock.writeLock().lock();
         try {
             internalManager = getInternalScriptEngineManager();
             factories.clear();

             long fakeBundleIdCounter = Long.MIN_VALUE;
             // first add the platform factories
             for (final ScriptEngineFactory factory : internalManager.getEngineFactories()) {
                 if (isIncluded(factory)) {
                     final SortableScriptEngineFactory sortableScriptEngineFactory = new SortableScriptEngineFactory(factory, fakeBundleIdCounter++, 0, null);
                     factories.add(sortableScriptEngineFactory);
                 }
             }

             // then factories from SPI Bundles
             final ClassLoader loader = Thread.currentThread().getContextClassLoader();
             try {
                 Thread.currentThread().setContextClassLoader(null);
                 for (final Bundle bundle : engineSpiBundles) {
                     try {
                         final ScriptEngineManager manager = new ScriptEngineManager(bundle.adapt(BundleWiring.class).getClassLoader());
                         for (final ScriptEngineFactory factory : manager.getEngineFactories()) {
                             if (isIncluded(factory)) {
                                 final SortableScriptEngineFactory sortableScriptEngineFactory = new SortableScriptEngineFactory(factory, bundle.getBundleId(), 0, null);
                                 factories.add(sortableScriptEngineFactory);
                             }
                         }
                     } catch (Exception ex) {
                         logger.error("Unable to process bundle " + bundle.getSymbolicName(), ex);
                     }
                 }
             }
             finally {
                 Thread.currentThread().setContextClassLoader(loader);
             }
             // and finally factories registered as OSGi services
             if (bundleContext != null) {
                 synchronized (this.serviceReferences) {
                     for (final ServiceReference<ScriptEngineFactory> serviceReference : serviceReferences) {
                         final ScriptEngineFactory scriptEngineFactory = bundleContext.getService(serviceReference);
                         if (isIncluded(scriptEngineFactory)) {
                             final Map<String, Object> factoryProperties = new HashMap<>(serviceReference.getPropertyKeys().length);
                             for (final String key : serviceReference.getPropertyKeys()) {
                                 factoryProperties.put(key, serviceReference.getProperty(key));
                             }
                             final SortableScriptEngineFactory sortableScriptEngineFactory = new SortableScriptEngineFactory(scriptEngineFactory, serviceReference.getBundle().getBundleId(), PropertiesUtil.toInteger(serviceReference.getProperty(Constants.SERVICE_RANKING), 0), factoryProperties);
                             factories.add(sortableScriptEngineFactory);
                         }
                     }
                 }
             }
             // register the associations at the end, so that the priority sorting is taken into consideration
             for (final ScriptEngineFactory factory : factories) {
                 registerAssociations(factory);
             }
             if (eventAdmin != null) {
                 eventAdmin.postEvent(new Event(EVENT_TOPIC_SCRIPT_MANAGER_UPDATED, Collections.emptyMap()));
             }
         } finally {
             readWriteLock.writeLock().unlock();
         }
     }

     private ScriptEngineManager getInternalScriptEngineManager() {
         final ClassLoader loader = Thread.currentThread().getContextClassLoader();
         try {
             Thread.currentThread().setContextClassLoader(null);
             return new ScriptEngineManager(ClassLoader.getSystemClassLoader());
         }
         finally {
             Thread.currentThread().setContextClassLoader(loader);
         }
     }

     private void registerAssociations(ScriptEngineFactory factory) {
         for (String extension : factory.getExtensions()) {
             if (extension != null && !extension.isEmpty()) {
                 internalManager.registerEngineExtension(extension, factory);
             } else {
                 logger.warn("Could not register an empty or null extension for script engine factory {}.", factory.getEngineName());
             }
         }
         for (String mimeType : factory.getMimeTypes()) {
             if (mimeType != null && !mimeType.isEmpty()) {
                 internalManager.registerEngineMimeType(mimeType, factory);
             } else {
                 logger.warn("Could not register an empty or null mime type for script engine factory {}.", factory.getEngineName());
             }
         }
         for (String name : factory.getNames()) {
             if (name != null && !name.isEmpty()) {
                 internalManager.registerEngineName(name, factory);
             } else {
                 logger.warn("Could not register an empty or null engine name for script engine factory {}.", factory.getEngineName());
             }
         }
     }

     private void postEvent(final String topic, final ScriptEngineFactory scriptEngineFactory) {
         if (eventAdmin != null) {
             final Dictionary<String, Object> props = new Hashtable<>();
             props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_NAME, scriptEngineFactory.getEngineName());
             props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_VERSION, scriptEngineFactory.getEngineVersion());
             props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_EXTENSIONS, scriptEngineFactory.getExtensions().toArray(new String[0]));
             props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_LANGUAGE_NAME, scriptEngineFactory.getLanguageName());
             props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_LANGUAGE_VERSION, scriptEngineFactory.getLanguageVersion());
             props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_MIME_TYPES, scriptEngineFactory.getMimeTypes().toArray(new String[0]));
             eventAdmin.postEvent(new Event(topic, props));
         }
     }

 }
	/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	~ 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.sling.scripting.core.impl.jsr223;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Dictionary;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Hashtable;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.SortedSet;
	import java.util.TreeSet;
	import java.util.concurrent.locks.ReentrantReadWriteLock;
	import java.util.regex.Pattern;
	import java.util.stream.Collectors;

	import javax.script.ScriptEngine;
	import javax.script.ScriptEngineFactory;
	import javax.script.ScriptEngineManager;

	import org.apache.sling.api.scripting.SlingScriptConstants;
	import org.apache.sling.commons.osgi.PropertiesUtil;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.BundleContext;
	import org.osgi.framework.BundleEvent;
	import org.osgi.framework.BundleListener;
	import org.osgi.framework.Constants;
	import org.osgi.framework.ServiceReference;
	import org.osgi.framework.wiring.BundleWiring;
	import org.osgi.service.component.annotations.Activate;
	import org.osgi.service.component.annotations.Component;
	import org.osgi.service.component.annotations.Deactivate;
	import org.osgi.service.component.annotations.Reference;
	import org.osgi.service.component.annotations.ReferenceCardinality;
	import org.osgi.service.component.annotations.ReferencePolicy;
	import org.osgi.service.component.annotations.ReferencePolicyOption;
	import org.osgi.service.event.Event;
	import org.osgi.service.event.EventAdmin;
	import org.osgi.service.metatype.annotations.AttributeDefinition;
	import org.osgi.service.metatype.annotations.Designate;
	import org.osgi.service.metatype.annotations.ObjectClassDefinition;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	@Component(
	service = {
	ScriptEngineManager.class,
	SlingScriptEngineManager.class
	},
	reference = @Reference(
	name = "ScriptEngineFactory",
	bind = "bindScriptEngineFactory",
	unbind = "unbindScriptEngineFactory",
	updated = "updatedScriptEngineFactory",
	service = ScriptEngineFactory.class,
	cardinality = ReferenceCardinality.MULTIPLE,
	policy = ReferencePolicy.DYNAMIC
	)
	)
	@Designate(ocd=SlingScriptEngineManager.Config.class)
	public class SlingScriptEngineManager extends ScriptEngineManager implements BundleListener {

	@ObjectClassDefinition(name ="Apache Sling Script Engine Manager",
	description="Configures options for the Script Engine Manager")
	public @interface Config {

	@AttributeDefinition(name = "Includes", description = "A script engine with a short name that matches any of these expressions is included")
	String[] includes() default {".*"};

	@AttributeDefinition(name = "Excludes", description = "A script engine with a short name that matches any of these (optional) expressions is NOT included, even if it was accepted by the 'Includes' configuration")
	String[] excludes();

	}

	private ScriptEngineManager internalManager;

	private final Set<Bundle> engineSpiBundles = new HashSet<>();

	private final Set<ServiceReference<ScriptEngineFactory>> serviceReferences = new HashSet<>();

	private final SortedSet<SortableScriptEngineFactory> factories = new TreeSet<>();

	private BundleContext bundleContext;

	@Reference(
	policy = ReferencePolicy.DYNAMIC,
	policyOption = ReferencePolicyOption.GREEDY,
	cardinality = ReferenceCardinality.OPTIONAL
	)
	private volatile EventAdmin eventAdmin;

	static final String EVENT_TOPIC_SCRIPT_MANAGER_UPDATED = "org/apache/sling/scripting/core/impl/jsr223/SlingScriptEngineManager/UPDATED";

	static final String META_INF_SERVICES = "META-INF/services";
	static final String FACTORY_NAME = ScriptEngineFactory.class.getName();

	private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

	private final Logger logger = LoggerFactory.getLogger(SlingScriptEngineManager.class);

	private Set<Pattern> includePatterns = Collections.emptySet();
	private Set<Pattern> excludePatterns = Collections.emptySet();

	@Override
	public ScriptEngine getEngineByName(String shortName) {
	readWriteLock.readLock().lock();
	try {
	SortableScriptEngineFactory ssef = factories.stream()
	.filter(factory -> factory.getNames().contains(shortName))
	.findFirst()
	.orElse(null);
	return ssef == null ? null : ssef.getScriptEngine();
	} finally {
	readWriteLock.readLock().unlock();
	}
	}

	public List<ScriptEngine> getEnginesByName(final String shortName) {
	readWriteLock.readLock().lock();
	try {
	return factories.stream()
	// first, check exact match of short names
	.filter(factory -> factory.getNames().contains(shortName) \|\|
	// then, check contains match of long name
	// for backward compatibility
	factory.getEngineName().contains(shortName))
	.map(factory -> factory.getDelegate().getScriptEngine())
	.collect(Collectors.toList());
	} finally {
	readWriteLock.readLock().unlock();
	}
	}

	@Override
	public ScriptEngine getEngineByExtension(String extension) {
	readWriteLock.readLock().lock();
	try {
	SortableScriptEngineFactory ssef = factories.stream()
	.filter(factory -> factory.getExtensions().contains(extension))
	.findFirst()
	.orElse(null);
	return ssef == null ? null : ssef.getScriptEngine();
	} finally {
	readWriteLock.readLock().unlock();
	}
	}

	public List<ScriptEngine> getEnginesByExtension(final String extension) {
	readWriteLock.readLock().lock();
	try {
	return factories.stream()
	.filter(factory -> factory.getExtensions().contains(extension))
	.map(factory -> factory.getDelegate().getScriptEngine())
	.collect(Collectors.toList());
	} finally {
	readWriteLock.readLock().unlock();
	}
	}

	@Override
	public ScriptEngine getEngineByMimeType(String mimeType) {
	readWriteLock.readLock().lock();
	try {
	SortableScriptEngineFactory ssef = factories.stream()
	.filter(factory -> factory.getMimeTypes().contains(mimeType))
	.findFirst()
	.orElse(null);
	return ssef == null ? null : ssef.getScriptEngine();
	} finally {
	readWriteLock.readLock().unlock();
	}
	}

	public List<ScriptEngine> getEnginesByMimeType(final String mimeType) {
	readWriteLock.readLock().lock();
	try {
	return factories.stream()
	.filter(factory -> factory.getMimeTypes().contains(mimeType))
	.map(factory -> factory.getDelegate().getScriptEngine())
	.collect(Collectors.toList());
	} finally {
	readWriteLock.readLock().unlock();
	}
	}

	@Override
	public List<ScriptEngineFactory> getEngineFactories() {
	readWriteLock.readLock().lock();
	try {
	ArrayList<ScriptEngineFactory> list = new ArrayList<>(factories.size());
	list.addAll(factories);
	return Collections.unmodifiableList(list);
	} finally {
	readWriteLock.readLock().unlock();
	}
	}

	@Override
	public void registerEngineName(String name, ScriptEngineFactory factory) {
	readWriteLock.writeLock().lock();
	try {
	internalManager.registerEngineName(name, factory);
	} finally {
	readWriteLock.writeLock().unlock();
	}
	}

	@Override
	public void registerEngineMimeType(String type, ScriptEngineFactory factory) {
	readWriteLock.writeLock().lock();
	try {
	internalManager.registerEngineMimeType(type, factory);
	} finally {
	readWriteLock.writeLock().unlock();
	}
	}

	@Override
	public void registerEngineExtension(String extension, ScriptEngineFactory factory) {
	readWriteLock.writeLock().lock();
	try {
	internalManager.registerEngineExtension(extension, factory);
	} finally {
	readWriteLock.writeLock().unlock();
	}
	}

	@Override
	public void bundleChanged(BundleEvent event) {
	if (event.getType() == BundleEvent.STARTED
	&& event.getBundle().getBundleId() > 0
	// SLING-11398 - use findEntries instead of getEntry to support fragments
	&& event.getBundle().findEntries(META_INF_SERVICES, FACTORY_NAME, false) != null) {
	synchronized (this.engineSpiBundles) {
	this.engineSpiBundles.add(event.getBundle());
	}
	updateFactories();
	} else if (event.getType() == BundleEvent.STOPPED) {
	boolean refresh;
	synchronized (this.engineSpiBundles) {
	refresh = this.engineSpiBundles.remove(event.getBundle());
	}
	if (refresh) {
	updateFactories();
	}
	}
	}

	public Map<String, Object> getServiceProperties(final ScriptEngineFactory factory) {
	readWriteLock.readLock().lock();
	try {
	return factories.stream().filter(f -> f.getDelegate().equals(factory)).findFirst().map(SortableScriptEngineFactory::getServiceProperties).orElse(null);
	} finally {
	readWriteLock.readLock().unlock();
	}
	}

	@Activate
	private void activate(final Config config, final BundleContext bundleContext) {
	String[] includes = config.includes();
	if (includes == null) {
	this.includePatterns = Collections.emptySet();
	} else {
	this.includePatterns = new HashSet<>();
	for (String pattern : includes) {
	if (!pattern.isEmpty()) {
	Pattern p = Pattern.compile(pattern);
	includePatterns.add(p);
	}
	}
	}

	String[] excludes = config.excludes();
	if (excludes == null) {
	this.excludePatterns = Collections.emptySet();
	} else {
	this.excludePatterns = new HashSet<>();
	for (String pattern : excludes) {
	if (!pattern.isEmpty()) {
	Pattern p = Pattern.compile(pattern);
	excludePatterns.add(p);
	}
	}
	}

	this.bundleContext = bundleContext;
	bundleContext.addBundleListener(this);
	registerInitialScriptEngineFactories();
	}

	/**
	* Handles any spi bundles that were already started before we started listening
	*/
	private void registerInitialScriptEngineFactories() {
	Bundle[] bundles = this.bundleContext.getBundles();
	for (Bundle bundle : bundles) {
	if (bundle.getState() == Bundle.ACTIVE
	&& bundle.getBundleId() > 0
	&& bundle.findEntries(META_INF_SERVICES, FACTORY_NAME, false) != null) {
	synchronized (this.engineSpiBundles) {
	this.engineSpiBundles.add(bundle);
	}
	}
	}
	updateFactories();
	}

	/**
	* Check if the given factory matches any of the include/excludes patterns
	*
	* @param sef the factory to check
	* @return true if included, false otherwise
	*/
	private boolean isIncluded(ScriptEngineFactory sef) {
	boolean include = false;

	if (!this.includePatterns.isEmpty()) {
	List<String> names = sef.getNames();
	for (String name : names) {
	for (Pattern p : this.includePatterns) {
	if (p.matcher(name).matches()) {
	include = true;
	if (logger.isDebugEnabled()) {
	logger.debug("ScriptEngineFactory \"{}\" matches the include pattern \"{}\" for name \"{}\"", sef.getEngineName(), p.pattern(), name);
	}
	break; // found a match so stop looking further
	}
	}
	if (include) {
	break; // break out of the outer loop too
	}
	}
	}

	if (include && !this.excludePatterns.isEmpty()) {
	List<String> names = sef.getNames();
	for (String name : names) {
	for (Pattern p : this.excludePatterns) {
	if (p.matcher(name).matches()) {
	include = false;
	if (logger.isDebugEnabled()) {
	logger.debug("ScriptEngineFactory \"{}\" matches the exclude pattern \"{}\" for name \"{}\" so it is not included", sef.getEngineName(), p.pattern(), name);
	}
	break; // found a match so stop looking further
	}
	}
	if (!include) {
	break; // break out of the outer loop too
	}
	}
	}
	return include;
	}

	@Deactivate
	private void deactivate(final BundleContext bundleContext) {
	bundleContext.removeBundleListener(this);
	}

	@SuppressWarnings("unused")
	private void bindScriptEngineFactory(final ServiceReference<ScriptEngineFactory> serviceReference, final ScriptEngineFactory factory) {
	synchronized (this.serviceReferences) {
	serviceReferences.add(serviceReference);
	}
	updateFactories();
	postEvent(SlingScriptConstants.TOPIC_SCRIPT_ENGINE_FACTORY_ADDED, factory);
	}

	@SuppressWarnings("unused")
	private void unbindScriptEngineFactory(final ServiceReference<ScriptEngineFactory> serviceReference, final ScriptEngineFactory factory) {
	synchronized (this.serviceReferences) {
	serviceReferences.remove(serviceReference);
	if (bundleContext != null) {
	bundleContext.ungetService(serviceReference);
	}
	}
	updateFactories();
	postEvent(SlingScriptConstants.TOPIC_SCRIPT_ENGINE_FACTORY_REMOVED, factory);
	}

	@SuppressWarnings("unused")
	private void updatedScriptEngineFactory(final ServiceReference<ScriptEngineFactory> serviceReference, final ScriptEngineFactory factory) {
	updateFactories();
	postEvent(SlingScriptConstants.TOPIC_SCRIPT_ENGINE_FACTORY_UPDATED, factory);
	}

	private void updateFactories() {
	readWriteLock.writeLock().lock();
	try {
	internalManager = getInternalScriptEngineManager();
	factories.clear();

	long fakeBundleIdCounter = Long.MIN_VALUE;
	// first add the platform factories
	for (final ScriptEngineFactory factory : internalManager.getEngineFactories()) {
	if (isIncluded(factory)) {
	final SortableScriptEngineFactory sortableScriptEngineFactory = new SortableScriptEngineFactory(factory, fakeBundleIdCounter++, 0, null);
	factories.add(sortableScriptEngineFactory);
	}
	}

	// then factories from SPI Bundles
	final ClassLoader loader = Thread.currentThread().getContextClassLoader();
	try {
	Thread.currentThread().setContextClassLoader(null);
	for (final Bundle bundle : engineSpiBundles) {
	try {
	final ScriptEngineManager manager = new ScriptEngineManager(bundle.adapt(BundleWiring.class).getClassLoader());
	for (final ScriptEngineFactory factory : manager.getEngineFactories()) {
	if (isIncluded(factory)) {
	final SortableScriptEngineFactory sortableScriptEngineFactory = new SortableScriptEngineFactory(factory, bundle.getBundleId(), 0, null);
	factories.add(sortableScriptEngineFactory);
	}
	}
	} catch (Exception ex) {
	logger.error("Unable to process bundle " + bundle.getSymbolicName(), ex);
	}
	}
	}
	finally {
	Thread.currentThread().setContextClassLoader(loader);
	}
	// and finally factories registered as OSGi services
	if (bundleContext != null) {
	synchronized (this.serviceReferences) {
	for (final ServiceReference<ScriptEngineFactory> serviceReference : serviceReferences) {
	final ScriptEngineFactory scriptEngineFactory = bundleContext.getService(serviceReference);
	if (isIncluded(scriptEngineFactory)) {
	final Map<String, Object> factoryProperties = new HashMap<>(serviceReference.getPropertyKeys().length);
	for (final String key : serviceReference.getPropertyKeys()) {
	factoryProperties.put(key, serviceReference.getProperty(key));
	}
	final SortableScriptEngineFactory sortableScriptEngineFactory = new SortableScriptEngineFactory(scriptEngineFactory, serviceReference.getBundle().getBundleId(), PropertiesUtil.toInteger(serviceReference.getProperty(Constants.SERVICE_RANKING), 0), factoryProperties);
	factories.add(sortableScriptEngineFactory);
	}
	}
	}
	}
	// register the associations at the end, so that the priority sorting is taken into consideration
	for (final ScriptEngineFactory factory : factories) {
	registerAssociations(factory);
	}
	if (eventAdmin != null) {
	eventAdmin.postEvent(new Event(EVENT_TOPIC_SCRIPT_MANAGER_UPDATED, Collections.emptyMap()));
	}
	} finally {
	readWriteLock.writeLock().unlock();
	}
	}

	private ScriptEngineManager getInternalScriptEngineManager() {
	final ClassLoader loader = Thread.currentThread().getContextClassLoader();
	try {
	Thread.currentThread().setContextClassLoader(null);
	return new ScriptEngineManager(ClassLoader.getSystemClassLoader());
	}
	finally {
	Thread.currentThread().setContextClassLoader(loader);
	}
	}

	private void registerAssociations(ScriptEngineFactory factory) {
	for (String extension : factory.getExtensions()) {
	if (extension != null && !extension.isEmpty()) {
	internalManager.registerEngineExtension(extension, factory);
	} else {
	logger.warn("Could not register an empty or null extension for script engine factory {}.", factory.getEngineName());
	}
	}
	for (String mimeType : factory.getMimeTypes()) {
	if (mimeType != null && !mimeType.isEmpty()) {
	internalManager.registerEngineMimeType(mimeType, factory);
	} else {
	logger.warn("Could not register an empty or null mime type for script engine factory {}.", factory.getEngineName());
	}
	}
	for (String name : factory.getNames()) {
	if (name != null && !name.isEmpty()) {
	internalManager.registerEngineName(name, factory);
	} else {
	logger.warn("Could not register an empty or null engine name for script engine factory {}.", factory.getEngineName());
	}
	}
	}

	private void postEvent(final String topic, final ScriptEngineFactory scriptEngineFactory) {
	if (eventAdmin != null) {
	final Dictionary<String, Object> props = new Hashtable<>();
	props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_NAME, scriptEngineFactory.getEngineName());
	props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_VERSION, scriptEngineFactory.getEngineVersion());
	props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_EXTENSIONS, scriptEngineFactory.getExtensions().toArray(new String[0]));
	props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_LANGUAGE_NAME, scriptEngineFactory.getLanguageName());
	props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_LANGUAGE_VERSION, scriptEngineFactory.getLanguageVersion());
	props.put(SlingScriptConstants.PROPERTY_SCRIPT_ENGINE_FACTORY_MIME_TYPES, scriptEngineFactory.getMimeTypes().toArray(new String[0]));
	eventAdmin.postEvent(new Event(topic, props));
	}
	}

	}