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

Example 26 with Plugin

use of org.bukkit.plugin.Plugin in project Bukkit by Bukkit.

the class VersionCommand method execute.

@Override
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
    if (!testPermission(sender))
        return true;
    if (args.length == 0) {
        sender.sendMessage("This server is running " + Bukkit.getName() + " version " + Bukkit.getVersion() + " (Implementing API version " + Bukkit.getBukkitVersion() + ")");
    } else {
        StringBuilder name = new StringBuilder();
        for (String arg : args) {
            if (name.length() > 0) {
                name.append(' ');
            }
            name.append(arg);
        }
        String pluginName = name.toString();
        Plugin exactPlugin = Bukkit.getPluginManager().getPlugin(pluginName);
        if (exactPlugin != null) {
            describeToSender(exactPlugin, sender);
            return true;
        }
        boolean found = false;
        pluginName = pluginName.toLowerCase();
        for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
            if (plugin.getName().toLowerCase().contains(pluginName)) {
                describeToSender(plugin, sender);
                found = true;
            }
        }
        if (!found) {
            sender.sendMessage("This server is not running any plugin by that name.");
            sender.sendMessage("Use /plugins to get a list of plugins.");
        }
    }
    return true;
}

Example 27 with Plugin

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

the class MixedPluginManager method fireEvent.

private void fireEvent(Event event) {
    HandlerList handlers = event.getHandlers();
    RegisteredListener[] listeners = handlers.getRegisteredListeners();
    for (RegisteredListener registration : listeners) {
        if (!registration.getPlugin().isEnabled()) {
            continue;
        }
        try {
            registration.callEvent(event);
        } catch (AuthorNagException ex) {
            Plugin plugin = registration.getPlugin();
            if (plugin.isNaggable()) {
                plugin.setNaggable(false);
                server.getLogger().log(Level.SEVERE, String.format("Nag author(s): '%s' of '%s' about the following: %s", plugin.getDescription().getAuthors(), plugin.getDescription().getFullName(), ex.getMessage()));
            }
        } catch (Throwable ex) {
            server.getLogger().log(Level.SEVERE, "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName(), ex);
        }
    }
}

Example 28 with Plugin

use of org.bukkit.plugin.Plugin 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 29 with Plugin

use of org.bukkit.plugin.Plugin in project Bukkit by Bukkit.

the class MetadataStoreBase method setMetadata.

/**
     * Adds a metadata value to an object. Each metadata value is owned by a
     * specific {@link Plugin}. If a plugin has already added a metadata value
     * to an object, that value will be replaced with the value of {@code
     * newMetadataValue}. Multiple plugins can set independent values for the
     * same {@code metadataKey} without conflict.
     * <p>
     * Implementation note: I considered using a {@link
     * java.util.concurrent.locks.ReadWriteLock} for controlling access to
     * {@code metadataMap}, but decided that the added overhead wasn't worth
     * the finer grained access control.
     * <p>
     * Bukkit is almost entirely single threaded so locking overhead shouldn't
     * pose a problem.
     *
     * @param subject The object receiving the metadata.
     * @param metadataKey A unique key to identify this metadata.
     * @param newMetadataValue The metadata value to apply.
     * @see MetadataStore#setMetadata(Object, String, MetadataValue)
     * @throws IllegalArgumentException If value is null, or the owning plugin
     *     is null
     */
public synchronized void setMetadata(T subject, String metadataKey, MetadataValue newMetadataValue) {
    Validate.notNull(newMetadataValue, "Value cannot be null");
    Plugin owningPlugin = newMetadataValue.getOwningPlugin();
    Validate.notNull(owningPlugin, "Plugin cannot be null");
    String key = disambiguate(subject, metadataKey);
    Map<Plugin, MetadataValue> entry = metadataMap.get(key);
    if (entry == null) {
        entry = new WeakHashMap<Plugin, MetadataValue>(1);
        metadataMap.put(key, entry);
    }
    entry.put(owningPlugin, newMetadataValue);
}

Example 30 with Plugin

use of org.bukkit.plugin.Plugin in project Towny by ElgarL.

the class NationCommand method nationInviteTown.

private static void nationInviteTown(Player player, Nation nation, Town town) throws AlreadyRegisteredException {
    Plugin test = plugin.getServer().getPluginManager().getPlugin("Questioner");
    Resident townMayor = town.getMayor();
    if (TownySettings.isUsingQuestioner() && test != null && test instanceof Questioner && test.isEnabled()) {
        Questioner questioner = (Questioner) test;
        questioner.loadClasses();
        List<Option> options = new ArrayList<Option>();
        options.add(new Option(TownySettings.questionerAccept(), new JoinNationTask(townMayor, nation)));
        options.add(new Option(TownySettings.questionerDeny(), new ResidentNationQuestionTask(townMayor, nation) {

            @Override
            public void run() {
                TownyMessaging.sendNationMessage(nation, String.format(TownySettings.getLangString("msg_deny_invite"), getResident().getName()));
            }
        }));
        Question question = new Question(townMayor.getName(), String.format(TownySettings.getLangString("msg_invited"), nation.getName()), options);
        try {
            plugin.appendQuestion(questioner, question);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    } else {
        nation.addTown(town);
        plugin.resetCache();
        TownyUniverse.getDataSource().saveTown(town);
    }
}