001: /*
002: * Copyright 2005-2006 The Kuali Foundation.
003: *
004: *
005: * Licensed under the Educational Community License, Version 1.0 (the "License");
006: * you may not use this file except in compliance with the License.
007: * You may obtain a copy of the License at
008: *
009: * http://www.opensource.org/licenses/ecl1.php
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: package edu.iu.uis.eden.plugin;
018:
019: /**
020: * A PluginEnvironment represents a Plugin and the PluginLoader from which it was loaded.
021: * Grouping these together allows us to execute a reload of the Plugin since the Plugin
022: * itself is not responsible for handling how it's own loading or reloading.
023: *
024: * <p>The PluginEnvironment also keeps a reference to the PluginRegistry because this
025: * allows it to add and remove Plugins as child resource loaders of the registry.
026: *
027: * @author ewestfal
028: */
029: public class PluginEnvironment implements Reloadable {
030:
031: private boolean loaded = false;
032: private Plugin plugin;
033: private final PluginLoader loader;
034: private final PluginRegistry registry;
035: private boolean supressStartupFailure = true;
036:
037: /**
038: * Constructs an unloaded PluginEnvironment from the given PluginLoader and PluginRegistry.
039: * The environment will not be loaded until the first time that load() is executed.
040: */
041: public PluginEnvironment(PluginLoader loader,
042: PluginRegistry registry) {
043: this .loader = loader;
044: this .registry = registry;
045: }
046:
047: /**
048: * Constructs a PluginEnvironment representing the given loaded Plugin. Environments created
049: * in this manner will indicate that they are loaded from the moment they are constructed.
050: */
051: public PluginEnvironment(Plugin plugin, PluginLoader loader,
052: PluginRegistry registry) {
053: this (loader, registry);
054: this .plugin = plugin;
055: this .loaded = true;
056: }
057:
058: /**
059: * Returns true if this environment has been loaded, false otherwise. If this method returns
060: * false then getPlugin() may return null if the environment was never loaded after construction.
061: */
062: public boolean isLoaded() {
063: return loaded;
064: }
065:
066: /**
067: * Returns a boolean indicating whether or not this PluginEnvironment is truly reloadable.
068: *
069: * This will return false if the Plugin represents a plugin which can not be reloaded
070: * (like the institutional plugin).
071: */
072: public boolean isReloadable() {
073: // TODO for now the institutional plugin is not reloadable
074: return !PluginUtils.isInstitutionalPlugin(plugin);
075: }
076:
077: /**
078: * Indicates whether or not a reload of this environment is needed. If this method
079: * returns true, it should continue to return true until a reload() is executed.
080: */
081: public synchronized boolean isReloadNeeded() {
082: return loader.isModified();
083: }
084:
085: /**
086: * Reloads the environment by effectively executing an unload() followed by a load().
087: */
088: public synchronized void reload() throws Exception {
089: unload();
090: load();
091: }
092:
093: /**
094: * Loads the plugin from the PluginLoader. This will also start the Plugin and add it
095: * to the PluginRegistry's resoure loaders.
096: */
097: public synchronized void load() throws Exception {
098: plugin = loader.load();
099: plugin.setSupressStartupFailure(supressStartupFailure);
100: // it's important that the plugin is added to the resource loading system prior to startup because
101: // startup may need to grab services
102: registry.addResourceLoader(plugin);
103: plugin.start();
104: loaded = true;
105: }
106:
107: /**
108: * Unloads the plugin. The effectively shuts the plugin down and removes it from the
109: * PluginRegistry's resource loaders.
110: * @throws Exception
111: */
112: public synchronized void unload() throws Exception {
113: plugin.stop();
114: // it's important that the plugin be removed from the resource loading system after shutdown in
115: // case the plugin needs to access the resource loader during shutdown
116: registry.removeResourceLoader(plugin.getName());
117: loaded = false;
118: }
119:
120: /**
121: * Gets the Plugin represented by this environment. May be null if this environment has not
122: * yet been loaded.
123: */
124: public Plugin getPlugin() {
125: return plugin;
126: }
127:
128: /**
129: * Gets the PluginLoader which loaded the Plugin in this environment.
130: */
131: public PluginLoader getLoader() {
132: return loader;
133: }
134:
135: /**
136: * By default, startup failure is supressed. If it is indicated that startup failure
137: * supression is not desired, then startup errors will be thrown directly from calls to
138: * load().
139: */
140: public void setSupressStartupFailure(boolean supressStartupFailure) {
141: this.supressStartupFailure = supressStartupFailure;
142: }
143:
144: }
|