Examples with PluginLoader org.bukkit.plugin.PluginLoader used on opensource projects

Example 1 with PluginLoader

use of org.bukkit.plugin.PluginLoader in project Dragonet-Legacy by DragonetMC.

the class MixedPluginManager method loadPlugin.

/**
 * Loads the plugin in the specified file
 * <p>
 * File must be valid according to the current enabled Plugin interfaces
 *
 * @param file File containing the plugin to load
 * @return The Plugin loaded, or null if it was invalid
 * @throws InvalidPluginException Thrown when the specified file is not a
 *     valid plugin
 * @throws UnknownDependencyException If a required dependency could not
 *     be found
 */
public synchronized Plugin loadPlugin(File file) throws InvalidPluginException, UnknownDependencyException {
    Validate.notNull(file, "File cannot be null");
    checkUpdate(file);
    Set<Pattern> filters = fileAssociations.keySet();
    Plugin result = null;
    for (Pattern filter : filters) {
        String name = file.getName();
        Matcher match = filter.matcher(name);
        if (match.find()) {
            PluginLoader loader = fileAssociations.get(filter);
            result = loader.loadPlugin(file);
        }
    }
    if (result != null) {
        plugins.add(result);
        lookupNames.put(result.getDescription().getName(), result);
    }
    return result;
}

Example 2 with PluginLoader

use of org.bukkit.plugin.PluginLoader in project Dragonet-Legacy by DragonetMC.

the class MixedPluginManager method loadPlugins.

/**
 * Loads the array of plugins
 *
 * @param files Array of plugin files to load
 * @param sourceFolder Containing folder path name string for error messages
 * @return
 */
