src/main/java/org/apache/sling/commons/classloader/impl/PackageAdminClassLoader.java - sling-org-apache-sling-commons-classloader - 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.commons.classloader.impl;

 import java.io.IOException;
 import java.net.URL;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;

 import org.osgi.framework.Bundle;
 import org.osgi.framework.Constants;
 import org.osgi.service.packageadmin.ExportedPackage;
 import org.osgi.service.packageadmin.PackageAdmin;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * The <code>PackageAdminClassLoader</code> loads
  * classes and resources through the package admin service.
  */
 class PackageAdminClassLoader extends ClassLoader {

     private static final Logger LOGGER = LoggerFactory.getLogger(PackageAdminClassLoader.class);

     /** The package admin service. */
     private final PackageAdmin packageAdmin;

     /** The manager factory. */
     private final DynamicClassLoaderManagerFactory factory;

     /** A cache for resolved classes. */
     private Map<String, Class<?>> classCache = new ConcurrentHashMap<String, Class<?>>();

     /** Negative class cache. */
     private Set<String> negativeClassCache = Collections.synchronizedSet(new HashSet<String>());

     private Map<String, Bundle> packageProviders = new ConcurrentHashMap<>();

     /** A cache for resolved urls. */
     private Map<String, URL> urlCache = new ConcurrentHashMap<String, URL>();

     public PackageAdminClassLoader(final PackageAdmin pckAdmin,
             final ClassLoader parent,
             final DynamicClassLoaderManagerFactory factory) {
         super(parent);
         this.packageAdmin = pckAdmin;
         this.factory = factory;
     }

     /**
      * Returns <code>true</code> if the <code>bundle</code> is to be considered
      * active from the perspective of declarative services.
      * <p>
      * As of R4.1 a bundle may have lazy activation policy which means a bundle
      * remains in the STARTING state until a class is loaded from that bundle
      * (unless that class is declared to not cause the bundle to start).
      *
      * @param bundle The bundle check
      * @return <code>true</code> if <code>bundle</code> is not <code>null</code>
      *          and the bundle is either active or has lazy activation policy
      *          and is in the starting state.
      */
     private boolean isBundleActive( final Bundle bundle ) {
         if ( bundle != null ) {
             if ( bundle.getState() == Bundle.ACTIVE ) {
                 return true;
             }

             if ( bundle.getState() == Bundle.STARTING ) {
                 // according to the spec the activationPolicy header is only
                 // set to request a bundle to be lazily activated. So in this
                 // simple check we just verify the header is set to assume
                 // the bundle is considered a lazily activated bundle
                 return bundle.getHeaders().get( Constants.BUNDLE_ACTIVATIONPOLICY ) != null;
             }
         }

         // fall back: bundle is not considered active
         return false;
     }

     /**
      * Find the bundle for a given package.
      * @param pckName The package name.
      * @return The bundle or <code>null</code>
      */
     private Set<Bundle> findBundlesForPackage(final String pckName) {
         final ExportedPackage[] exportedPackages = this.packageAdmin.getExportedPackages(pckName);
         Set<Bundle> bundles = new LinkedHashSet<>();
         if (exportedPackages != null) {
             for (ExportedPackage exportedPackage : exportedPackages) {
                 if (!exportedPackage.isRemovalPending()) {
                     Bundle bundle = exportedPackage.getExportingBundle();
                     if (isBundleActive(bundle)) {
                         bundles.add(bundle);
                     }
                 }
             }
         }
         return bundles;
     }

     /**
      * Return the package from a resource.
      * @param resource The resource path.
      * @return The package name.
      */
     private String getPackageFromResource(final String resource) {
         final int lastSlash = resource.lastIndexOf('/');
         final String pckName = (lastSlash == -1 ? "" : resource.substring(0, lastSlash).replace('/', '.'));
         return pckName;
     }

     /**
      * Return the package from a class.
      * @param name The class name.
      * @return The package name.
      */
     private String getPackageFromClassName(final String name) {
         final int lastDot = name.lastIndexOf('.');
         final String pckName = (lastDot == -1 ? "" : name.substring(0, lastDot));
         return pckName;
     }

     /**
      * @see java.lang.ClassLoader#getResources(java.lang.String)
      */
     @Override
     public Enumeration<URL> getResources(final String name) throws IOException {
         Enumeration<URL> e = super.getResources(name);
         if ( e == null || !e.hasMoreElements() ) {
             String packageName = getPackageFromResource(name);
             Bundle providingBundle = packageProviders.get(packageName);
             if (providingBundle == null) {
                 for (Bundle bundle : findBundlesForPackage(getPackageFromResource(name))) {
                     e = bundle.getResources(name);
                     if (e != null) {
                         packageProviders.put(packageName, bundle);
                         LOGGER.debug("Marking bundle {}:{} as the provider for API package {}.", bundle.getSymbolicName(), bundle
                                 .getVersion().toString(), packageName);
                         return e;
                     }
                 }
             } else {
                 e = providingBundle.getResources(name);
                 if (e == null) {
                     LOGGER.debug("Cannot find resources {} in bundle {}:{} which was marked as the provider for package {}.", name,
                             providingBundle.getSymbolicName(), providingBundle.getVersion().toString(), packageName);
                 }
             }
         }
         return e;
     }

     /**
      * @see java.lang.ClassLoader#findResource(java.lang.String)
      */
     @Override
     public URL findResource(final String name) {
         final URL cachedURL = urlCache.get(name);
         if ( cachedURL != null ) {
             return cachedURL;
         }
         URL url = super.findResource(name);
         if ( url == null ) {
             String packageName = getPackageFromResource(name);
             Bundle providingBundle = packageProviders.get(packageName);
             if (providingBundle == null) {
                 Set<Bundle> bundles = findBundlesForPackage(getPackageFromResource(name));
                 for (Bundle bundle : bundles) {
                     url = bundle.getResource(name);
                     if (url != null) {
                         urlCache.put(name, url);
                         packageProviders.put(packageName, bundle);
                         LOGGER.debug("Marking bundle {}:{} as the provider for API package {}.", bundle.getSymbolicName(), bundle
                                 .getVersion().toString(), packageName);
                         return url;
                     }
                 }
             } else {
                 url = providingBundle.getResource(name);
                 if (url == null) {
                     LOGGER.debug("Cannot find resource {} in bundle {}:{} which was marked as the provider for package {}.", name,
                             providingBundle.getSymbolicName(), providingBundle.getVersion().toString(), packageName);
                 }
             }
         }
         return url;
     }

     /**
      * @see java.lang.ClassLoader#findClass(java.lang.String)
      */
     @Override
     public Class<?> findClass(final String name) throws ClassNotFoundException {
         final Class<?> cachedClass = this.classCache.get(name);
         if ( cachedClass != null ) {
             return cachedClass;
         }
         Class<?> clazz;
         try {
             clazz = super.findClass(name);
         } catch (ClassNotFoundException cnfe) {
             try {
                 clazz = getClassFromBundles(name);
             } catch (ClassNotFoundException innerCNFE) {
                 throw innerCNFE;
             }
         }
         if ( clazz == null ) {
             throw new ClassNotFoundException("Class not found " + name);
         }
         this.classCache.put(name, clazz);
         return clazz;
     }

     /**
      * @see java.lang.ClassLoader#loadClass(java.lang.String, boolean)
      */
     @Override
     protected Class<?> loadClass(final String name, final boolean resolve) throws ClassNotFoundException {
         final Class<?> cachedClass = this.classCache.get(name);
         if ( cachedClass != null ) {
             return cachedClass;
         }
         if ( negativeClassCache.contains(name) ) {
             throw new ClassNotFoundException("Class not found " + name);
         }
         String packageName = getPackageFromClassName(name);
         Class<?> clazz;
         try {
             clazz = super.loadClass(name, resolve);
         } catch (final ClassNotFoundException cnfe) {
             try {
                 clazz = getClassFromBundles(name);
             } catch (ClassNotFoundException innerCNFE) {
                 negativeClassCache.add(name);
                 this.factory.addUnresolvedPackage(packageName);
                 throw innerCNFE;
             }
         }
         if ( clazz == null ) {
             negativeClassCache.add(name);
             this.factory.addUnresolvedPackage(packageName);
             throw new ClassNotFoundException("Class not found " + name);
         }
         this.classCache.put(name, clazz);
         return clazz;
     }

     private Class<?> getClassFromBundles(String name) throws ClassNotFoundException {
         Class<?> clazz = null;
         String packageName = getPackageFromClassName(name);
         Bundle providingBundle = packageProviders.get(packageName);
         if (providingBundle == null) {
             Set<Bundle> bundles = findBundlesForPackage(packageName);
             for (Bundle bundle : bundles) {
                 try {
                     clazz = bundle.loadClass(name);
                     this.factory.addUsedBundle(bundle);
                     packageProviders.put(packageName, bundle);
                     LOGGER.debug("Marking bundle {}:{} as the provider for API package {}.", bundle.getSymbolicName(), bundle
                             .getVersion().toString(), packageName);
                     break;
                 } catch (ClassNotFoundException innerCNFE) {
                     // do nothing; we need to loop over the bundles providing the class' package
                 }
             }
         } else {
             try {
                 clazz = providingBundle.loadClass(name);
                 this.factory.addUsedBundle(providingBundle);
             } catch (ClassNotFoundException icnfe) {
                 throw new ClassNotFoundException(String.format("Cannot find class %s in bundle %s:%s which was marked as the provider for" +
                         " package %s.", name, providingBundle.getSymbolicName(), providingBundle.getVersion().toString(), packageName), icnfe);
             }
         }
         return clazz;
     }
 }
	/*
	* 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.commons.classloader.impl;

	import java.io.IOException;
	import java.net.URL;
	import java.util.Collections;
	import java.util.Enumeration;
	import java.util.HashSet;
	import java.util.LinkedHashSet;
	import java.util.Map;
	import java.util.Set;
	import java.util.concurrent.ConcurrentHashMap;

	import org.osgi.framework.Bundle;
	import org.osgi.framework.Constants;
	import org.osgi.service.packageadmin.ExportedPackage;
	import org.osgi.service.packageadmin.PackageAdmin;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	/**
	* The <code>PackageAdminClassLoader</code> loads
	* classes and resources through the package admin service.
	*/
	class PackageAdminClassLoader extends ClassLoader {

	private static final Logger LOGGER = LoggerFactory.getLogger(PackageAdminClassLoader.class);

	/** The package admin service. */
	private final PackageAdmin packageAdmin;

	/** The manager factory. */
	private final DynamicClassLoaderManagerFactory factory;

	/** A cache for resolved classes. */
	private Map<String, Class<?>> classCache = new ConcurrentHashMap<String, Class<?>>();

	/** Negative class cache. */
	private Set<String> negativeClassCache = Collections.synchronizedSet(new HashSet<String>());

	private Map<String, Bundle> packageProviders = new ConcurrentHashMap<>();

	/** A cache for resolved urls. */
	private Map<String, URL> urlCache = new ConcurrentHashMap<String, URL>();

	public PackageAdminClassLoader(final PackageAdmin pckAdmin,
	final ClassLoader parent,
	final DynamicClassLoaderManagerFactory factory) {
	super(parent);
	this.packageAdmin = pckAdmin;
	this.factory = factory;
	}

	/**
	* Returns <code>true</code> if the <code>bundle</code> is to be considered
	* active from the perspective of declarative services.
	* <p>
	* As of R4.1 a bundle may have lazy activation policy which means a bundle
	* remains in the STARTING state until a class is loaded from that bundle
	* (unless that class is declared to not cause the bundle to start).
	*
	* @param bundle The bundle check
	* @return <code>true</code> if <code>bundle</code> is not <code>null</code>
	* and the bundle is either active or has lazy activation policy
	* and is in the starting state.
	*/
	private boolean isBundleActive( final Bundle bundle ) {
	if ( bundle != null ) {
	if ( bundle.getState() == Bundle.ACTIVE ) {
	return true;
	}

	if ( bundle.getState() == Bundle.STARTING ) {
	// according to the spec the activationPolicy header is only
	// set to request a bundle to be lazily activated. So in this
	// simple check we just verify the header is set to assume
	// the bundle is considered a lazily activated bundle
	return bundle.getHeaders().get( Constants.BUNDLE_ACTIVATIONPOLICY ) != null;
	}
	}

	// fall back: bundle is not considered active
	return false;
	}

	/**
	* Find the bundle for a given package.
	* @param pckName The package name.
	* @return The bundle or <code>null</code>
	*/
	private Set<Bundle> findBundlesForPackage(final String pckName) {
	final ExportedPackage[] exportedPackages = this.packageAdmin.getExportedPackages(pckName);
	Set<Bundle> bundles = new LinkedHashSet<>();
	if (exportedPackages != null) {
	for (ExportedPackage exportedPackage : exportedPackages) {
	if (!exportedPackage.isRemovalPending()) {
	Bundle bundle = exportedPackage.getExportingBundle();
	if (isBundleActive(bundle)) {
	bundles.add(bundle);
	}
	}
	}
	}
	return bundles;
	}

	/**
	* Return the package from a resource.
	* @param resource The resource path.
	* @return The package name.
	*/
	private String getPackageFromResource(final String resource) {
	final int lastSlash = resource.lastIndexOf('/');
	final String pckName = (lastSlash == -1 ? "" : resource.substring(0, lastSlash).replace('/', '.'));
	return pckName;
	}

	/**
	* Return the package from a class.
	* @param name The class name.
	* @return The package name.
	*/
	private String getPackageFromClassName(final String name) {
	final int lastDot = name.lastIndexOf('.');
	final String pckName = (lastDot == -1 ? "" : name.substring(0, lastDot));
	return pckName;
	}

	/**
	* @see java.lang.ClassLoader#getResources(java.lang.String)
	*/
	@Override
	public Enumeration<URL> getResources(final String name) throws IOException {
	Enumeration<URL> e = super.getResources(name);
	if ( e == null \|\| !e.hasMoreElements() ) {
	String packageName = getPackageFromResource(name);
	Bundle providingBundle = packageProviders.get(packageName);
	if (providingBundle == null) {
	for (Bundle bundle : findBundlesForPackage(getPackageFromResource(name))) {
	e = bundle.getResources(name);
	if (e != null) {
	packageProviders.put(packageName, bundle);
	LOGGER.debug("Marking bundle {}:{} as the provider for API package {}.", bundle.getSymbolicName(), bundle
	.getVersion().toString(), packageName);
	return e;
	}
	}
	} else {
	e = providingBundle.getResources(name);
	if (e == null) {
	LOGGER.debug("Cannot find resources {} in bundle {}:{} which was marked as the provider for package {}.", name,
	providingBundle.getSymbolicName(), providingBundle.getVersion().toString(), packageName);
	}
	}
	}
	return e;
	}

	/**
	* @see java.lang.ClassLoader#findResource(java.lang.String)
	*/
	@Override
	public URL findResource(final String name) {
	final URL cachedURL = urlCache.get(name);
	if ( cachedURL != null ) {
	return cachedURL;
	}
	URL url = super.findResource(name);
	if ( url == null ) {
	String packageName = getPackageFromResource(name);
	Bundle providingBundle = packageProviders.get(packageName);
	if (providingBundle == null) {
	Set<Bundle> bundles = findBundlesForPackage(getPackageFromResource(name));
	for (Bundle bundle : bundles) {
	url = bundle.getResource(name);
	if (url != null) {
	urlCache.put(name, url);
	packageProviders.put(packageName, bundle);
	LOGGER.debug("Marking bundle {}:{} as the provider for API package {}.", bundle.getSymbolicName(), bundle
	.getVersion().toString(), packageName);
	return url;
	}
	}
	} else {
	url = providingBundle.getResource(name);
	if (url == null) {
	LOGGER.debug("Cannot find resource {} in bundle {}:{} which was marked as the provider for package {}.", name,
	providingBundle.getSymbolicName(), providingBundle.getVersion().toString(), packageName);
	}
	}
	}
	return url;
	}

	/**
	* @see java.lang.ClassLoader#findClass(java.lang.String)
	*/
	@Override
	public Class<?> findClass(final String name) throws ClassNotFoundException {
	final Class<?> cachedClass = this.classCache.get(name);
	if ( cachedClass != null ) {
	return cachedClass;
	}
	Class<?> clazz;
	try {
	clazz = super.findClass(name);
	} catch (ClassNotFoundException cnfe) {
	try {
	clazz = getClassFromBundles(name);
	} catch (ClassNotFoundException innerCNFE) {
	throw innerCNFE;
	}
	}
	if ( clazz == null ) {
	throw new ClassNotFoundException("Class not found " + name);
	}
	this.classCache.put(name, clazz);
	return clazz;
	}

	/**
	* @see java.lang.ClassLoader#loadClass(java.lang.String, boolean)
	*/
	@Override
	protected Class<?> loadClass(final String name, final boolean resolve) throws ClassNotFoundException {
	final Class<?> cachedClass = this.classCache.get(name);
	if ( cachedClass != null ) {
	return cachedClass;
	}
	if ( negativeClassCache.contains(name) ) {
	throw new ClassNotFoundException("Class not found " + name);
	}
	String packageName = getPackageFromClassName(name);
	Class<?> clazz;
	try {
	clazz = super.loadClass(name, resolve);
	} catch (final ClassNotFoundException cnfe) {
	try {
	clazz = getClassFromBundles(name);
	} catch (ClassNotFoundException innerCNFE) {
	negativeClassCache.add(name);
	this.factory.addUnresolvedPackage(packageName);
	throw innerCNFE;
	}
	}
	if ( clazz == null ) {
	negativeClassCache.add(name);
	this.factory.addUnresolvedPackage(packageName);
	throw new ClassNotFoundException("Class not found " + name);
	}
	this.classCache.put(name, clazz);
	return clazz;
	}

	private Class<?> getClassFromBundles(String name) throws ClassNotFoundException {
	Class<?> clazz = null;
	String packageName = getPackageFromClassName(name);
	Bundle providingBundle = packageProviders.get(packageName);
	if (providingBundle == null) {
	Set<Bundle> bundles = findBundlesForPackage(packageName);
	for (Bundle bundle : bundles) {
	try {
	clazz = bundle.loadClass(name);
	this.factory.addUsedBundle(bundle);
	packageProviders.put(packageName, bundle);
	LOGGER.debug("Marking bundle {}:{} as the provider for API package {}.", bundle.getSymbolicName(), bundle
	.getVersion().toString(), packageName);
	break;
	} catch (ClassNotFoundException innerCNFE) {
	// do nothing; we need to loop over the bundles providing the class' package
	}
	}
	} else {
	try {
	clazz = providingBundle.loadClass(name);
	this.factory.addUsedBundle(providingBundle);
	} catch (ClassNotFoundException icnfe) {
	throw new ClassNotFoundException(String.format("Cannot find class %s in bundle %s:%s which was marked as the provider for" +
	" package %s.", name, providingBundle.getSymbolicName(), providingBundle.getVersion().toString(), packageName), icnfe);
	}
	}
	return clazz;
	}
	}