com.devonfw.cobigen.impl.extension.ClassServiceLoader Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of core Show documentation
A Code-based incremental Generator
There is a newer version: 2021.12.006
package com.devonfw.cobigen.impl.extension;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLConnection;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.ServiceLoader;
import java.util.Set;

import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.devonfw.cobigen.api.extension.GeneratorPluginActivator;
import com.devonfw.cobigen.api.extension.TextTemplateEngine;

/**
 * This class is is the manual implementation of a Lazy {@link ServiceLoader} allowing introspection without
 * instantiating a plug-in. Introspection get's supported by JDK 9 earliest by the ServiceLoader
 * implementation of JDK. This class can be treated as a workaround for JDK 8 and can be removed as soon as we
 * raise the lower limit of JDK support to at least JDK 9.
 */
public class ClassServiceLoader {

    /** Logger instance. */
    private static final Logger LOG = LoggerFactory.getLogger(ClassServiceLoader.class);

    /** Classes detected as GeneratorPluginActivators */
    private static Set> generatorPluginActivatorClasses = new HashSet<>();

    /** Classes detected as TemplateEngines */
    private static Set> templateEngineClasses = new HashSet<>();

    static {
        LOG.debug("Initiating CobiGen");
        lookupServices(Thread.currentThread().getContextClassLoader());
    }

    /**
     * Detects CobiGen extensions on the classpath of the given class loader
     * @param classLoader
     *            determining the classpath to look at
     */
    public static void lookupServices(ClassLoader classLoader) {
        LOG.info("Searching for plug-ins at classloader {}", classLoader);
        if (LOG.isDebugEnabled()) {
            if (classLoader instanceof URLClassLoader) {
                LOG.debug("URL Classloader with URLs:");
                Arrays.stream(((URLClassLoader) classLoader).getURLs()).forEach(url -> LOG.debug("  * {}", url));
            }
        }
        generatorPluginActivatorClasses.clear();
        templateEngineClasses.clear();
        LOG.info("Loading plug-in activators...");
        lookupServices(GeneratorPluginActivator.class, generatorPluginActivatorClasses, classLoader);
        LOG.info("Loading template engines...");
        lookupServices(TextTemplateEngine.class, templateEngineClasses, classLoader);
    }

    /**
     * Detects services of extensions type and adds them to the clazzSet
     * @param 
     *            the extension type to be found by {@link ServiceLoader} mechanism
     * @param extensionType
     *            the extension type
     * @param clazzSet
     *            the set to add the detected classes
     * @param contextClassLoader
     *            the classloader to be used for classpath scanning
     */
    @SuppressWarnings("unchecked")
    private static  void lookupServices(Class extensionType, Set> clazzSet,
        ClassLoader contextClassLoader) {
        try {
            Enumeration foundGeneratorPluginActivators =
                contextClassLoader.getResources("META-INF/services/" + extensionType.getName());

            while (foundGeneratorPluginActivators.hasMoreElements()) {
                URL url = foundGeneratorPluginActivators.nextElement();
                LOG.debug("Found classpath entry: {}", url);
                String activatorClassName = null;
                try {
                    URLConnection con = url.openConnection();
                    try (InputStream in = con.getInputStream()) {
                        List lines = IOUtils.readLines(in, StandardCharsets.UTF_8);
                        LOG.debug("Lines of service loader file: {}", lines);
                        if (!lines.isEmpty()) {
                            activatorClassName = lines.get(0);
                            Class loadClass = contextClassLoader.loadClass(activatorClassName);
                            if (extensionType.isAssignableFrom(loadClass)) {
                                LOG.info("Found {} {}", extensionType.getSimpleName(), activatorClassName);
                                clazzSet.add((Class) loadClass);
                            } else {
                                LOG.warn("ServiceLoader extension with class {} is not a subclass of {}. Skipping...",
                                    activatorClassName, extensionType.getCanonicalName());
                            }
                        }
                    }
                } catch (IOException e) {
                    LOG.error("Could not read plug-in at {}", url, LOG.isDebugEnabled() ? e : null);
                } catch (ClassNotFoundException e) {
                    LOG.error("Could not load plug-in with class {}", activatorClassName,
                        LOG.isDebugEnabled() ? e : null);
                }
            }
            if (clazzSet.isEmpty()) {
                LOG.error("At least one plug-in should be registered of type {}", extensionType.getSimpleName());
            }
        } catch (Throwable e1) {
            LOG.error("Unable to retrieve {} by ServiceLoader interface", extensionType, e1);
        }
    }

    /**
     * @return the detected classes of {@link GeneratorPluginActivator}
     */
    public static Set> getGeneratorPluginActivatorClasses() {
        return generatorPluginActivatorClasses;
    }

    /**
     * @return the detected classes of {@link TextTemplateEngine}
     */
    public static Set> getTemplateEngineClasses() {
        return templateEngineClasses;
    }

}