Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed 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 com.facebook.presto.server;
 
 
 
 import java.io.File;
 import java.net.URL;
 import java.util.List;
 import java.util.Map;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public class PluginManager
 {
     private static final List<StringHIDDEN_CLASSES = ImmutableList.<String>builder()
             .add("org.slf4j")
             .build();
 
     private static final ImmutableList<StringPARENT_FIRST_CLASSES = ImmutableList.<String>builder()
             .add("com.facebook.presto")
             .add("com.fasterxml.jackson")
             .add("io.airlift.slice")
             .add("javax.inject")
             .add("javax.annotation")
             .add("java.")
             .build();
 
     private static final Logger log = Logger.get(PluginManager.class);
 
     private final Injector injector;
     private final ConnectorManager connectorManager;
     private final SystemTablesManager systemTablesManager;
     private final Metadata metadata;
     private final BlockEncodingManager blockEncodingManager;
     private final TypeRegistry typeRegistry;
     private final ArtifactResolver resolver;
     private final File installedPluginsDir;
     private final List<Stringplugins;
     private final Map<StringStringoptionalConfig;
     private final AtomicBoolean pluginsLoading = new AtomicBoolean();
     private final AtomicBoolean pluginsLoaded = new AtomicBoolean();
 
     @Inject
     public PluginManager(Injector injector,
             NodeInfo nodeInfo,
             HttpServerInfo httpServerInfo,
             PluginManagerConfig config,
             ConnectorManager connectorManager,
             ConfigurationFactory configurationFactory,
             SystemTablesManager systemTablesManager,
             Metadata metadata,
            BlockEncodingManager blockEncodingManager,
            TypeRegistry typeRegistry)
    {
        checkNotNull(injector"injector is null");
        checkNotNull(nodeInfo"nodeInfo is null");
        checkNotNull(httpServerInfo"httpServerInfo is null");
        checkNotNull(config"config is null");
        checkNotNull(configurationFactory"configurationFactory is null");
        this. = injector;
         = config.getInstalledPluginsDir();
        if (config.getPlugins() == null) {
            this. = ImmutableList.of();
        }
        else {
            this. = ImmutableList.copyOf(config.getPlugins());
        }
        this. = new ArtifactResolver(config.getMavenLocalRepository(), config.getMavenRemoteRepository());
        Map<StringStringoptionalConfig = new TreeMap<>(configurationFactory.getProperties());
        optionalConfig.put("node.id"nodeInfo.getNodeId());
        // TODO: make this work with and without HTTP and HTTPS
        optionalConfig.put("http-server.http.port", Integer.toString(httpServerInfo.getHttpUri().getPort()));
        this. = ImmutableMap.copyOf(optionalConfig);
        this. = checkNotNull(connectorManager"connectorManager is null");
        this. = checkNotNull(systemTablesManager"systemTablesManager is null");
        this. = checkNotNull(metadata"metadata is null");
        this. = checkNotNull(blockEncodingManager"blockEncodingManager is null");
        this. = checkNotNull(typeRegistry"typeRegistry is null");
    }
    public boolean arePluginsLoaded()
    {
        return .get();
    }
    public void loadPlugins()
            throws Exception
    {
        if (!.compareAndSet(falsetrue)) {
            return;
        }
        for (File file : listFiles()) {
            if (file.isDirectory()) {
                loadPlugin(file.getAbsolutePath());
            }
        }
        for (String plugin : ) {
            loadPlugin(plugin);
        }
        .set(true);
    }
    private void loadPlugin(String plugin)
            throws Exception
    {
        .info("-- Loading plugin %s --"plugin);
        URLClassLoader pluginClassLoader = buildClassLoader(plugin);
        try (ThreadContextClassLoader ignored = new ThreadContextClassLoader(pluginClassLoader)) {
            loadPlugin(pluginClassLoader);
        }
        .info("-- Finished loading plugin %s --"plugin);
    }
    private void loadPlugin(URLClassLoader pluginClassLoader)
            throws Exception
    {
        ServiceLoader<PluginserviceLoader = ServiceLoader.load(Plugin.classpluginClassLoader);
        List<Pluginplugins = ImmutableList.copyOf(serviceLoader);
        if (plugins.isEmpty()) {
            .warn("No service providers of type %s"Plugin.class.getName());
        }
        for (Plugin plugin : plugins) {
            .info("Installing %s"plugin.getClass().getName());
            installPlugin(plugin);
        }
    }
    public void installPlugin(Plugin plugin)
    {
        .injectMembers(plugin);
        plugin.setOptionalConfig();
        for (BlockEncodingFactory<?> blockEncodingFactory : plugin.getServices(BlockEncodingFactory.class)) {
            .info("Registering block encoding %s"blockEncodingFactory.getName());
            .addBlockEncodingFactory(blockEncodingFactory);
        }
        for (Type type : plugin.getServices(Type.class)) {
            .info("Registering type %s"type.getTypeSignature());
            .addType(type);
        }
        for (ParametricType parametricType : plugin.getServices(ParametricType.class)) {
            .info("Registering parametric type %s"parametricType.getName());
            .addParametricType(parametricType);
        }
        for (ConnectorFactory connectorFactory : plugin.getServices(ConnectorFactory.class)) {
            .info("Registering connector %s"connectorFactory.getName());
            .addConnectorFactory(connectorFactory);
        }
        for (SystemTable systemTable : plugin.getServices(SystemTable.class)) {
            .info("Registering system table %s"systemTable.getTableMetadata().getTable());
            .addTable(systemTable);
        }
        for (FunctionFactory functionFactory : plugin.getServices(FunctionFactory.class)) {
            .info("Registering functions from %s"functionFactory.getClass().getName());
            .addFunctions(functionFactory.listFunctions());
        }
    }
    private URLClassLoader buildClassLoader(String plugin)
            throws Exception
    {
        File file = new File(plugin);
        if (file.isFile() && (file.getName().equals("pom.xml") || file.getName().endsWith(".pom"))) {
            return buildClassLoaderFromPom(file);
        }
        if (file.isDirectory()) {
            return buildClassLoaderFromDirectory(file);
        }
        return buildClassLoaderFromCoordinates(plugin);
    }
    private URLClassLoader buildClassLoaderFromPom(File pomFile)
            throws Exception
    {
        List<Artifactartifacts = .resolvePom(pomFile);
        return createClassLoader(artifactspomFile.getPath());
    }
            throws Exception
    {
        .debug("Classpath for %s:"dir.getName());
        List<URLurls = new ArrayList<>();
        for (File file : listFiles(dir)) {
            .debug("    %s"file);
            urls.add(file.toURI().toURL());
        }
        return createClassLoader(urls);
    }
            throws Exception
    {
        Artifact rootArtifact = new DefaultArtifact(coordinates);
        List<Artifactartifacts = .resolveArtifacts(rootArtifact);
        return createClassLoader(artifactsrootArtifact.toString());
    }
    private URLClassLoader createClassLoader(List<ArtifactartifactsString name)
            throws IOException
    {
        .debug("Classpath for %s:"name);
        List<URLurls = new ArrayList<>();
        for (Artifact artifact : sortedArtifacts(artifacts)) {
            if (artifact.getFile() == null) {
                throw new RuntimeException("Could not resolve artifact: " + artifact);
            }
            File file = artifact.getFile().getCanonicalFile();
            .debug("    %s"file);
            urls.add(file.toURI().toURL());
        }
        return createClassLoader(urls);
    }
    private URLClassLoader createClassLoader(List<URLurls)
    {
        ClassLoader parent = getClass().getClassLoader();
        return new PluginClassLoader(urlsparent);
    }
    private static List<FilelistFiles(File installedPluginsDir)
    {
        if (installedPluginsDir != null && installedPluginsDir.isDirectory()) {
            File[] files = installedPluginsDir.listFiles();
            if (files != null) {
                Arrays.sort(files);
                return ImmutableList.copyOf(files);
            }
        }
        return ImmutableList.of();
    }
    private static List<ArtifactsortedArtifacts(List<Artifactartifacts)
    {
        List<Artifactlist = Lists.newArrayList(artifacts);
        Collections.sort(list, Ordering.natural().nullsLast().onResultOf(Artifact::getFile));
        return list;
    }
New to GrepCode? Check out our FAQ X