[ https://issues.apache.org/jira/browse/METRON-777?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16118651#comment-16118651 ]
ASF GitHub Bot commented on METRON-777: --------------------------------------- Github user mattf-horton commented on a diff in the pull request: https://github.com/apache/metron/pull/530#discussion_r131973587 --- Diff: bundles-lib/src/main/java/org/apache/metron/bundles/BundleClassLoaders.java --- @@ -0,0 +1,353 @@ +/* + * 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.metron.bundles; + +import java.net.URISyntaxException; +import java.util.*; + +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.vfs2.FileObject; +import org.apache.commons.vfs2.FileSystemException; +import org.apache.commons.vfs2.FileSystemManager; +import org.apache.metron.bundles.bundle.Bundle; +import org.apache.metron.bundles.bundle.BundleCoordinate; +import org.apache.metron.bundles.bundle.BundleDetails; +import org.apache.metron.bundles.util.BundleProperties; +import org.apache.metron.bundles.util.BundleSelector; +import org.apache.metron.bundles.util.FileUtils; +import org.apache.metron.bundles.util.BundleUtil; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * A singleton class used to initialize the extension and framework classloaders. + */ +public final class BundleClassLoaders { + + private static volatile BundleClassLoaders bundleClassLoaders; + private volatile InitContext initContext; + private static final Logger logger = LoggerFactory.getLogger(BundleClassLoaders.class); + + private final static class InitContext { + + private final List<FileObject> extensionDirs; + private final Map<String, Bundle> bundles; + + private InitContext( + final List<FileObject> extensionDirs, + final Map<String, Bundle> bundles) { + this.extensionDirs = extensionDirs; + this.bundles = bundles; + } + } + + private BundleClassLoaders() { + } + + /** + * @return The singleton instance of the BundleClassLoaders + */ + public static BundleClassLoaders getInstance() { + BundleClassLoaders result = bundleClassLoaders; + if (result == null) { + synchronized (BundleClassLoaders.class) { + result = bundleClassLoaders; + if (result == null) { + bundleClassLoaders = result = new BundleClassLoaders(); + } + } + } + return result; + } + + public static void reset() { + getInstance().unInit(); + } + + private void unInit() { + synchronized (this) { + initContext = null; + } + } + + /** + * Initializes and loads the BundleClassLoaders. This method must be called before the rest of the + * methods to access the classloaders are called and it can be safely called any number of times + * provided the same framework and extension working dirs are used. + * + * @param fileSystemManager the FileSystemManager + * @param extensionsDirs where to find extension artifacts + * @param props BundleProperties + * @throws FileSystemException if any issue occurs while exploding bundle working directories. + * @throws java.lang.ClassNotFoundException if unable to load class definition + * @throws IllegalStateException already initialized with a given pair of directories cannot + * reinitialize or use a different pair of directories. + */ + public void init(final FileSystemManager fileSystemManager, final List<FileObject> extensionsDirs, + BundleProperties props) + throws FileSystemException, ClassNotFoundException, URISyntaxException { + if (extensionsDirs == null || fileSystemManager == null) { + throw new NullPointerException("cannot have empty arguments"); + } + InitContext ic = initContext; + if (ic == null) { + synchronized (this) { + ic = initContext; + if (ic == null) { + initContext = ic = load(fileSystemManager, extensionsDirs, props); + } + } + } else { + boolean matching = CollectionUtils + .isEqualCollection(initContext.extensionDirs, extensionsDirs); + if (!matching) { + throw new IllegalStateException( + "Cannot reinitialize and extension/framework directories cannot change"); + } + } + } + + /** + * Should be called at most once. + */ + private InitContext load(final FileSystemManager fileSystemManager, + final List<FileObject> extensionsDirs, BundleProperties props) + throws FileSystemException, ClassNotFoundException, URISyntaxException { + // get the system classloader + final ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); + + // find all bundle files and create class loaders for them. --- End diff -- I agree this is efficiency only and we should tackle it in a follow-on. However, I don't understand what it means that we (can?) only use one of the loaded extensions. I didn't see a mechanism for that. It certainly is not a characteristic of the NAR environment (where almost all the "built-in" processors are actually NARs loaded at startup time). Can you please explain further? > Create a plugin system for Metron based on 'NAR' > ------------------------------------------------ > > Key: METRON-777 > URL: https://issues.apache.org/jira/browse/METRON-777 > Project: Metron > Issue Type: New Feature > Reporter: Otto Fowler > Assignee: Otto Fowler > > The success of the Metron project will be greatly dependent on community > participation, and with that the ability to adapt and extend Metron without > having to maintain a fork of the project. > As organizations and individuals look to extend the Metron system with custom > parsers, enrichments, and stellar functions that may be proprietary in > nature, the ability to develop and deploy these extensions outside the Metron > code base is critically important. > To that end, and after community discussion and proposal we create or > formalize the 'plugin' development story in Metron. > The proposal is to adapt the Apache Nifi NAR system for use in Metron. This > will provide the system with: > * archetype(s) for developer projects and independent development > * defined packaging and metadata for 'plugin' products > * loading and instantiation with classloader isolation capabilities > * removing the necessity for shading plugin jars > These capabilities will also enable other features, such as plugin lifecycle, > plugin configuration+redeployment, and other things. > The plugin archetypes and their installation will be a followon -- This message was sent by Atlassian JIRA (v6.4.14#64029)