public Plugin[] loadPlugins(File[] files, String sourceFolder) {
    List<Plugin> result = new ArrayList<Plugin>();
    Set<Pattern> filters = fileAssociations.keySet();
    Map<String, File> plugins = new HashMap<String, File>();
    Set<String> loadedPlugins = new HashSet<String>();
    Map<String, Collection<String>> dependencies = new HashMap<String, Collection<String>>();
    Map<String, Collection<String>> softDependencies = new HashMap<String, Collection<String>>();
    // This is where it figures out all possible plugins
    for (File file : files) {
        // Skip plugins in the ignore set
        try {
            URL url = file.toURI().toURL();
            if (ignoreURLs != null && ignoreURLs.contains(file.toURI().toURL())) {
                continue;
            }
        } catch (MalformedURLException ex) {
        // ignore
        }
        PluginLoader loader = null;
        for (Pattern filter : filters) {
            Matcher match = filter.matcher(file.getName());
            if (match.find()) {
                loader = fileAssociations.get(filter);
            }
        }
        if (loader == null)
            continue;
        PluginDescriptionFile description = null;
        try {
            description = loader.getPluginDescription(file);
            String name = description.getName();
            if (name.equalsIgnoreCase("bukkit") || name.equalsIgnoreCase("minecraft") || name.equalsIgnoreCase("mojang")) {
                server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "': Restricted Name");
                continue;
            } else if (description.getRawName().indexOf(' ') != -1) {
                server.getLogger().warning(String.format("Plugin `%s' uses the space-character (0x20) in its name `%s' - this is discouraged", description.getFullName(), description.getRawName()));
            }
        } catch (InvalidDescriptionException ex) {
            server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "'", ex);
            continue;
        }
        File replacedFile = plugins.put(description.getName(), file);
        if (replacedFile != null) {
            server.getLogger().severe(String.format("Ambiguous plugin name `%s' for files `%s' and `%s' in `%s'", description.getName(), file.getPath(), replacedFile.getPath(), sourceFolder));
        }
        Collection<String> softDependencySet = description.getSoftDepend();
        if (softDependencySet != null && !softDependencySet.isEmpty()) {
            if (softDependencies.containsKey(description.getName())) {
                // Duplicates do not matter, they will be removed together if applicable
                softDependencies.get(description.getName()).addAll(softDependencySet);
            } else {
                softDependencies.put(description.getName(), new LinkedList<String>(softDependencySet));
            }
        }
        Collection<String> dependencySet = description.getDepend();
        if (dependencySet != null && !dependencySet.isEmpty()) {
            dependencies.put(description.getName(), new LinkedList<String>(dependencySet));
        }
        Collection<String> loadBeforeSet = description.getLoadBefore();
        if (loadBeforeSet != null && !loadBeforeSet.isEmpty()) {
            for (String loadBeforeTarget : loadBeforeSet) {
                if (softDependencies.containsKey(loadBeforeTarget)) {
                    softDependencies.get(loadBeforeTarget).add(description.getName());
                } else {
                    // softDependencies is never iterated, so 'ghost' plugins aren't an issue
                    Collection<String> shortSoftDependency = new LinkedList<String>();
                    shortSoftDependency.add(description.getName());
                    softDependencies.put(loadBeforeTarget, shortSoftDependency);
                }
            }
        }
    }
    while (!plugins.isEmpty()) {
        boolean missingDependency = true;
        Iterator<String> pluginIterator = plugins.keySet().iterator();
        while (pluginIterator.hasNext()) {
            String plugin = pluginIterator.next();
            if (dependencies.containsKey(plugin)) {
                Iterator<String> dependencyIterator = dependencies.get(plugin).iterator();
                while (dependencyIterator.hasNext()) {
                    String dependency = dependencyIterator.next();
                    // Dependency loaded
                    if (loadedPlugins.contains(dependency)) {
                        dependencyIterator.remove();
                    // We have a dependency not found
                    } else if (!plugins.containsKey(dependency)) {
                        missingDependency = false;
                        File file = plugins.get(plugin);
                        pluginIterator.remove();
                        softDependencies.remove(plugin);
                        dependencies.remove(plugin);
                        server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "'", new UnknownDependencyException(dependency));
                        break;
                    }
                }
                if (dependencies.containsKey(plugin) && dependencies.get(plugin).isEmpty()) {
                    dependencies.remove(plugin);
                }
            }
            if (softDependencies.containsKey(plugin)) {
                Iterator<String> softDependencyIterator = softDependencies.get(plugin).iterator();
                while (softDependencyIterator.hasNext()) {
                    String softDependency = softDependencyIterator.next();
                    // Soft depend is no longer around
                    if (!plugins.containsKey(softDependency)) {
                        softDependencyIterator.remove();
                    }
                }
                if (softDependencies.get(plugin).isEmpty()) {
                    softDependencies.remove(plugin);
                }
            }
            if (!(dependencies.containsKey(plugin) || softDependencies.containsKey(plugin)) && plugins.containsKey(plugin)) {
                // We're clear to load, no more soft or hard dependencies left
                File file = plugins.get(plugin);
                pluginIterator.remove();
                missingDependency = false;
                try {
                    result.add(loadPlugin(file));
                    loadedPlugins.add(plugin);
                    continue;
                } catch (InvalidPluginException ex) {
                    server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "'", ex);
                }
            }
        }
        if (missingDependency) {
            // We now iterate over plugins until something loads
            // This loop will ignore soft dependencies
            pluginIterator = plugins.keySet().iterator();
            while (pluginIterator.hasNext()) {
                String plugin = pluginIterator.next();
                if (!dependencies.containsKey(plugin)) {
                    softDependencies.remove(plugin);
                    missingDependency = false;
                    File file = plugins.get(plugin);
                    pluginIterator.remove();
                    try {
                        result.add(loadPlugin(file));
                        loadedPlugins.add(plugin);
                        break;
                    } catch (InvalidPluginException ex) {
                        server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "'", ex);
                    }
                }
            }
            // We have no plugins left without a depend
            if (missingDependency) {
                softDependencies.clear();
                dependencies.clear();
                Iterator<File> failedPluginIterator = plugins.values().iterator();
                while (failedPluginIterator.hasNext()) {
                    File file = failedPluginIterator.next();
                    failedPluginIterator.remove();
                    server.getLogger().log(Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + sourceFolder + "': circular dependency detected");
                }
            }
        }
    }
    return result.toArray(new Plugin[result.size()]);
}

Example 3 with PluginLoader

use of org.bukkit.plugin.PluginLoader in project Dragonet-Legacy by DragonetMC.

the class MixedPluginManager method registerInterface.

/**
 * Registers the specified plugin loader
 *
 * @param loader Class name of the PluginLoader to register
 * @throws IllegalArgumentException Thrown when the given Class is not a
 *     valid PluginLoader
 */
@Override
public void registerInterface(Class<? extends PluginLoader> loader) throws IllegalArgumentException {
    PluginLoader instance;
    if (PluginLoader.class.isAssignableFrom(loader)) {
        Constructor<? extends PluginLoader> constructor;
        try {
            constructor = loader.getConstructor(Server.class);
            instance = constructor.newInstance(server);
        } catch (NoSuchMethodException ex) {
            String className = loader.getName();
            throw new IllegalArgumentException(String.format("Class %s does not have a public %s(Server) constructor", className, className), ex);
        } catch (Exception ex) {
            throw new IllegalArgumentException(String.format("Unexpected exception %s while attempting to construct a new instance of %s", ex.getClass().getName(), loader.getName()), ex);
        }
    } else {
        throw new IllegalArgumentException(String.format("Class %s does not implement interface PluginLoader", loader.getName()));
    }
    Pattern[] patterns = instance.getPluginFileFilters();
    synchronized (this) {
        for (Pattern pattern : patterns) {
            fileAssociations.put(pattern, instance);
        }
    }
}