public AliveDashboardMediator(Shell shell, DashboardPart dashboardPart) { this.dashboardPart = dashboardPart; state = new AliveDashboardState(); locations = new HashMap<String, ActionContainer>(); contributions = new HashMap<DashboardActionDescriptor, IFigure>(); this.shell = shell; IConfigurationElement[] config = Platform.getExtensionRegistry() .getConfigurationElementsFor("net.sf.ictalive.aliveclipse.dashboard.actions"); for (IConfigurationElement ce : config) try { Object o = ce.createExecutableExtension("class"); if (o instanceof PluggedInDashboardAction<?>) { PluggedInDashboardAction<AliveDashboardState> pluggedInAction = (PluggedInDashboardAction<AliveDashboardState>) o; if (pluggedInAction.dashboardActionId() == null) Plugin.getDefault() .getLog() .log( Plugin.createError( "IDashboardAction plugin has null dashboardActionId.", null)); else pluggedInActions.put(pluggedInAction.dashboardActionId(), pluggedInAction); } } catch (CoreException e1) { e1.printStackTrace(); } }
public Collection<Class<? extends CloseableIndexComponent>> indexServices() { List<Class<? extends CloseableIndexComponent>> services = Lists.newArrayList(); for (Plugin plugin : plugins.values()) { services.addAll(plugin.indexServices()); } return services; }
public static void modalityChanged(int paramInt, boolean paramBoolean) { PerPluginInfo localPerPluginInfo = (PerPluginInfo) pluginInfoMap.get(new Integer(paramInt)); if (localPerPluginInfo == null) return; final AppletID localAppletID = new AppletID(paramInt); if (paramBoolean) { final int i = localPerPluginInfo.modalityPushed(); final Plugin localPlugin = localPerPluginInfo.getPlugin(); localPlugin.invokeLater( new Runnable() { private final ModalitySupport.PerPluginInfo val$info; private final AppletID val$id; private final int val$depth; private final Plugin val$plugin; public void run() { if (this.val$info.getPlugin().getActiveJSCounter() > 0) { this.val$info.modalityPopped(); return; } while ((!JVMManager.getManager().appletExited(localAppletID)) && (this.val$info.getModalityDepth() >= i)) localPlugin.waitForSignalWithModalBlocking(); localPlugin.notifyMainThread(); } }); } else { localPerPluginInfo.modalityPopped(); } }
public Collection<Class<? extends Module>> indexModules() { List<Class<? extends Module>> modules = Lists.newArrayList(); for (Plugin plugin : plugins.values()) { modules.addAll(plugin.indexModules()); } return modules; }
public Collection<Class<? extends LifecycleComponent>> services() { List<Class<? extends LifecycleComponent>> services = Lists.newArrayList(); for (Plugin plugin : plugins.values()) { services.addAll(plugin.services()); } return services; }
private Map<String, Plugin> loadPluginsFromClasspath(Settings settings) { Map<String, Plugin> plugins = newHashMap(); Enumeration<URL> pluginUrls = null; try { pluginUrls = settings.getClassLoader().getResources("es-plugin.properties"); } catch (IOException e) { logger.warn("Failed to find plugins from classpath", e); } while (pluginUrls.hasMoreElements()) { URL pluginUrl = pluginUrls.nextElement(); Properties pluginProps = new Properties(); InputStream is = null; try { is = pluginUrl.openStream(); pluginProps.load(is); String sPluginClass = pluginProps.getProperty("plugin"); Class<?> pluginClass = settings.getClassLoader().loadClass(sPluginClass); Plugin plugin = (Plugin) pluginClass.newInstance(); plugins.put(plugin.name(), plugin); } catch (Exception e) { logger.warn("Failed to load plugin from [" + pluginUrl + "]", e); } finally { if (is != null) { try { is.close(); } catch (IOException e) { // ignore } } } } return plugins; }
public void logSevere(String message) { uLogger.severe(String.format("[%d] %s", Thread.currentThread().getId(), message)); final int maxSevereLogsToDump = 10; // could consider settings, but nah! if (currentSevereCnt.incrementAndGet() < maxSevereLogsToDump) { final String dumpLogFilename = String.format("%d.dump.log", new Date().getTime()); final String dumpLogFilePath = plugin.getDataFolder().toString() + File.separator + dumpLogFilename; try { PrintWriter out = new PrintWriter(dumpLogFilePath); out.println(String.format("[%d] %s", Thread.currentThread().getId(), message)); out.flush(); out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } } if (plugin.settings.devUser == null) { return; } final Player player = plugin.getServer().getPlayer(plugin.settings.devUser); if (player != null && player.isOnline()) { player.sendMessage( "Omniscient error: " + message.substring(0, Math.min(message.length() - 1, 30))); } }
/* * (non-Javadoc) * * @see jframe.core.plugin.PluginContext#regPlugins(java.util.Collection, * java.util.Comparator) */ public void regPlugins(Collection<Plugin> plugins, Comparator<? super Plugin> comparator) { if (plugins == null || plugins.size() == 0) return; if (comparator == null) { comparator = new PluginComparator(PluginComparator.TYPE.START); } TreeSet<Plugin> set = new TreeSet<Plugin>(comparator); for (Plugin p : plugins) { if (!set.add(p)) _LOG.warn("Found repeated plugin: " + p.getName()); } Iterator<Plugin> iter = set.iterator(); Plugin p = null; while (iter.hasNext()) { p = iter.next(); try { regPlugin(p); } catch (Exception e) { _LOG.error( "When invoke pluginContext.regPlugin(), plugin name is " + p.getName() + " " + e.getMessage()); unregPlugin(p); } iter.remove(); } }
private void resolveDeleteByDependency() { // delete by depend boolean hasModifications = true; while (hasModifications) { log.debug("Check uninstall dependencies"); hasModifications = false; for (Plugin plugin : deletions) { if (!additions.contains(plugin)) { for (Plugin dep : getDependants(plugin)) { if (!deletions.contains(dep) && dep.isInstalled()) { log.debug("Add to deletions: " + dep); deletions.add(dep); hasModifications = true; } if (additions.contains(dep)) { log.debug("Remove from additions: " + dep); additions.remove(dep); hasModifications = true; } } } if (hasModifications) { break; // prevent ConcurrentModificationException } } } }
private DetectorFactoryCollection( boolean loadCore, boolean forceLoad, @Nonnull Collection<Plugin> pluginsToLoad, @Nonnull Collection<Plugin> enabledPlugins) { if (loadCore) { loadCorePlugin(); } for (Plugin plugin : pluginsToLoad) { if (forceLoad || plugin.isGloballyEnabled() && !plugin.isCorePlugin()) { loadPlugin(plugin); if (!enabledPlugins.contains(plugin)) { enabledPlugins.add(plugin); } } } setGlobalOptions(); updateChecker = new UpdateChecker(this); pluginsToUpdate = combine(enabledPlugins); // There are too many places where the detector factory collection can be created, // and in many cases it has nothing to do with update checks, like Plugin#addCustomPlugin(URI). // Line below commented to allow custom plugins be loaded/registered BEFORE we // start to update something. The reason is that custom plugins // can disable update globally OR just will be NOT INCLUDED in the update check! // updateChecker.checkForUpdates(pluginsToUpdate, false); }
public void enablePlugin(final Plugin plugin) { if (!(plugin instanceof JavaPlugin)) { throw new IllegalArgumentException("Plugin is not associated with this PluginLoader"); } if (!plugin.isEnabled()) { JavaPlugin jPlugin = (JavaPlugin) plugin; String pluginName = jPlugin.getDescription().getName(); if (!loaders.containsKey(pluginName)) { loaders.put(pluginName, (PluginClassLoader) jPlugin.getClassLoader()); } try { jPlugin.setEnabled(true); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred while enabling " + plugin.getDescription().getFullName() + " (Is it up to date?): " + ex.getMessage(), ex); } // Perhaps abort here, rather than continue going, but as it stands, // an abort is not possible the way it's currently written server.getPluginManager().callEvent(new PluginEnableEvent(plugin)); } }
private void resolveInstallByDependency() { // resolve dependencies boolean hasModifications = true; while (hasModifications) { log.debug("Check install dependencies: " + additions); hasModifications = false; for (Plugin plugin : additions) { for (String pluginID : plugin.getDepends()) { Plugin depend = getPluginByID(pluginID); if (!depend.isInstalled() || deletions.contains(depend)) { if (!additions.contains(depend)) { log.debug("Add to install: " + depend); additions.add(depend); hasModifications = true; } } } if (hasModifications) { break; // prevent ConcurrentModificationException } } } }
/** Create worker-specific fileinstall.cfg file for the master. */ public void confCreate(final String worker) { ensureConf(); final Conf conf = conf(); if (!ResourceUtil.hasProject(worker)) { Plugin.logWarn("Project#confCreate: missing project: " + worker); return; } final Map<String, String> variables = // Conf.variables(ResourceUtil.workspacePath(), worker, ResourceUtil.projectPath(worker)); final String path = ConfUtil.replace( // conf.fileinstallPath(), variables); final String tempalte = ConfUtil.replace( // conf.fileinstallTemplate(), variables); final File file = ProjectUtil.file(project(), path); try { FileUtil.writeTextFile(file, tempalte); Plugin.logOK("Project#confCreate file: " + file); } catch (final Throwable e) { Plugin.logErrr("Project#confCreate failure", e); } }
@UnsafeMethod public synchronized void enablePlugin(Plugin plugin) { if (!CommonPlugin.class.isAssignableFrom(plugin.getClass())) { throw new IllegalArgumentException( "Cannot enable plugin with this PluginLoader as it is of the wrong type!"); } if (!plugin.isEnabled()) { CommonPlugin cp = (CommonPlugin) plugin; String name = cp.getDescription().getName(); if (!loaders.containsKey(name)) { loaders.put(name, (CommonClassLoader) cp.getClassLoader()); } try { cp.setEnabled(true); cp.onEnable(); } catch (Throwable e) { engine .getLogger() .log( Level.SEVERE, "An error occured when enabling '" + plugin.getDescription().getFullName() + "': " + e.getMessage(), e); } engine.getEventManager().callEvent(new PluginEnableEvent(cp)); } }
/** * 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; }
/** Loads all plugins, calling onLoad, &c. */ private void loadPlugins() { // clear the map commandMap.clearCommands(); commandMap.register("glowstone", new ColorCommand("colors")); commandMap.register("glowstone", new TellrawCommand()); File folder = new File(config.getString(ServerConfig.Key.PLUGIN_FOLDER)); if (!folder.isDirectory() && !folder.mkdirs()) { logger.log(Level.SEVERE, "Could not create plugins directory: " + folder); } // clear plugins and prepare to load pluginManager.clearPlugins(); pluginManager.registerInterface(JavaPluginLoader.class); Plugin[] plugins = pluginManager.loadPlugins(folder); // call onLoad methods for (Plugin plugin : plugins) { try { plugin.onLoad(); } catch (Exception ex) { logger.log(Level.SEVERE, "Error loading " + plugin.getDescription().getFullName(), ex); } } }
/** 从配置文件装载系统配置信息 */ public void initialize() throws PluginException { try { Element sysconfig = Plugin.getRoot().getElement("sysconfig"); DEBUG = Boolean.valueOf(sysconfig.getAttributeValue("debug")); ERROR_PAGE = sysconfig.getElementText("error-page"); CACHE_PATH = sysconfig.getElementText("cache-path"); MvcPlugin.getMvcs().clear(); Element mvc = Plugin.getRoot().getElement("mvc"); // autoInject=Boolean.valueOf(mvc.getAttributeValue("auto-inject")); // paramIntercept=Boolean.valueOf(mvc.getAttributeValue("param-intercept")); String _useDao = mvc.getAttributeValue("use-dao"); USE_DAO = !(_useDao == null || _useDao.equalsIgnoreCase("false")); if (USE_DAO) { DAOFactory.getInstance().createDAO().close(); } Element modules = mvc.getElement("modules"); for (int i = 0; i < modules.getChildCount(); i++) { Element module = (Element) modules.getElement(i); if (module != null) { MvcPlugin.getMvcs().add(module.getText()); } } } catch (UtilException e) { throw new PluginException(e); } }
/** Called when Plugin is destroyed. */ public void onDestroy() { Enumeration e = this.plugins.elements(); while (e.hasMoreElements()) { Plugin plugin = (Plugin) e.nextElement(); plugin.onDestroy(); } }
@SuppressWarnings("unchecked") private static void startPlugins() { logger.info("Loading available plugins"); final Collection<File> botJars = FileUtils.listFiles(pluginsDirecotry, new String[] {"jar"}, false); for (File botJar : botJars) { try { JarFile jar = new JarFile(botJar); ZipEntry ze = jar.getEntry("plugin.yml"); if (ze == null) throw new RuntimeException("Plugin has no plugin.yml file!"); InputStream is = jar.getInputStream(ze); YAMLNode n = new YAMLNode(new Yaml().loadAs(is, Map.class), true); String mainClass = n.getString("mainClass"); String name = n.getString("name"); URLClassLoader loader = new URLClassLoader(new URL[] {botJar.toURI().toURL()}, Chatty.class.getClassLoader()); Plugin plugin = loader.loadClass(mainClass).asSubclass(Plugin.class).newInstance(); plugin.start(); PLUGIN_INFO.put(name, new PluginInfo(name, plugin, n)); logger.info("Loaded plugin '{}'", name); } catch (Exception e) { logger.error("Failed to load plugin from {}", botJar.getName()); e.printStackTrace(); } } logger.info("Loaded {} plugin(s)", PLUGIN_INFO.size()); }
private Plugin getPluginByID(String id) { for (Plugin plugin : allPlugins.keySet()) { if (plugin.getID().equals(id)) { return plugin; } } throw new RuntimeException("Plugin not found by ID: " + id); }
public static void addOpenPort(int port, Protocol protocol, String service, String version) { Port p = new Port(port, protocol, service, version); getCurrentTarget().addOpenPort(p); for (Plugin plugin : getPluginsForTarget()) { plugin.onTargetNewOpenPort(getCurrentTarget(), p); } }
/** Returns a list of all the plugins with the given {@code pluginClass}. */ public <T extends Plugin> List<T> findPlugins(Class<T> pluginClass) { List<T> plugins = new ArrayList<T>(); for (Plugin plugin : getAllPlugins(getState().getDatabase())) { if (pluginClass.isInstance(plugin) && plugin.getTool() != null) { plugins.add((T) plugin); } } return plugins; }
/** * Returns the {@link de.xirp.profile.Plugin plugins} for the specified plugin main class * associated with this robot. * * @param pluginMainClass The main class of the plugin. * @return The list of plugins or <code>null</code> if no plugin was found. * @see de.xirp.profile.Plugin */ public List<Plugin> getPlugins(String pluginMainClass) { List<Plugin> lst = new ArrayList<Plugin>(); for (Plugin plugin : getPlugins().getPlugins()) { if (plugin.getClassName().equalsIgnoreCase(pluginMainClass)) { lst.add(plugin); } } return lst; }
private void appendPluginSettings(StringBuffer buffer) { if (plugins.size() > 0) { Iterator<Plugin> iterator = plugins.iterator(); while (iterator.hasNext()) { Plugin plugin = iterator.next(); plugin.definePluginSettings(buffer); } } }
public static ArrayList<Plugin> getPluginsForTarget(Target target) { ArrayList<Plugin> filtered = new ArrayList<Plugin>(); if (target != null) { for (Plugin plugin : mPlugins) if (plugin.isAllowedTarget(target)) filtered.add(plugin); } return filtered; }
/** * Locate a plugin with the given name. Plugins are identified by their class names (without * package name). * * @param pluginName The name of the plugin (the base class name) * @return the Plugin instance or null if not found. */ public Plugin getPlugin(String pluginName) { for (Plugin plugin : mPlugins) { String name = plugin.getClass().getSimpleName(); if (name.equals(pluginName)) { return plugin; } } return null; }
public static void startAll() { for (String pluginName : AppConfig.getPlugins()) { Plugin plugin = get(pluginName); if (plugin != null) { logger.warn("Starting plugin " + pluginName); plugin.start(); } } }
/** * Unloads the plugin. The effectively shuts the plugin down and removes it from the * PluginRegistry's resource loaders. * * @throws Exception */ public synchronized void unload() throws Exception { if (plugin != null) { plugin.stop(); // it's important that the plugin be removed from the resource loading system after shutdown // in // case the plugin needs to access the resource loader during shutdown registry.removeResourceLoader(plugin.getName()); } loaded = false; }
/** * Loads the plugin from the PluginLoader. This will also start the Plugin and add it to the * PluginRegistry's resoure loaders. */ public synchronized void load() throws Exception { plugin = loader.load(); plugin.setSuppressStartupFailure(suppressStartupFailure); // it's important that the plugin is added to the resource loading system prior to startup // because // startup may need to grab services registry.addResourceLoader(plugin); plugin.start(); loaded = true; }
private void resolveInstallLibs() { for (Plugin plugin : additions) { Map<String, String> libs = plugin.getLibs(plugin.getCandidateVersion()); for (String lib : libs.keySet()) { if (Plugin.getLibInstallPath(lib) == null) { libAdditions.put(lib, libs.get(lib)); } } } }