code
stringlengths 3
1.18M
| language
stringclasses 1
value |
|---|---|
/*
* OptionDummy.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options.getinformation;
import java.util.List;
import net.xeoh.plugins.base.PluginInformation;
import net.xeoh.plugins.base.options.GetInformationOption;
/**
* Asks the {@link PluginInformation} plugin to return the author information.
*
* @author Ralf Biedert
*/
public class InformationAuthors implements GetInformationOption {
/** */
private static final long serialVersionUID = -1699032953607764618L;
/**
* Returns a list of all authors that contributed to the plugin.
*
* @since 1.0
* @return The list with all authors.
*/
public List<String> getAuthors() {
return null;
}
}
|
Java
|
/**
* Options to <code>getPlugin()</code>.
*
* @since 1.0
*/
package net.xeoh.plugins.base.options.getplugin;
|
Java
|
/*
* PluginSelector.java
*
* Copyright (c) 2008, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options.getplugin;
import net.xeoh.plugins.base.Plugin;
/**
* You can use this interface to select an appropriate instance of a given
* plugin when querying the plugin manager.
*
* @author Ralf Biedert
*
* @param <T> Type of the plugin.
*/
public interface PluginSelector<T extends Plugin> {
/**
* Return true if you want the specified plugin returned, false otherwise.
*
* @param plugin The plugin for which you are being called.
* @return Return <code>true</code> if you want to select the passed plugin.
*/
public boolean selectPlugin(T plugin);
}
|
Java
|
/*
* OptionDummy.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options.getplugin;
import net.xeoh.plugins.base.annotations.Capabilities;
import net.xeoh.plugins.base.options.GetPluginOption;
/**
* Specifies the method should only consider plugins satisfying all the
* given {@link Capabilities}. This is useful in case there are a number of plugins
* implementing the same interface. With this option, only plugins with the
* specified capabilities are considered. For example, to get a plugin implementing
* the <code>Language</code> and capable of handling English, write:<br/><br/>
*
* <code>
* pluginManager.getPlugin(Language.class, new OptionCapabilities("language:english"));
* </code><br/><br/>
*
* If multiple capabilities are specified only plugins matching all of them are being
* considered. Multiple capabilities MUST be specified within a single option, not as
* multiple options, i.e., write:<br/><br/>
*
* <code>
* new OptionCapabilities("filetype:xml", "filetype:csv", "filetype:raw");
* </code><br/><br/>
*
* @author Ralf Biedert
*/
public class OptionCapabilities implements GetPluginOption {
/** */
private static final long serialVersionUID = -7856506348748868122L;
/** */
private String[] caps;
/**
* Returns plugins that matches all given capabilites.
*
* @param matchingCapabilites The capabilities to consider.
*/
public OptionCapabilities(String... matchingCapabilites) {
this.caps = matchingCapabilites;
}
/**
* Returns the requested capabilities.
*
* @return Array of caps.
*/
public String[] getCapabilities() {
return this.caps;
}
}
|
Java
|
/*
* OptionPluginSelector.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options.getplugin;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.options.GetPluginOption;
import net.xeoh.plugins.base.util.PluginManagerUtil;
/**
* Passes a plugin selector as an option. The selector will be called for each considered plugin.
* The first plugin on which the collector returns <code>true</code> will be returned. For example,
* to select a remote service based on its protocol, write:<br/><br/>
*
* <code>
* getPlugin(RemoteAPI.class, new OptionPluginSelector<RemoteAPI>(new PluginSelector<RemoteAPI>() {<br/>
* public boolean selectPlugin(final RemoteAPI p) {<br/>
* if (p.getPublishMethod() == PublishMethod.JSON) return true;<br/>
* return false;<br/>
* }<br/>
* }));<br/>
* </code><br/><br/>
*
* The plugin selector is especially useful to iterate over all plugins, {@link PluginManagerUtil}
* already does that for you.
*
* @author Ralf Biedert
* @see PluginManager
* @param <P> Type of the plugin.
*/
public final class OptionPluginSelector<P extends Plugin> implements GetPluginOption {
/** */
private static final long serialVersionUID = 6540623006341980932L;
/** */
private PluginSelector<P> value;
/**
* Creates a new selectop option with the given selelector.
*
* @param ps The plugin selector to add.
*/
public OptionPluginSelector(PluginSelector<P> ps) {
this.value = ps;
}
/**
* Returns the passed selector.
*
* @return The selector enclosed.
*/
public PluginSelector<P> getSelector() {
return this.value;
}
}
|
Java
|
/**
* Top level package for core options.
*
* @since 1.0
*/
package net.xeoh.plugins.base.options;
|
Java
|
/*
* OptionSearchAround.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options.addpluginsfrom;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
/**
* When JSPF searches for plugins, use the given class as the initial exploration
* point for a classpath search. Usually this is not needed, but in very special cases
* (like when using an application server), it can help JSPF to find your plugins.<br/><br/>
*
* <code>
* pluginManager.addPluginsFrom(uri, new OptionSearchAround(getClass()));
* </code>
*
* @author Ralf Biedert
* @see PluginManager
*/
public class OptionSearchAround implements AddPluginsFromOption {
/** */
private static final long serialVersionUID = -8362751446846683259L;
/** */
private Class<?> clazz;
public OptionSearchAround(Class<?> clazz) {
this.clazz = clazz;
}
/**
* @return the clazz
*/
public Class<?> getClazz() {
return this.clazz;
}
}
|
Java
|
/**
* Options to <code>addPluginsFrom()</code>.
*
* @since 1.0
*/
package net.xeoh.plugins.base.options.addpluginsfrom;
|
Java
|
/*
* OptionDummy.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options.addpluginsfrom;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
/**
* Asks the PluginManager to print a report after this plugin addition. See the console
* output for more information. This option is a useful tool for debugging plugin problems.
* For example, to print a report after all plugins from a given source have been loaded,
* write:<br/><br/>
*
* <code>
* pluginManager.addPluginsFrom(uri, new OptionReportAfter());
* </code>
*
* @author Ralf Biedert
* @see PluginManager
*/
public class OptionReportAfter implements AddPluginsFromOption {
/** */
private static final long serialVersionUID = -8362751446846683259L;
}
|
Java
|
/*
* GetPluginOption.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options;
import net.xeoh.plugins.base.Option;
import net.xeoh.plugins.base.PluginManager;
/**
* The base type for all <code>getPlugin()</code> options.
*
* @author Ralf Biedert
* @see PluginManager
*/
public interface GetPluginOption extends Option {
//
}
|
Java
|
/*
* GetInformationOption.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options;
import net.xeoh.plugins.base.Option;
import net.xeoh.plugins.base.PluginManager;
/**
* The base type for all <code>getInformation()</code> options.
*
* @author Ralf Biedert
* @see PluginManager
*/
public interface GetInformationOption extends Option {
//
}
|
Java
|
/*
* GetPluginOption.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.options;
import net.xeoh.plugins.base.Option;
import net.xeoh.plugins.base.PluginManager;
/**
* The base type for all <code>addPluginsFrom()</code> options.
*
* @author Ralf Biedert
* @see PluginManager
*/
public interface AddPluginsFromOption extends Option {
//
}
|
Java
|
/*
* PluginInformation.java
*
* Copyright (c) 2008, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base;
import java.util.Collection;
import net.xeoh.plugins.base.annotations.Capabilities;
import net.xeoh.plugins.base.annotations.meta.Author;
import net.xeoh.plugins.base.annotations.meta.Version;
import net.xeoh.plugins.base.options.GetInformationOption;
/**
* Returns various information about plugins, static as well as dynamic.
*
* @author Ralf Biedert
*/
public interface PluginInformation extends Plugin {
/**
* The set of information item that can be requested. <b>S1</b> means a list
* of strings with exactly one element is returnd, <b>S+</b> means a number of
* strings will be returned. In case no information was available an empty
* collection is returned.
*
* @author Ralf Biedert
*/
public static enum Information {
/**
* The author of this plugins (S1).
*
* @see Author
*/
AUTHORS,
/**
* Returns the self proclaimed capabilites of this plugin (S+).
*
* @see Capabilities
*/
CAPABILITIES,
/**
* Version of this plugin (S+). A version number of 10304 will be
* returned as 1.03.04 at index 0. Additional versioning information may be
* provided.
*
* @see Version
*/
VERSION,
/**
* Date when the plugin was initialized (S1). The unix time will be returned.<br/><br/>
*
* TODO: Not implemented yet.
*/
INIT_DATE,
/**
* Returns a single string containing the URI to the classpath item this
* element came from (S1).
*/
CLASSPATH_ORIGIN,
}
/**
* Returns an {@link Information} item about a plugin. For example, to query a plugin's
* classpath origin you would write:<br/><br/>
*
* <code>
* getInformation(Information.CLASSPATH_ORIGIN, plugin);
* </code>
*
* @param item The information item to request.
* @param plugin The plugin for which the information is requested.
*
* @return A collection of strings containing the requested information. The the specific {@link Information}
* item for more details. If nothing sensible was found, an empty collection is returned.
*/
public Collection<String> getInformation(Information item, Plugin plugin);
/**
* Returns an {@link Information} item about a plugin. For example, to query a plugin's
* classpath origin you would write:<br/><br/>
*
* <code>
* getInformation(plugin, InformationOrigin.class);
* </code>
*
* @param plugin The plugin for which the information is requested.
* @param query The information item to request.
*
* @return The appropriate query result.
*/
public <T extends GetInformationOption> T getInformation(Plugin plugin, Class<T> query);
}
|
Java
|
/*
* Spawner.java
*
* Copyright (c) 2008, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.spawning;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.TimerTask;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.annotations.Thread;
import net.xeoh.plugins.base.annotations.Timer;
import net.xeoh.plugins.base.annotations.events.Init;
import net.xeoh.plugins.base.annotations.events.PluginLoaded;
import net.xeoh.plugins.base.annotations.events.Shutdown;
import net.xeoh.plugins.base.diagnosis.channels.tracing.SpawnerTracer;
import net.xeoh.plugins.base.impl.PluginManagerImpl;
import net.xeoh.plugins.base.impl.registry.PluginClassMetaInformation.Dependency;
import net.xeoh.plugins.base.impl.registry.PluginMetaInformation;
import net.xeoh.plugins.base.impl.registry.PluginMetaInformation.PluginLoadedInformation;
import net.xeoh.plugins.base.impl.registry.PluginMetaInformation.PluginStatus;
import net.xeoh.plugins.base.impl.spawning.handler.InjectHandler;
import net.xeoh.plugins.base.util.PluginManagerUtil;
import net.xeoh.plugins.diagnosis.local.Diagnosis;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannel;
import net.xeoh.plugins.diagnosis.local.options.StatusOption;
import net.xeoh.plugins.diagnosis.local.options.status.OptionInfo;
/**
* Spawn a given class.
*
* @author Ralf Biedert
*/
public class Spawner {
/** Used for diagnosic messages */
DiagnosisChannel<String> diagnosis;
/** Main plugin manager */
private final PluginManagerImpl pluginManager;
/**
* Creates a new spawner with the given PluginManager.
*
* @param pmi
*/
public Spawner(final PluginManagerImpl pmi) {
this.pluginManager = pmi;
}
/**
* Destroys a given plugin, halt all timers and threads, calls shutdown methods.
*
* @param plugin
* @param metaInformation
*/
public void destroyPlugin(final Plugin plugin,
final PluginMetaInformation metaInformation) {
log("destroy/start", new OptionInfo("plugin", plugin.getClass().getCanonicalName()));
// Halt all timer tasks
for (final TimerTask timerTask : metaInformation.timerTasks) {
timerTask.cancel();
}
// Halt all timers
for (final java.util.Timer timer : metaInformation.timers) {
timer.cancel();
}
// Halt all threads
for (final java.lang.Thread thread : metaInformation.threads) {
// TODO: Maybe not the best way to terminate.
try {
thread.interrupt();
} catch (final Exception e) {
e.printStackTrace();
}
}
// Call shutdown hooks
callShutdownMethods(plugin);
log("destroy/end", new OptionInfo("plugin", plugin.getClass().getCanonicalName()));
}
/**
* Destroys a given plugin, halt all timers and threads, calls shutdown methods.
*
* @param plugin
* @param metaInformation
*/
public void processThisPluginLoadedAnnotation(final Plugin plugin,
final PluginMetaInformation metaInformation) {
// Get all our annotations.
for (PluginLoadedInformation pli : metaInformation.pluginLoadedInformation) {
final Collection<? extends Plugin> plugins = new PluginManagerUtil(this.pluginManager).getPlugins(pli.baseType);
// For each plugin we have a request, call this plugin.
for (Plugin p : plugins) {
try {
pli.method.invoke(plugin, p);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
pli.calledWith.addAll(plugins);
}
}
/**
* Processes the {@link PluginLoaded} annotation for other plugins for this plugin.
*
* @param newPlugin Newly creatd pluign
*/
public void processOtherPluginLoadedAnnotation(Plugin newPlugin) {
for (Plugin plugin : this.pluginManager.getPluginRegistry().getAllPlugins()) {
final PluginMetaInformation pmi = this.pluginManager.getPluginRegistry().getMetaInformationFor(plugin);
for (PluginLoadedInformation pli : pmi.pluginLoadedInformation) {
final Collection<? extends Plugin> plins = new PluginManagerUtil(this.pluginManager).getPlugins(pli.baseType);
// Check if the new plugin is returned upon request
if (plins.contains(newPlugin)) {
try {
pli.method.invoke(plugin, newPlugin);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
pli.calledWith.add(newPlugin);
}
}
}
}
/**
* Spawn a plugin and process its internal annotations.
*
* @param c Class to spawn from.
* @return .
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public SpawnResult spawnPlugin(final Class c) {
log("spawn/start", new OptionInfo("plugin", c.getCanonicalName()));
// Used for time measurements.
final long startTime = System.nanoTime();
final java.util.Timer timer = new java.util.Timer();
final TimerTask lateMessage = new TimerTask() {
@Override
public void run() {
log("spawn/timeout/toolong", new OptionInfo("plugin", c.getCanonicalName()));
}
};
// Finally load and register plugin
try {
// Schedule late message. (TODO: Make this configurable)
timer.schedule(lateMessage, 250);
// Instanciate the plugin
final Constructor constructor = c.getDeclaredConstructor();
constructor.setAccessible(true);
final Plugin spawnedPlugin = (Plugin) constructor.newInstance();
// In here spawning of the plugin worked
final SpawnResult spawnResult = new SpawnResult(spawnedPlugin);
spawnResult.metaInformation.pluginStatus = PluginStatus.SPAWNED;
spawnResult.metaInformation.spawnTime = System.currentTimeMillis();
// Finally load and register plugin
try {
new InjectHandler(this.pluginManager).init(spawnedPlugin);
// Obtain all methods
final Method[] methods = getMethods(c);
// 2. Call all init methods
final boolean initStatus = callInitMethods(spawnedPlugin, methods);
if (initStatus == false) {
spawnResult.metaInformation.pluginStatus = PluginStatus.FAILED;
return spawnResult;
}
// Initialization complete
spawnResult.metaInformation.pluginStatus = PluginStatus.INITIALIZED;
// 3. Spawn all threads
spawnThreads(spawnResult, methods);
// 4. Spawn timer
spawnTimer(spawnResult, methods);
// 5. Obtain PluginLoaded methods
obtainPluginLoadedMethods(spawnResult, methods);
// Currently running
spawnResult.metaInformation.pluginStatus = PluginStatus.ACTIVE;
log("spawn/end", new OptionInfo("plugin", c.getCanonicalName()));
return spawnResult;
} catch (final Throwable e) {
log("spawn/exception/init", new OptionInfo("plugin", c.getCanonicalName()));
e.printStackTrace();
Throwable cause = e.getCause();
while (cause != null) {
cause.printStackTrace();
cause = cause.getCause();
}
}
return null;
} catch (final Throwable e) {
log("spawn/exception/construct", new OptionInfo("plugin", c.getCanonicalName()));
e.printStackTrace();
Throwable cause = e.getCause();
while (cause != null) {
cause.printStackTrace();
cause = cause.getCause();
}
} finally {
// Halt the late message
timer.cancel();
final long stopTime = System.nanoTime();
final long delta = (stopTime - startTime) / 1000;
log("spawn/duration", new OptionInfo("plugin", c.getCanonicalName()), new OptionInfo("time", ""+ delta));
}
log("spawn/end/abnormal", new OptionInfo("plugin", c.getCanonicalName()));
return null;
}
/**
*
* @param methods
* @returns True if initialization was successful.
* @throws IllegalAccessException
*
*
*/
private boolean callInitMethods(final Plugin spawnedPlugin, final Method[] methods)
throws IllegalAccessException {
log("callinit/start", new OptionInfo("plugin", spawnedPlugin.getClass().getCanonicalName()));
// final Class<? extends Plugin> spawnClass = spawnedPlugin.getClass();
for (final Method method : methods) {
log("callinit/method", new OptionInfo("method", method.getName()));
// Init methods will be marked by the corresponding annotation.
final Init annotation = method.getAnnotation(Init.class);
if (annotation != null) {
log("callinit/method/initannotation", new OptionInfo("method", method.getName()));
try {
final Object invoke = method.invoke(spawnedPlugin, new Object[0]);
if (invoke != null && invoke instanceof Boolean) {
// Check if any init method returns false.
if (((Boolean) invoke).booleanValue() == false) return false;
}
} catch (final IllegalArgumentException e) {
log("callinit/exception/illegalargument", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
log("callinit/end/abnormal", new OptionInfo("plugin", spawnedPlugin.getClass().getCanonicalName()));
e.printStackTrace();
return false;
} catch (final InvocationTargetException e) {
log("callinit/exception/invocationtargetexception", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
log("callinit/end/abnormal", new OptionInfo("plugin", spawnedPlugin.getClass().getCanonicalName()));
e.printStackTrace();
return false;
} catch (final Exception e) {
log("callinit/exception/exception", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
log("callinit/end/abnormal", new OptionInfo("plugin", spawnedPlugin.getClass().getCanonicalName()));
e.printStackTrace();
return false;
}
}
}
log("callinit/end", new OptionInfo("plugin", spawnedPlugin.getClass().getCanonicalName()));
return true;
}
/**
* @param plugin
*/
private void callShutdownMethods(final Plugin plugin) {
log("callshutdown/start", new OptionInfo("plugin", plugin.getClass().getCanonicalName()));
final Class<? extends Plugin> spawnClass = plugin.getClass();
final Method[] methods = spawnClass.getMethods();
for (final Method method : methods) {
log("callshutdown/method", new OptionInfo("method", method.getName()));
// Init methods will be marked by the corresponding annotation.
final Shutdown annotation = method.getAnnotation(Shutdown.class);
if (annotation != null) {
log("callshutdown/method/shutdownannotation", new OptionInfo("method", method.getName()));
try {
method.invoke(plugin, new Object[0]);
} catch (final IllegalArgumentException e) {
log("callshutdown/exception/illegalargument", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
} catch (final InvocationTargetException e) {
log("callinit/exception/invocationtargetexception", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
} catch (final Exception e) {
log("callshutdown/exception/exception", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
}
}
}
log("callshutdown/end", new OptionInfo("plugin", plugin.getClass().getCanonicalName()));
return;
}
/**
* @param c
* @return
*/
private Method[] getMethods(final Class<? extends Plugin> c) {
final Method[] methods = c.getMethods();
return methods;
}
/**
* @param spawnResult
* @param methods
*/
private void spawnThreads(final SpawnResult spawnResult, final Method[] methods) {
log("spawnthreads/start", new OptionInfo("plugin", spawnResult.plugin.getClass().getCanonicalName()));
for (final Method method : methods) {
// Init methods will be marked by the corresponding annotation. New:
// also turn on extended accessibility, so elements don't have to be public
// anymore.
method.setAccessible(true);
final net.xeoh.plugins.base.annotations.Thread annotation = method.getAnnotation(Thread.class);
if (annotation != null) {
final java.lang.Thread t = new java.lang.Thread(new Runnable() {
public void run() {
try {
// TODO: Pass kind of ThreadController as argument 1 (or any
// fitting argument)
method.invoke(spawnResult.plugin, new Object[0]);
} catch (final IllegalArgumentException e) {
log("spawnthreads/exception/illegalargument", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
} catch (final IllegalAccessException e) {
log("spawnthreads/exception/illegalaccess", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
} catch (final InvocationTargetException e) {
log("spawnthreads/exception/invocationtargetexception", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
}
}
});
final String name = spawnResult.plugin.getClass().getName() + "." + method.getName() + "()";
log("spawnthreads/threadstart", new OptionInfo("plugin", spawnResult.plugin.getClass().getCanonicalName()), new OptionInfo("threadname", name));
t.setName(name);
t.setDaemon(annotation.isDaemonic());
t.start();
// Add timer task to list
spawnResult.metaInformation.threads.add(t);
}
}
log("spawnthreads/end", new OptionInfo("plugin", spawnResult.plugin.getClass().getCanonicalName()));
}
/**
* @param spawnResult
* @param methods
*/
@SuppressWarnings("unchecked")
private void obtainPluginLoadedMethods(SpawnResult spawnResult, Method[] methods) {
for (final Method method : methods) {
// New: also turn on extended accessibility, so elements don't have to be
// public anymore.
method.setAccessible(true);
final PluginLoaded annotation = method.getAnnotation(PluginLoaded.class);
if (annotation != null) {
final PluginLoadedInformation pli = new PluginLoadedInformation();
final Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length != 1) {
log("pluginloadedmethods/wrongnumberofparams", new OptionInfo("plugin", spawnResult.plugin.getClass().getCanonicalName()), new OptionInfo("method", method.getName()));
continue;
}
pli.method = method;
pli.baseType = (Class<? extends Plugin>) parameterTypes[0];
// And add result
spawnResult.metaInformation.pluginLoadedInformation.add(pli);
}
}
}
/**
* @param spawnResult
* @param methods
*/
private void spawnTimer(final SpawnResult spawnResult, final Method[] methods) {
log("spawntimers/start", new OptionInfo("plugin", spawnResult.plugin.getClass().getCanonicalName()));
for (final Method method : methods) {
// Init methods will be marked by the corresponding annotation. New: also
// turn on extended accessibility, so elements don't have to be public
// anymore.
method.setAccessible(true);
final net.xeoh.plugins.base.annotations.Timer annotation = method.getAnnotation(Timer.class);
if (annotation != null) {
final java.util.Timer t = new java.util.Timer();
final TimerTask tt = new TimerTask() {
@Override
public void run() {
try {
final Object invoke = method.invoke(spawnResult.plugin, new Object[0]);
if (invoke != null && invoke instanceof Boolean) {
if (((Boolean) invoke).booleanValue()) {
t.cancel();
}
}
} catch (final IllegalArgumentException e) {
log("spawntimers/exception/illegalargument", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
} catch (final IllegalAccessException e) {
log("spawntimers/exception/illegalaccessexception", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
} catch (final InvocationTargetException e) {
log("spawntimers/exception/invocationtargetexception", new OptionInfo("method", method.getName()), new OptionInfo("message", e.getMessage()));
e.printStackTrace();
}
}
};
if (annotation.timerType() == Timer.TimerType.RATE_BASED) {
t.scheduleAtFixedRate(tt, annotation.startupDelay(), annotation.period());
}
if (annotation.timerType() == Timer.TimerType.DELAY_BASED) {
t.schedule(tt, annotation.startupDelay(), annotation.period());
}
// Add timer task to list
spawnResult.metaInformation.timerTasks.add(tt);
spawnResult.metaInformation.timers.add(t);
}
}
log("spawntimers/end", new OptionInfo("plugin", spawnResult.plugin.getClass().getCanonicalName()));
}
/**
* Returns the list of all dependencies the plugin has.
*
* @param pluginClass
* @return .
*/
public Collection<Dependency> getDependencies(Class<? extends Plugin> pluginClass) {
return new InjectHandler(this.pluginManager).getDependencies(pluginClass);
}
/**
* Logs the given message.
*
* @param message
* @param options
*/
void log(String message, StatusOption... options) {
// Try to get the diagnosis
if (this.diagnosis == null) {
// Check if the diagnosis is already there
final Diagnosis diag = this.pluginManager.getDiagnosis();
if(diag==null) return;
// If yes, get the main channel
this.diagnosis = diag.channel(SpawnerTracer.class);
}
this.diagnosis.status(message, options);
}
}
|
Java
|
package net.xeoh.plugins.base.impl.spawning;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.impl.registry.PluginMetaInformation;
/**
* Spawn result, encapsulates the results of our attempt to spawn
* a given plugin.
*
* @author Ralf Biedert
*/
public class SpawnResult {
/** The actual pluggable spawned */
public final Plugin plugin;
/** Information on this plugin */
public final PluginMetaInformation metaInformation;
/**
* Creates a new spawn results.
*
* @param plugin
*/
public SpawnResult(Plugin plugin) {
this.plugin = plugin;
this.metaInformation = new PluginMetaInformation();
}
}
|
Java
|
/*
* AbstractHandler.java
*
* Copyright (c) 2010, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.spawning.handler;
import java.util.logging.Logger;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginManager;
/**
* Handles a certain type of annotations / properties.
*
* @author Ralf Biedert
*/
public abstract class AbstractHandler {
/** */
final PluginManager pluginManager;
/** */
final Logger logger = Logger.getLogger(this.getClass().getName());
/**
* @param pluginManager
*/
public AbstractHandler(PluginManager pluginManager) {
this.pluginManager = pluginManager;
}
/**
* Called when the plugin is initialized
*
* @param plugin
* @throws Exception
*/
public abstract void init(Plugin plugin) throws Exception;
/**
* Called when the plugin is initialized
*
* @param plugin
* @throws Exception
*/
public abstract void deinit(Plugin plugin) throws Exception;
}
|
Java
|
/*
* InjectHandler.java
*
* Copyright (c) 2010, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.spawning.handler;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.annotations.injections.InjectPlugin;
import net.xeoh.plugins.base.impl.registry.PluginClassMetaInformation.Dependency;
import net.xeoh.plugins.base.options.getplugin.OptionCapabilities;
/**
* Handles injections into plugins.
*
* @author Ralf Biedert
*/
public class InjectHandler extends AbstractHandler {
/**
* @param pluginManager
*/
public InjectHandler(PluginManager pluginManager) {
super(pluginManager);
}
/*
* (non-Javadoc)
*
* @see
* net.xeoh.plugins.base.impl.spawning.handler.AbstractHandler#init(net.xeoh.plugins
* .base.Plugin)
*/
@SuppressWarnings("unchecked")
@Override
public void init(Plugin plugin) throws Exception {
// All fields we have a look at
final Field[] fields = plugin.getClass().getFields();
final Method[] methods = plugin.getClass().getMethods();
// Process every field
for (final Field field : fields) {
// Try to get inject annotation. New: also turn on extended accessibility, so
// elements don't have to be public anymore.
field.setAccessible(true);
final InjectPlugin ipannotation = field.getAnnotation(InjectPlugin.class);
// If there is one ..
if (ipannotation != null) {
// Obtain capabilities
final String[] capabilities = ipannotation.requiredCapabilities();
// Handle the plugin-parameter part
// In the default case do an auto-detection ...
final Class<? extends Plugin> typeOfField = (Class<? extends Plugin>) field.getType();
this.logger.fine("Injecting plugin by autodetection (" + typeOfField.getName() + ") into " + plugin.getClass().getName());
field.set(plugin, getEntityForType(typeOfField, capabilities));
}
}
// And setter methods as well (aka Scala hack)
for (Method method : methods) {
// Try to get inject annotation. New: also turn on extended accessibility, so
// elements don't have to be public anymore.
method.setAccessible(true);
final InjectPlugin ipannotation = method.getAnnotation(InjectPlugin.class);
if (ipannotation != null) {
// Obtain capabilities
final String[] capabilities = ipannotation.requiredCapabilities();
// Handle the plugin-parameter part
// In the default case do an auto-detection ...
final Class<? extends Plugin> typeOfMethod = (Class<? extends Plugin>) method.getParameterTypes()[0];
this.logger.fine("Injecting plugin by autodetection (" + typeOfMethod.getName() + ") into " + plugin.getClass().getName());
try {
method.invoke(plugin, getEntityForType(typeOfMethod, capabilities));
} catch (IllegalArgumentException e) {
this.logger.warning("Unable to inject plugin " + typeOfMethod + " into method " + method);
e.printStackTrace();
} catch (InvocationTargetException e) {
this.logger.warning("Unable to inject plugin " + typeOfMethod + " into method " + method);
e.printStackTrace();
}
}
}
}
/*
* (non-Javadoc)
*
* @see
* net.xeoh.plugins.base.impl.spawning.handler.AbstractHandler#deinit(net.xeoh.plugins
* .base.Plugin)
*/
@Override
public void deinit(Plugin plugin) throws Exception {
// TODO Auto-generated method stub
}
/**
* Returns the true plugin interface type for something that accepts
* an @InjectPlugin annotation. This is either the interface directly,
* or some Util that accepts a interface as the first parameter.
*
* @param type
* @return
*/
Class<?> getTrueDependencyInterfaceType(Class<?> type) {
// If it is an interface, return that
if(type.isInterface()) return type;
// In all other cases, return the type of the first parameter of the given class
try {
final Constructor<?>[] declaredConstructors = type.getDeclaredConstructors();
for (Constructor<?> constructor : declaredConstructors) {
final Class<?>[] parameterTypes = constructor.getParameterTypes();
if(parameterTypes.length != 1) continue;
if(parameterTypes[0].isAssignableFrom(type)) return parameterTypes[0];
}
} catch (SecurityException e) {
e.printStackTrace();
}
return null;
}
/**
* Tries to get an entity for the requested type.
*
* @param type
* @return
*/
@SuppressWarnings("unchecked")
Plugin getEntityForType(Class<?> type, String...capabilities) {
// We need that anyways.
Plugin plugin = this.pluginManager.getPlugin((Class<Plugin>) getTrueDependencyInterfaceType(type), new OptionCapabilities(capabilities));
// First check if the requested type is an anctual interface or not. If it is, we simply treat
// it as a plugin, if it is not (i.e., a ordinary class), we treat it as a util wrapper.
if(type.isInterface()) {
return plugin;
}
// In that case, we have to inspect the first parameter of the constructor that accepts itself as a
// paramter.
try {
final Constructor<?>[] constructors = type.getDeclaredConstructors();
for (Constructor<?> constructor : constructors) {
final Class<?>[] parameterTypes = constructor.getParameterTypes();
if(parameterTypes.length != 1) continue;
if(parameterTypes[0].isAssignableFrom(type)) return (Plugin) constructor.newInstance(plugin);
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return null;
}
/**
* Returns the list of all dependencies the plugin has.
*
* @param pluginClass
* @return .
*/
@SuppressWarnings("unchecked")
public Collection<Dependency> getDependencies(Class<? extends Plugin> pluginClass) {
final Collection<Dependency> rval = new ArrayList<Dependency>();
// All fields we have a look at
final Field[] fields = pluginClass.getFields();
final Method[] methods = pluginClass.getMethods();
// Process every field
for (final Field field : fields) {
field.setAccessible(true);
final InjectPlugin ipannotation = field.getAnnotation(InjectPlugin.class);
if (ipannotation == null) continue;
if (ipannotation.isOptional()) continue;
final Dependency d = new Dependency();
d.capabilites = ipannotation.requiredCapabilities();
d.pluginClass = (Class<? extends Plugin>) getTrueDependencyInterfaceType(field.getType());
d.isOptional = ipannotation.isOptional();
rval.add(d);
}
// And setter methods as well (aka Scala hack)
for (Method method : methods) {
method.setAccessible(true);
final InjectPlugin ipannotation = method.getAnnotation(InjectPlugin.class);
if (ipannotation == null) continue;
if (ipannotation.isOptional()) continue;
final Dependency d = new Dependency();
d.capabilites = ipannotation.requiredCapabilities();
d.pluginClass = (Class<? extends Plugin>) getTrueDependencyInterfaceType(method.getParameterTypes()[0]);
d.isOptional = ipannotation.isOptional();
rval.add(d);
}
return rval;
}
}
|
Java
|
/**
* The {@link net.xeoh.plugins.base.impl.PluginManagerFactory} is the framework's entry point and the only class of
* relevance within this package, start exploring here.
*
* @since 1.0
*/
package net.xeoh.plugins.base.impl;
|
Java
|
/*
* PluginConfigurationImpl.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl;
import static net.jcores.jre.CoreKeeper.$;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.logging.Logger;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginInformation;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.annotations.Capabilities;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import net.xeoh.plugins.base.annotations.injections.InjectPlugin;
import net.xeoh.plugins.base.annotations.meta.Author;
import net.xeoh.plugins.base.annotations.meta.Stateless;
import net.xeoh.plugins.base.annotations.meta.Version;
import net.xeoh.plugins.base.impl.registry.PluginMetaInformation;
import net.xeoh.plugins.base.impl.registry.PluginRegistry;
import net.xeoh.plugins.base.options.GetInformationOption;
/**
* TODO: Make plugin threadsafe
*
* @author Ralf Biedert
*
*/
@Author(name = "Ralf Biedert")
@Version(version = 1 * Version.UNIT_MAJOR)
@Stateless
@PluginImplementation
public class PluginInformationImpl implements PluginInformation {
/** */
final Logger logger = Logger.getLogger(this.getClass().getName());
/** */
@InjectPlugin
public PluginManager pluginManager;
/** Dum dum dum dum .... don't touch this ... */
private PluginInformationImpl() { }
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.PluginInformation#getInformation(net.xeoh.plugins.base.
* PluginInformation.Information, net.xeoh.plugins.base.Plugin)
*/
public Collection<String> getInformation(final Information item, final Plugin plugin) {
// Needed to query some special information
final PluginManagerImpl pmi = (PluginManagerImpl) this.pluginManager;
// Prepare return values ...
final Collection<String> rval = new ArrayList<String>();
switch (item) {
case CAPABILITIES:
// Caps are only supported for plugins currently
final String[] caps = getCaps(plugin);
for (final String string : caps) {
rval.add(string);
}
break;
case AUTHORS:
final Author author = plugin.getClass().getAnnotation(Author.class);
if (author == null) break;
rval.add(author.name());
break;
case VERSION:
final Version version = plugin.getClass().getAnnotation(Version.class);
if (version == null) break;
rval.add(Integer.toString(version.version()));
if(plugin == this.pluginManager) {
final String build = $(PluginManagerImpl.class.getResourceAsStream("jspf.version")).text().split("\n").hashmap().get("build");
rval.add("jspf.build:" + build);
}
break;
case CLASSPATH_ORIGIN:
final PluginRegistry pluginRegistry = pmi.getPluginRegistry();
final PluginMetaInformation metaInformation = pluginRegistry.getMetaInformationFor(plugin);
if (metaInformation != null && metaInformation.classMeta != null && metaInformation.classMeta.pluginOrigin != null)
rval.add(metaInformation.classMeta.pluginOrigin.toString());
break;
default:
this.logger.info("Requested InformationItem is not known!");
break;
}
return rval;
}
/**
* @param plugin
* @return
*/
private String[] getCaps(final Plugin plugin) {
final Class<? extends Plugin> spawnClass = plugin.getClass();
final Method[] methods = spawnClass.getMethods();
// Search for proper method
for (final Method method : methods) {
// Init methods will be marked by the corresponding annotation.
final Capabilities caps = method.getAnnotation(Capabilities.class);
if (caps != null) {
Object result = null;
try {
result = method.invoke(plugin, new Object[0]);
} catch (final IllegalArgumentException e) {
//
} catch (final IllegalAccessException e) {
//
} catch (final InvocationTargetException e) {
//
}
if (result != null && result instanceof String[])
return (String[]) result;
}
}
return new String[0];
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.PluginInformation#getInformation(net.xeoh.plugins.base.Plugin, java.lang.Class)
*/
@Override
public <T extends GetInformationOption> T getInformation(Plugin plugin, Class<T> query) {
return null;
}
}
|
Java
|
/*
* PluginManager.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl;
import static net.jcores.jre.CoreKeeper.$;
import java.net.URI;
import java.util.Arrays;
import java.util.Collection;
import java.util.Properties;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginConfiguration;
import net.xeoh.plugins.base.PluginInformation;
import net.xeoh.plugins.base.PluginInformation.Information;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import net.xeoh.plugins.base.annotations.meta.Author;
import net.xeoh.plugins.base.annotations.meta.RecognizesOption;
import net.xeoh.plugins.base.annotations.meta.Version;
import net.xeoh.plugins.base.diagnosis.channels.tracing.PluginManagerTracer;
import net.xeoh.plugins.base.impl.classpath.ClassPathManager;
import net.xeoh.plugins.base.impl.registry.PluginMetaInformation;
import net.xeoh.plugins.base.impl.registry.PluginMetaInformation.PluginStatus;
import net.xeoh.plugins.base.impl.registry.PluginRegistry;
import net.xeoh.plugins.base.impl.spawning.SpawnResult;
import net.xeoh.plugins.base.impl.spawning.Spawner;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
import net.xeoh.plugins.base.options.GetPluginOption;
import net.xeoh.plugins.base.options.addpluginsfrom.OptionReportAfter;
import net.xeoh.plugins.base.options.getplugin.OptionCapabilities;
import net.xeoh.plugins.base.options.getplugin.OptionPluginSelector;
import net.xeoh.plugins.base.options.getplugin.PluginSelector;
import net.xeoh.plugins.base.util.OptionUtils;
import net.xeoh.plugins.base.util.PluginConfigurationUtil;
import net.xeoh.plugins.diagnosis.local.Diagnosis;
import net.xeoh.plugins.diagnosis.local.impl.DiagnosisImpl;
import net.xeoh.plugins.diagnosis.local.options.status.OptionInfo;
import net.xeoh.plugins.informationbroker.impl.InformationBrokerImpl;
/**
* Implementation of the PluginManager interface. Do not use this class. Do not cast the PluginManager to this implementation.
* Do not access any of the public methods.<br>
*
* @author Ralf Biedert
*/
@PluginImplementation
@Version(version = 1 * Version.UNIT_MAJOR + 0 * Version.UNIT_MINOR + 2 * Version.UNIT_RELEASE)
@Author(name = "Ralf Biedert")
public class PluginManagerImpl implements PluginManager {
/** User properties for plugin configuration */
private final PluginConfiguration configuration;
/** The main container for plugins and plugin information */
private final PluginRegistry pluginRegistry = new PluginRegistry();
/** Classloader used by plugin manager to locate and load plugin classes */
private final ClassPathManager classPathManager;
/** Manages the creation of plugins */
private final Spawner spawner;
/** Indicates if a shutdown has already been one */
private boolean shutdownPerformed = false;
/** User properties for plugin configuration */
PluginInformation information;
/** Diagnostic facilities */
Diagnosis diagnosis;
/**
* Construct new properties.
*
* @param initialProperties
*/
protected PluginManagerImpl(final Properties initialProperties) {
// Create helper classes and config (needed early)
this.spawner = new Spawner(this);
this.classPathManager = new ClassPathManager(this);
this.configuration = new PluginConfigurationImpl(initialProperties);
// Hook fundamental plugins
hookPlugin(new SpawnResult(this));
hookPlugin(new SpawnResult(this.configuration));
// Load the rest
loadAdditionalPlugins();
applyConfig();
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.PluginManager#addPluginsFrom(java.net.URI,
* net.xeoh.plugins.base.options.AddPluginsFromOption[])
*/
public PluginManager addPluginsFrom(final URI url, final AddPluginsFromOption... options) {
this.diagnosis.channel(PluginManagerTracer.class).status("add/start", new OptionInfo("url", url));
if(url == null) return this;
// Add from the given location
if (!this.classPathManager.addFromLocation(url, options)) {
this.diagnosis.channel(PluginManagerTracer.class).status("add/nohandler", new OptionInfo("url", url));
}
// Check if we should print a report?
if ($(options).get(OptionReportAfter.class, null) != null)
this.pluginRegistry.report();
this.diagnosis.channel(PluginManagerTracer.class).status("add/end", new OptionInfo("url", url));
return this;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.PluginManager#getPlugin(java.lang.Class,
* net.xeoh.plugins.base.option.GetPluginOption[])
*/
@SuppressWarnings({ "unchecked" })
@RecognizesOption(option = OptionPluginSelector.class)
public <P extends Plugin> P getPlugin(final Class<P> requestedPlugin,
GetPluginOption... options) {
// Report our request.
if (this.diagnosis != null) {
String name = requestedPlugin == null ? "null" : requestedPlugin.getCanonicalName();
this.diagnosis.channel(PluginManagerTracer.class).status("get/start", new OptionInfo("plugin", name));
}
// We don't handle null values.
if (requestedPlugin == null) {
this.diagnosis.channel(PluginManagerTracer.class).status("get/end", new OptionInfo("return", null));
return null;
}
// Sanity check.
if (!requestedPlugin.isInterface()) {
this.diagnosis.channel(PluginManagerTracer.class).status("get/onlyinterface", new OptionInfo("plugin", requestedPlugin.getCanonicalName()));
this.diagnosis.channel(PluginManagerTracer.class).status("get/end", new OptionInfo("return", null));
System.err.println("YOU MUST NOT call getPlugin() with a concrete class; only interfaces are");
System.err.println("supported for lookup. This means do not call getPlugin(MyPluginImpl.class),");
System.err.println("but rather getPlugin(MyPlugin.class)!");
return null;
}
// Used to process the options
final OptionUtils<GetPluginOption> ou = new OptionUtils<GetPluginOption>(options);
// We use this one to select the plugin
PluginSelector<P> pluginSelector = null;
// Check our options. In case we have a plugin selector, only use the selector
if (ou.contains(OptionPluginSelector.class)) {
pluginSelector = ou.get(OptionPluginSelector.class).getSelector();
} else {
// Capabilites we require
final String capabilites[] = ou.get(OptionCapabilities.class, new OptionCapabilities()).getCapabilities();
// Get caps as list
final Collection<String> caps = Arrays.asList(capabilites);
// Create our own selector
pluginSelector = new PluginSelector<P>() {
public boolean selectPlugin(final Plugin plugin) {
// In case we have caps do special handling and don't return the next
// best plugin
if (caps.size() > 0) {
Collection<String> pcaps = PluginManagerImpl.this.information.getInformation(Information.CAPABILITIES, plugin);
// Check the plugin has them all
if (pcaps.containsAll(caps)) return true;
return false;
}
return true;
}
};
}
// Check for each plugin if it matches
for (final Plugin plugin : this.pluginRegistry.getAllPlugins()) {
if (this.diagnosis != null)
this.diagnosis.channel(PluginManagerTracer.class).status("get/considering", new OptionInfo("plugin", plugin.toString()));
// Check the meta information for this plugin. We only want active classes
final PluginMetaInformation metaInformation = this.pluginRegistry.getMetaInformationFor(plugin);
// Plugins not active are not considered
if (metaInformation.pluginStatus != PluginStatus.ACTIVE) continue;
// Check if the plugin can be assigned to the requested class
if (requestedPlugin.isAssignableFrom(plugin.getClass())) {
if (pluginSelector.selectPlugin((P) plugin)) {
if (this.diagnosis != null)
this.diagnosis.channel(PluginManagerTracer.class).status("get/end", new OptionInfo("return", plugin.toString()));
return (P) plugin;
}
}
}
if (this.diagnosis != null)
this.diagnosis.channel(PluginManagerTracer.class).status("get/end", new OptionInfo("return", null));
return null;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.PluginManager#shutdown()
*/
public void shutdown() {
this.diagnosis.channel(PluginManagerTracer.class).status("shutdown/start");
// Only execute this method a single time.
if (this.shutdownPerformed) {
this.diagnosis.channel(PluginManagerTracer.class).status("shutdown/end/alreadyperformed");
return;
}
// Destroy plugins in a random order
for (final Plugin p : this.pluginRegistry.getAllPlugins()) {
this.diagnosis.channel(PluginManagerTracer.class).status("shutdown/destroy", new OptionInfo("plugin", p.getClass().getCanonicalName()));
this.spawner.destroyPlugin(p, this.pluginRegistry.getMetaInformationFor(p));
}
// Curtains down, lights out.
this.pluginRegistry.clear();
this.shutdownPerformed = true;
this.diagnosis.channel(PluginManagerTracer.class).status("shutdown/end");
}
/**
* Apply things from the config.
*/
@SuppressWarnings("boxing")
private void applyConfig() {
final PluginConfigurationUtil pcu = new PluginConfigurationUtil(this.configuration);
final String cachePath = this.configuration.getConfiguration(PluginManager.class, "cache.file");
this.classPathManager.getCache().setEnabled(pcu.getBoolean(PluginManager.class, "cache.enabled", false));
this.classPathManager.getCache().setCachePath(cachePath);
// Check if we should enable weak mode
final String mode = pcu.getString(PluginManager.class, "cache.mode", "strong");
if (mode.equals("weak")) {
this.classPathManager.getCache().setWeakMode(true);
}
}
/**
* Load some additional plugins.
*/
private void loadAdditionalPlugins() {
// Remaining core plugins
hookPlugin(this.spawner.spawnPlugin(InformationBrokerImpl.class));
// We need the information plugin in getPlugin, so we can't get it normally.
this.information = (PluginInformation) this.spawner.spawnPlugin(PluginInformationImpl.class).plugin;
this.diagnosis = (Diagnosis) this.spawner.spawnPlugin(DiagnosisImpl.class).plugin;
// Inject additional information (MUST NOT USE @InjectPlugin at this point, as
// they are not set
// 'active' yet) and perform manual init
((PluginInformationImpl) this.information).pluginManager = this;
((DiagnosisImpl) this.diagnosis).configuration = this.configuration;
((DiagnosisImpl) this.diagnosis).init();
hookPlugin(new SpawnResult(this.information));
hookPlugin(new SpawnResult(this.diagnosis));
// Set all plugins as active we have so far ...
final Collection<Plugin> allPlugins = this.pluginRegistry.getAllPlugins();
for (Plugin plugin : allPlugins) {
this.pluginRegistry.getMetaInformationFor(plugin).pluginStatus = PluginStatus.ACTIVE;
}
}
/**
* Adds a plugins to the list of known plugins and performs late initialization and
* processing.
*
* @param p The SpawnResult to hook.
*/
public void hookPlugin(SpawnResult p) {
// 1. Process plugin @PluginLoaded annotation for this plugins. TODO: Why was
// this process split? Can't we just do everything in one method before or
// after the plugins was registered?
this.spawner.processThisPluginLoadedAnnotation(p.plugin, p.metaInformation);
// Finally register it.
this.pluginRegistry.registerPlugin(p.plugin, p.metaInformation);
// Process plugin loaded information
this.spawner.processOtherPluginLoadedAnnotation(p.plugin);
}
/**
* Returns the ClassPathManger handling our plugin sources.
*
* @return The PluginManager.
*/
public ClassPathManager getClassPathManager() {
return this.classPathManager;
}
/**
* Returns the PluginRegistry, keeping track of loaded plugins.
*
* @return The PluginRegistry.
*/
public PluginRegistry getPluginRegistry() {
return this.pluginRegistry;
}
/**
* Returns the PluginConfiguration handling application setup.
*
* @return Returns the plugin configuration.
*/
public PluginConfiguration getPluginConfiguration() {
return this.configuration;
}
/**
* Returns the Diagnosis.
*
* @return The diagnosis.
*/
public Diagnosis getDiagnosis() {
return this.diagnosis;
}
/**
* Returns the main spawner to instantiate plugins.
*
* @return The Spawner.
*/
public Spawner getSpawner() {
return this.spawner;
}
}
|
Java
|
/*
* MBeansDiagnosisProvider.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.jmx;
import java.lang.management.ManagementFactory;
import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.AttributeNotFoundException;
import javax.management.DynamicMBean;
import javax.management.InstanceAlreadyExistsException;
import javax.management.IntrospectionException;
import javax.management.InvalidAttributeValueException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanConstructorInfo;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanRegistrationException;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.NotCompliantMBeanException;
import javax.management.ObjectInstance;
import javax.management.ObjectName;
import javax.management.ReflectionException;
/**
* @author rb
*
*/
public class MBeansDiagnosisProvider implements DynamicMBean {
/**
* @throws InstanceAlreadyExistsException
* @throws MBeanRegistrationException
* @throws NotCompliantMBeanException
* @throws MalformedObjectNameException
* @throws ReflectionException
* @throws MBeanException
* @throws NullPointerException
*/
public MBeansDiagnosisProvider() throws InstanceAlreadyExistsException,
MBeanRegistrationException,
NotCompliantMBeanException,
MalformedObjectNameException, ReflectionException,
MBeanException, NullPointerException {
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
System.out.println(server.getMBeanCount());
for (Object object : server.queryMBeans(new ObjectName("*:*"), null))
System.out.println(((ObjectInstance) object).getObjectName());
ObjectName name = new ObjectName("com.javatutor.insel.jmx:type=MBeansDiagnosisProvider");
server.registerMBean(this, name);
}
/**
* @param args
* @throws InstanceAlreadyExistsException
* @throws MBeanRegistrationException
* @throws NotCompliantMBeanException
* @throws MalformedObjectNameException
* @throws ReflectionException
* @throws MBeanException
* @throws NullPointerException
* @throws InterruptedException
*/
@SuppressWarnings("unused")
public static void main(String[] args) throws InstanceAlreadyExistsException,
MBeanRegistrationException,
NotCompliantMBeanException,
MalformedObjectNameException,
ReflectionException, MBeanException,
NullPointerException, InterruptedException {
new MBeansDiagnosisProvider();
Thread.sleep(1000 * 1000);
}
public Object getAttribute(String attribute) throws AttributeNotFoundException,
MBeanException, ReflectionException {
// TODO Auto-generated method stub
System.out.println("getAttr " + attribute);
return null;
}
public AttributeList getAttributes(String[] attributes) {
System.out.println("getAttrs");
// TODO Auto-generated method stub
return null;
}
public MBeanInfo getMBeanInfo() {
System.out.println("getM");
MBeanAttributeInfo mai = null;
try {
mai = new MBeanAttributeInfo("mname", "Desccasas", MBeansDiagnosisProvider.class.getMethod("test"), null);
} catch (IntrospectionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
MBeanNotificationInfo mni = new MBeanNotificationInfo(new String[] {"asd"}, "nmnm!", "asdklajsdasl");
return new MBeanInfo("clzName", "Desc", new MBeanAttributeInfo[] { mai }, new MBeanConstructorInfo[0], new MBeanOperationInfo[0], new MBeanNotificationInfo[] {mni});
}
public Object invoke(String actionName, Object[] params, String[] signature)
throws MBeanException,
ReflectionException {
// TODO Auto-generated method stub
return null;
}
public void setAttribute(Attribute attribute) throws AttributeNotFoundException,
InvalidAttributeValueException,
MBeanException, ReflectionException {
// TODO Auto-generated method stub
System.out.println("setAttr");
}
public AttributeList setAttributes(AttributeList attributes) {
System.out.println("setAttrrs");
return null;
}
/**
* @return .
*/
public int test() {
System.out.println("Test");
return 123;
}
}
|
Java
|
/*
* PluginMetaInformation.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.registry;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import net.xeoh.plugins.base.Plugin;
/**
* Meta information of the given plugin.
*
* @author Ralf Biedert
*/
public class PluginMetaInformation {
/** Handles PluginLoaded annotations */
public static class PluginLoadedInformation {
/** Annotated method */
public Method method;
/** Base type to call with */
public Class<? extends Plugin> baseType;
/** Items already put into the method */
public List<Plugin> calledWith = new ArrayList<Plugin>();
}
/**
* @author rb
*/
public static enum PluginStatus {
/** No further information is available */
UNDEFINED,
/** Plugin has been spawned, i.e., constructed. */
SPAWNED,
/** Plugin has been initialized and all threads and timers have been spawned */
INITIALIZED,
/**
* Plugin is currently running (default state when
* everything is okay)
*/
ACTIVE,
/** Plugin was shut down. */
TERMINATED,
/** Plugin failed to initialize due to own report. */
FAILED
}
/** Status of the plugin */
public PluginStatus pluginStatus = PluginStatus.UNDEFINED;
/** Meta information of the parent class */
public PluginClassMetaInformation classMeta = null;
/** List of declared threads, managed by the Spawner */
public final List<Thread> threads = new ArrayList<Thread>();
/** List of declared timer tasks, managed by the Spawner */
public final List<TimerTask> timerTasks = new ArrayList<TimerTask>();
/** List of declared timer tasks, managed by the Spawner */
public final List<Timer> timers = new ArrayList<Timer>();
/** Handles plugin loaded information */
public final List<PluginLoadedInformation> pluginLoadedInformation = new ArrayList<PluginLoadedInformation>();
/** Time this pluggable has been spawned. */
public long spawnTime;
}
|
Java
|
/*
* PluginRegistry.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.registry;
import static net.jcores.jre.CoreKeeper.$;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import net.jcores.jre.interfaces.functions.F1;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.impl.registry.PluginClassMetaInformation.Dependency;
import net.xeoh.plugins.base.impl.registry.PluginClassMetaInformation.PluginClassStatus;
/**
* The registry keeps track of all instantiated plugins.
*
* @author Ralf Biedert
*/
public class PluginRegistry {
/** Stores meta information related to a plugin */
private final Map<Plugin, PluginMetaInformation> pluginMetaInformation;
/** Stores meta information related to a plugin class */
private final Map<Class<? extends Plugin>, PluginClassMetaInformation> pluginClassMetaInformation;
/**
* Creates a new registry
*/
public PluginRegistry() {
this.pluginMetaInformation = new ConcurrentHashMap<Plugin, PluginMetaInformation>();
this.pluginClassMetaInformation = new ConcurrentHashMap<Class<? extends Plugin>, PluginClassMetaInformation>();
}
/**
* Returns all plugins, regardless of their status
*
* @return .
*/
public Collection<Plugin> getAllPlugins() {
return this.pluginMetaInformation.keySet();
}
/**
* Returns the metainfromation of a plugin
*
* @param plugin
* @return .
*/
public PluginMetaInformation getMetaInformationFor(Plugin plugin) {
return this.pluginMetaInformation.get(plugin);
}
/**
* Returns the metainfromation of a pluginclass
*
* @param clazz
* @return .
*/
public PluginClassMetaInformation getMetaInformationFor(Class<? extends Plugin> clazz) {
return this.pluginClassMetaInformation.get(clazz);
}
/**
* Remove all plugin references
*/
public void clear() {
this.pluginClassMetaInformation.clear();
this.pluginMetaInformation.clear();
}
/**
* Registers a plugin with the given meta information
*
* @param plugin
* @param metaInformation
*/
public void registerPlugin(Plugin plugin, PluginMetaInformation metaInformation) {
this.pluginMetaInformation.put(plugin, metaInformation);
}
/**
* @param c
* @param metaInformation
*/
public void registerPluginClass(Class<? extends Plugin> c,
PluginClassMetaInformation metaInformation) {
this.pluginClassMetaInformation.put(c, metaInformation);
}
/**
* Returns all classes with a given status.
*
* @param status
* @return .
*/
public Collection<Class<? extends Plugin>> getPluginClassesWithStatus(PluginClassStatus status) {
final List<Class<? extends Plugin>> rval = new ArrayList<Class<? extends Plugin>>();
final Set<Class<? extends Plugin>> keySet = this.pluginClassMetaInformation.keySet();
for (Class<? extends Plugin> class1 : keySet) {
final PluginClassMetaInformation metaInformation = this.pluginClassMetaInformation.get(class1);
if (metaInformation.pluginClassStatus == status) rval.add(class1);
}
return rval;
}
/**
* Prints a report of this registry.
*/
public void report() {
System.out.println();
System.out.println(">>> Class Report <<<");
final Set<Class<? extends Plugin>> keySet = this.pluginClassMetaInformation.keySet();
for (Class<? extends Plugin> class1 : keySet) {
final PluginClassMetaInformation meta = this.pluginClassMetaInformation.get(class1);
System.out.print(" " + class1.getCanonicalName() + " (status:'" + meta.pluginClassStatus);
System.out.print("'; dependencies:'" + $(meta.dependencies).map(new F1<PluginClassMetaInformation.Dependency, String>() {
public String f(Dependency x) {
return x.pluginClass.getSimpleName();
}
}).string().join(","));
System.out.print("'; origin:'" + meta.pluginOrigin + "';)");
System.out.println();
}
System.out.println();
System.out.println(">>> Object Report <<<");
final Set<Plugin> keySet2 = this.pluginMetaInformation.keySet();
for (Plugin plugin : keySet2) {
final PluginMetaInformation meta = this.pluginMetaInformation.get(plugin);
System.out.println(" " + plugin + " (status:'" + meta.pluginStatus + "')");
}
System.out.println();
}
}
|
Java
|
/*
* PluginClassMetaInformation.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.registry;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import net.xeoh.plugins.base.Plugin;
/**
* Meta information of the given plugin class.
*
* @author Ralf Biedert
*/
public class PluginClassMetaInformation {
/**
* @author rb
*/
public static enum PluginClassStatus {
/** No further information are available. Should not be observed
* under normal circumstances. */
UNDEFINED,
/** Plugin has been accepted as a valid plugin */
ACCEPTED,
/** Disabled due to various reasons (check logging output). */
DISABLED,
/** Plugin contains unresolved dependencies */
CONTAINS_UNRESOLVED_DEPENDENCIES,
/** Plugin is ready for spawning, should happen soon. */
SPAWNABLE,
/** Plugin has been lazy-spawned. ??? */
LAZY_SPAWNED,
/** Plugin has been spawned. Should be accessible now
* by getPlugin(). */
SPAWNED,
/** If the class failed to spawn */
FAILED,
}
/**
* Another plugin this plugin depends on.
*
* @author rb
*
*/
public static class Dependency {
/** */
public Class<? extends Plugin> pluginClass;
/** */
public String[] capabilites = new String[0];
/** */
public boolean isOptional = false;
}
/** Status of this plugin class */
public PluginClassStatus pluginClassStatus = PluginClassStatus.UNDEFINED;
/** Where this plugin came from */
public URI pluginOrigin;
/** The dependencies of this class */
public Collection<Dependency> dependencies = new ArrayList<Dependency>();
}
|
Java
|
/*
* ClassPathManager.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Logger;
import net.xeoh.plugins.base.impl.PluginManagerImpl;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache.JARInformation;
import net.xeoh.plugins.base.impl.classpath.loader.AbstractLoader;
import net.xeoh.plugins.base.impl.classpath.loader.FileLoader;
import net.xeoh.plugins.base.impl.classpath.loader.HTTPLoader;
import net.xeoh.plugins.base.impl.classpath.loader.InternalClasspathLoader;
import net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation;
import net.xeoh.plugins.base.impl.classpath.locator.ClassPathLocator;
import net.xeoh.plugins.base.impl.classpath.locator.locations.JARClasspathLocation;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
import org.codehaus.classworlds.ClassRealm;
import org.codehaus.classworlds.ClassWorld;
import org.codehaus.classworlds.DuplicateRealmException;
import org.codehaus.classworlds.NoSuchRealmException;
/**
* Manages all our classpaths shared by different plugins.
*
* @author Ralf Biedert
*/
public class ClassPathManager {
/** Console and file logging */
private final Logger logger = Logger.getLogger(this.getClass().getName());
/** Blocks access to the file cache */
private final Lock cacheLock = new ReentrantLock();
/** Manages content cache of jar files */
private final JARCache jarCache = new JARCache();
/** Locates possible classpaths */
private final ClassPathLocator locator;
/** Loads plugins from various urls */
private final Collection<AbstractLoader> pluginLoader = new ArrayList<AbstractLoader>();
/** Manages classpaths from URLs */
ClassWorld classWorld;
/**
* Indicates if we're initialized properly (application mode) or if we had sandbox
* problems (applet mode).
*/
boolean initializedProperly = false;
/**
* @param pluginManager
*/
@SuppressWarnings("synthetic-access")
public ClassPathManager(PluginManagerImpl pluginManager) {
this.locator = new ClassPathLocator(pluginManager, this.jarCache);
// Register loader
this.pluginLoader.add(new InternalClasspathLoader(pluginManager));
this.pluginLoader.add(new FileLoader(pluginManager));
this.pluginLoader.add(new HTTPLoader(pluginManager));
// Initialization is a bit ugly, but we might be in a sandbox
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
try {
// Try to create a new ClassWorld object
ClassPathManager.this.classWorld = new ClassWorld();
// Create a core realm (for internal and classpath://* plugins)
try {
ClassPathManager.this.classWorld.newRealm("core", getClass().getClassLoader());
} catch (DuplicateRealmException e) {
e.printStackTrace();
}
// Signal that we are okay.
ClassPathManager.this.initializedProperly = true;
} catch (SecurityException e) {
ClassPathManager.this.logger.warning("Proper initialization failed due to security restrictions. Only classpath://xxx URIs will work. Sorry.");
}
return null;
}
});
}
/**
* Locates plugins at a given source, loads them and adds them to the registry.
*
* @param location
* @param options
* @return .
*/
public boolean addFromLocation(URI location, AddPluginsFromOption[] options) {
if(location == null) return false;
this.cacheLock.lock();
try {
// Load local cache
this.jarCache.loadCache();
// Handle URI
for (AbstractLoader loader : this.pluginLoader) {
if (!loader.handlesURI(location)) continue;
loader.loadFrom(location, options);
return true;
}
} finally {
this.jarCache.saveCache();
this.cacheLock.unlock();
}
return false;
}
/**
* Loads a class given its name and classpath location.
*
* @param location Specifies where this plugins should be obtained from, or
* <code>null</code> if we should use our own classloader.
* @param name The name of the class to load.
*
* @return The requested class.
*
* @throws ClassNotFoundException
*/
public Class<?> loadClass(AbstractClassPathLocation location, String name)
throws ClassNotFoundException {
// In case no location is supplied ...
if (location == null) { return getClass().getClassLoader().loadClass(name); }
try {
if (this.initializedProperly) {
final ClassLoader classLoader = this.classWorld.getRealm(location.getRealm()).getClassLoader();
return classLoader.loadClass(name);
}
} catch (ClassNotFoundException e) {
return getClass().getClassLoader().loadClass(name);
} catch (NoSuchRealmException e) {
e.printStackTrace();
}
// And again, this time we run this code if we have not been inititalized properly
return getClass().getClassLoader().loadClass(name);
}
/**
* Finds all subclasses for the given superclass.
*
* @param location The location to search for.
* @param superclass The superclass to obtain subclasses for.
*
* @return A list of plugin names extending <code>superclass</code>.
*/
public Collection<String> findSubclassesFor(AbstractClassPathLocation location,
Class<?> superclass) {
final Collection<String> rval = new ArrayList<String>();
if (!this.initializedProperly) return rval;
// Check if we can get the requested information out of the cache
JARInformation cacheEntry = null;
// If it is a JAR entry, check if we have cache information
if (location instanceof JARClasspathLocation) {
cacheEntry = ((JARClasspathLocation) location).getCacheEntry();
if (cacheEntry != null) {
final Collection<String> collection = cacheEntry.subclasses.get(superclass.getCanonicalName());
if (collection != null) return collection;
}
}
// No? Okay, search the hard way ...
try {
final ClassLoader classLoader = this.classWorld.getRealm(location.getRealm()).getClassLoader();
final Collection<String> listClassNames = location.listToplevelClassNames();
for (String name : listClassNames) {
try {
final Class<?> c = Class.forName(name, false, classLoader);
// No interfaces please
if (c.isInterface()) continue;
if (superclass.isAssignableFrom(c) && !superclass.getCanonicalName().equals(c.getCanonicalName())) {
rval.add(name);
}
} catch (ClassNotFoundException e) {
this.logger.fine("ClassNotFoundException. Unable to inspect class " + name + " although it appears to be one.");
// Print all causes, helpful for debugging
Throwable cause = e.getCause();
while (cause != null) {
this.logger.fine("Reason " + cause.getMessage());
cause = cause.getCause();
}
} catch (final NoClassDefFoundError e) {
this.logger.finer("Ignored class " + name + " due to unresolved dependencies");
// Print all causes, helpful for debugging
Throwable cause = e.getCause();
while (cause != null) {
this.logger.fine("Reason " + cause.getMessage());
cause = cause.getCause();
}
} catch (SecurityException e) {
this.logger.fine("SecurityException while trying to find subclasses. Cause of trouble: " + name + ". This does not neccessarily mean problems however.");
// Print all causes, helpful for debugging
Throwable cause = e.getCause();
while (cause != null) {
this.logger.fine("Reason " + cause.getMessage());
cause = cause.getCause();
}
} catch (Exception e) {
this.logger.finer("Ignored class " + name + " due to some other error");
Throwable cause = e.getCause();
while (cause != null) {
this.logger.fine("Reason " + cause.getMessage());
cause = cause.getCause();
}
}
}
} catch (NoSuchRealmException e1) {
e1.printStackTrace();
}
// Update the cache information
if (cacheEntry != null) {
cacheEntry.subclasses.put(superclass.getCanonicalName(), rval);
}
return rval;
}
/**
* Adds a classpath location to this manager.
*
* @param location
*/
public void registerLocation(AbstractClassPathLocation location) {
if (!this.initializedProperly) return;
try {
final ClassRealm newRealm = this.classWorld.newRealm(location.getRealm(), getClass().getClassLoader());
final URI[] classpathLocations = location.getClasspathLocations();
for (URI uri : classpathLocations) {
newRealm.addConstituent(uri.toURL());
}
} catch (DuplicateRealmException e) {
// Happens for #classpath realms ...
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
/**
* Returns a resource as an input stream for a given location.
*
* @param location The location to use.
* @param name The requested resource.
* @return The input stream for the requested resource or <code>null</code> if none
* was found.
*/
public InputStream getResourceAsStream(AbstractClassPathLocation location, String name) {
// In case no location is supplied ...
if (location == null) { return getClass().getClassLoader().getResourceAsStream(name); }
try {
final ClassLoader classLoader = this.classWorld.getRealm(location.getRealm()).getClassLoader();
return classLoader.getResourceAsStream(name);
} catch (NoSuchRealmException e) {
e.printStackTrace();
}
return null;
}
/**
* Returns our locator.
*
* @return The locator.
*/
public ClassPathLocator getLocator() {
return this.locator;
}
/**
* Returns the JAR cache.
*
* @return The cache.
*/
public JARCache getCache() {
return this.jarCache;
}
}
|
Java
|
/*
* InternalClasspathLoader.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.loader;
import java.net.URI;
import java.util.Collection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.impl.PluginManagerImpl;
import net.xeoh.plugins.base.impl.classpath.ClassPathManager;
import net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation;
import net.xeoh.plugins.base.impl.classpath.locator.ClassPathLocator;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
/**
* A loader to handle classpath://* URIs.
*
* @author Ralf Biedert
*/
public class InternalClasspathLoader extends AbstractLoader {
/**
* @param pluginManager
*/
public InternalClasspathLoader(PluginManagerImpl pluginManager) {
super(pluginManager);
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.impl.loader.AbstractLoader#handlesURI(java.net.URI)
*/
@Override
public boolean handlesURI(URI uri) {
if (uri != null && "classpath".equals(uri.getScheme())) return true;
return false;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.impl.loader.AbstractLoader#loadFrom(java.net.URI)
*/
@Override
public void loadFrom(URI url, AddPluginsFromOption[] options) {
// Special handler to load files from the local classpath
if (url.toString().contains("*")) {
if (url.toString().equals("classpath://*")) {
loadAllClasspathPluginClasses(null, options);
} else {
String pattern = url.toString();
pattern = pattern.replace("**", ".+");
pattern = pattern.replace("*", "[^\\.]*");
pattern = pattern.replace("classpath://", "");
loadAllClasspathPluginClasses(pattern, options);
}
return;
}
// Special handler to load files from the local classpath, specified by name.
// Please note that this is a very bad solution and should only be used in special
// cases,
// as when invoking from applets that don't have permission to access the
// classpath (is this so)
if (url.toString().startsWith("classpath://")) {
// Obtain the fq-classname to load
final String toLoad = url.toString().substring("classpath://".length());
// Try to load all plugins, might cause memory problems due to Issue #20.
try {
loadClassFromClasspathByName(toLoad);
} catch (OutOfMemoryError error) {
this.logger.severe("Due to a bug (Issue #20), JSPF ran low on memory. Please increase your memory by (e.g., -Xmx1024m) or specify a 'classpath.filter.default.pattern' options. We hope to fix this bux in some future release. We are sorry for the inconvenience this might cause and we can understand if you hate us now :-(.");
error.printStackTrace();
}
return;
}
}
/**
* Load all plugins from the classpath that match a given pattern.
*
* @param pattern
* @param options
*/
private void loadAllClasspathPluginClasses(String pattern,
AddPluginsFromOption[] options) {
// Start the classpath search
this.logger.finer("Starting classpath search with pattern " + pattern);
// Get all classpath locations of the current classpath
final ClassPathManager manager = this.pluginManager.getClassPathManager();
final ClassPathLocator locator = manager.getLocator();
final Collection<AbstractClassPathLocation> locations = locator.findInCurrentClassPath(options);
// Process all locations
for (AbstractClassPathLocation location : locations) {
manager.registerLocation(location);
final Collection<String> candidates = manager.findSubclassesFor(location, Plugin.class);
this.logger.finer("Found " + candidates.size() + " candidates.");
// Check all candidates
for (String string : candidates) {
// Either try to add them all, or only those who match a given pattern
if (pattern == null) tryToLoadClassAsPlugin(location, string);
else {
final Pattern p = Pattern.compile(pattern);
final Matcher m = p.matcher(string);
this.logger.finest(string + " " + m.matches());
if (m.matches()) {
tryToLoadClassAsPlugin(location, string);
}
}
}
}
return;
}
private void loadClassFromClasspathByName(final String toLoad) {
this.logger.fine("Loading " + toLoad + " directly");
tryToLoadClassAsPlugin(null, toLoad);
}
}
|
Java
|
/*
* AbstractLoader.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.loader;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Properties;
import java.util.Set;
import java.util.logging.Logger;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import net.xeoh.plugins.base.annotations.configuration.ConfigurationFile;
import net.xeoh.plugins.base.annotations.configuration.IsDisabled;
import net.xeoh.plugins.base.impl.PluginManagerImpl;
import net.xeoh.plugins.base.impl.classpath.ClassPathManager;
import net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation;
import net.xeoh.plugins.base.impl.registry.PluginClassMetaInformation;
import net.xeoh.plugins.base.impl.registry.PluginClassMetaInformation.Dependency;
import net.xeoh.plugins.base.impl.registry.PluginClassMetaInformation.PluginClassStatus;
import net.xeoh.plugins.base.impl.registry.PluginMetaInformation.PluginStatus;
import net.xeoh.plugins.base.impl.registry.PluginRegistry;
import net.xeoh.plugins.base.impl.spawning.SpawnResult;
import net.xeoh.plugins.base.impl.spawning.Spawner;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
import net.xeoh.plugins.base.options.getplugin.OptionCapabilities;
import net.xeoh.plugins.base.util.PluginConfigurationUtil;
/**
* The abstract base class of all loaders, provides methods for spawning classes.
*
* @author Ralf Biedert
*/
public abstract class AbstractLoader {
/** */
protected final Logger logger = Logger.getLogger(this.getClass().getName());
/** Grants access to various shared variables. */
protected final PluginManagerImpl pluginManager;
/**
* @param pluginManager
*/
public AbstractLoader(PluginManagerImpl pluginManager) {
this.pluginManager = pluginManager;
}
/**
* @param uri
* @return .
*/
public abstract boolean handlesURI(URI uri);
/**
* Load plugins from a given source
*
* @param uri
* @param options
*/
public abstract void loadFrom(URI uri, AddPluginsFromOption[] options);
/**
* Tries to load a class from a given source. If it is a plugin, it will be
* registered.
*
* @param location
* @param name
*/
@SuppressWarnings({ "unchecked", "boxing" })
protected void tryToLoadClassAsPlugin(AbstractClassPathLocation location,
final String name) {
this.logger.finest("Trying to load " + name + " as a plugin.");
// Obtain some shared objects
// final JARCache jarCache = this.pluginManager.getJARCache();
final ClassPathManager classPathManager = this.pluginManager.getClassPathManager();
final PluginRegistry pluginRegistry = this.pluginManager.getPluginRegistry();
final PluginConfigurationUtil pcu = new PluginConfigurationUtil(this.pluginManager.getPluginConfiguration());
final Spawner spawner = this.pluginManager.getSpawner();
// Obtain information
// final JARInformation jarInformation = jarCache.getJARInformation(name);
// final String file = jarCache.classTofile(name);
try {
// Get class of the candidate
final Class<?> possiblePlugin = classPathManager.loadClass(location, name);
// Don't load plugins already spawned.
if (name.startsWith("net.xeoh.plugins.base") ||
name.startsWith("net.xeoh.plugins.diagnosis.") ||
name.startsWith("net.xeoh.plugins.informationbroker.")) return;
// Get the plugin's annotation
final PluginImplementation annotation = possiblePlugin.getAnnotation(PluginImplementation.class);
// Nothing to load here if no annotation is present
if (annotation == null) { return; }
// Don't load classes already loaded from this location
final PluginClassMetaInformation preexistingMeta = pluginRegistry.getMetaInformationFor((Class<? extends Plugin>) possiblePlugin);
if (preexistingMeta != null) {
this.logger.info("Skipping plugin " + possiblePlugin + " because we already have it ");
return;
}
// Register class at registry
final PluginClassMetaInformation metaInformation = new PluginClassMetaInformation();
metaInformation.pluginClassStatus = PluginClassStatus.ACCEPTED;
if (location != null) {
metaInformation.pluginOrigin = location.getToplevelLocation();
} else {
metaInformation.pluginOrigin = new URI("classpath://UNDEFINED");
}
pluginRegistry.registerPluginClass((Class<? extends Plugin>) possiblePlugin, metaInformation);
// Update the class information of the corresponding cache entry
this.logger.finer("Updating cache information");
// Avoid loading if annotation request it.
if (pcu.getBoolean(possiblePlugin, "plugin.disabled", false) || possiblePlugin.getAnnotation(IsDisabled.class) != null) {
metaInformation.pluginClassStatus = PluginClassStatus.DISABLED;
this.logger.fine("Ignoring " + name + " due to request.");
return;
}
// Up from here we know we will (eventually) use the plugin. So load its
// configuration.
final String properties = (possiblePlugin.getAnnotation(ConfigurationFile.class) != null) ? possiblePlugin.getAnnotation(ConfigurationFile.class).file() : null;
if (properties != null && properties.length() > 0) {
final String resourcePath = name.replaceAll("\\.", "/").replaceAll(possiblePlugin.getSimpleName(), "") + properties;
this.logger.fine("Adding configuration from " + resourcePath + " for plugin " + name);
final Properties p = new Properties();
// Try to load resource by special classloader
try {
p.load(classPathManager.getResourceAsStream(location, resourcePath));
final Set<Object> keys = p.keySet();
// Add every string that is not already in the configuration.
for (final Object object : keys) {
if (pcu.getString(null, (String) object) != null) {
this.pluginManager.getPluginConfiguration().setConfiguration(null, (String) object, p.getProperty((String) object));
}
}
} catch (final IOException e) {
this.logger.warning("Unable to load properties " + resourcePath + " although requested");
} catch (final NullPointerException e) {
this.logger.warning("Unable to load properties " + resourcePath + " although requested. Probably not in package.");
}
}
// Obtain dependencies
metaInformation.dependencies = spawner.getDependencies((Class<? extends Plugin>) possiblePlugin);
// If the class has unfulfilled dependencies, add it to our list.
if (metaInformation.dependencies.size() == 0) {
metaInformation.pluginClassStatus = PluginClassStatus.SPAWNABLE;
} else {
metaInformation.pluginClassStatus = PluginClassStatus.CONTAINS_UNRESOLVED_DEPENDENCIES;
}
} catch (final ClassNotFoundException e) {
e.printStackTrace();
this.logger.warning("ClassNotFoundException. Unable to inspect class " + name + " although it appears to be one.");
} catch (final NoClassDefFoundError e) {
e.printStackTrace();
this.logger.finer("Ignored class " + name + " due to unresolved dependencies");
} catch (URISyntaxException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// We always try to load pending classes ...
processPending();
}
/**
* Try to load a pending class.
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
protected void processPending() {
// Obtain shared objects
final PluginRegistry pluginRegistry = this.pluginManager.getPluginRegistry();
final Spawner spawner = this.pluginManager.getSpawner();
// All classes we want to spawn
final Collection<Class<? extends Plugin>> toSpawn = new ArrayList<Class<? extends Plugin>>();
toSpawn.addAll(pluginRegistry.getPluginClassesWithStatus(PluginClassStatus.CONTAINS_UNRESOLVED_DEPENDENCIES));
toSpawn.addAll(pluginRegistry.getPluginClassesWithStatus(PluginClassStatus.SPAWNABLE));
// Check if there is work to do.
if (toSpawn.size() == 0) return;
boolean loopAgain;
do {
// Classes we want to spawn
final Collection<Class<? extends Plugin>> spawned = new ArrayList<Class<? extends Plugin>>();
// Reset hasLoaded flag
loopAgain = false;
// Check all known classes ...
for (final Class c : toSpawn) {
this.logger.fine("Trying to load pending " + c);
final PluginClassMetaInformation metaInformation = pluginRegistry.getMetaInformationFor(c);
// If the class is spawnable, spawn it ...
if (metaInformation.pluginClassStatus == PluginClassStatus.SPAWNABLE) {
this.logger.fine("Class found as SPAWNABLE. Trying to spawn it now " + c);
//
// The magic line: spawn it.
//
final SpawnResult p = spawner.spawnPlugin(c);
// In case we were successful ...
if (p != null && p.metaInformation.pluginStatus != PluginStatus.FAILED) {
// Link the parent class meta information
p.metaInformation.classMeta = metaInformation;
// Check if the class is active or only lazy spawned
if (p.metaInformation.pluginStatus == PluginStatus.ACTIVE) {
// Mark the class a spawned
metaInformation.pluginClassStatus = PluginClassStatus.SPAWNED;
spawned.add(c);
this.pluginManager.hookPlugin(p);
}
// Lazy spawn ...
if (p.metaInformation.pluginStatus == PluginStatus.SPAWNED) {
metaInformation.pluginClassStatus = PluginClassStatus.LAZY_SPAWNED;
throw new IllegalStateException("Lazy spawning not supported yet!");
}
// And loop once more.
loopAgain = true;
break;
}
// This case is bad ...
this.logger.warning("Failed to spawn class " + c);
metaInformation.pluginClassStatus = PluginClassStatus.FAILED;
}
// Check if we can switch the class to SPAWNABLE
if (metaInformation.pluginClassStatus == PluginClassStatus.CONTAINS_UNRESOLVED_DEPENDENCIES) {
this.logger.fine("Trying to solve dependencies for class " + c);
boolean resolvedAll = true;
// Check all dependencies
for (Dependency d : metaInformation.dependencies) {
if (d.isOptional) {
this.logger.finest("Skipping dependency as optional " + d.pluginClass);
continue;
}
if (this.pluginManager.getPlugin(d.pluginClass, new OptionCapabilities(d.capabilites)) == null) {
resolvedAll = false;
}
}
// Nice. So this class will be spawned in one of the next rounds ...
if (resolvedAll) {
metaInformation.pluginClassStatus = PluginClassStatus.SPAWNABLE;
loopAgain = true;
break;
}
}
}
// Remove all spawned from the list (not really necessary, is it?)
toSpawn.removeAll(spawned);
} while (loopAgain && toSpawn.size() > 0);
}
}
|
Java
|
/*
* InternalClasspathLoader.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.loader;
import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLDecoder;
import java.util.Collection;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.impl.PluginManagerImpl;
import net.xeoh.plugins.base.impl.classpath.ClassPathManager;
import net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation;
import net.xeoh.plugins.base.impl.classpath.locator.ClassPathLocator;
import net.xeoh.plugins.base.impl.classpath.locator.locations.JARClasspathLocation;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
/**
* @author rb
*
*/
public class FileLoader extends AbstractLoader {
/**
* @param pluginManager
*/
public FileLoader(PluginManagerImpl pluginManager) {
super(pluginManager);
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.impl.loader.AbstractLoader#handlesURI(java.net.URI)
*/
@Override
public boolean handlesURI(URI uri) {
if (uri != null && "file".equals(uri.getScheme())) return true;
return false;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.impl.loader.AbstractLoader#loadFrom(java.net.URI)
*/
@Override
public void loadFrom(URI url, AddPluginsFromOption[] options) {
// If not caught by the previous handler, handle files normally.
if (url.getScheme().equals("file")) {
// Get the actual file from the given path (TODO: Why don't we do new
// File(url)?)
String file = url.getPath();
// FIXME: Where does this trailing slash come from ?!
if (file.startsWith("/") && file.substring(0, 4).contains(":")) {
file = file.substring(1);
}
// Try to decode the path properly
try {
file = URLDecoder.decode(file, "utf8");
} catch (final UnsupportedEncodingException e) {
e.printStackTrace();
}
// Now load from the given file ...
this.logger.fine("More specifically, trying to add from " + file);
final File root = new File(file);
// ... if it exists ...
if (!root.exists()) {
this.logger.warning("Supplied path does not exist. Unable to add plugins from there.");
return;
}
// Here we go
locateAllPluginsAt(root);
return;
}
}
/**
* Given a top level directory, we locate all classpath locations and load all plugins
* we find.
*
* @param root The top level to start from.
*/
void locateAllPluginsAt(File root) {
final ClassPathManager manager = this.pluginManager.getClassPathManager();
final ClassPathLocator locator = manager.getLocator();
final Collection<AbstractClassPathLocation> locations = locator.findBelow(root.toURI());
for (AbstractClassPathLocation location : locations) {
manager.registerLocation(location);
Collection<String> subclasses = null;
// Check if it has a list of plugins
if (location instanceof JARClasspathLocation) {
final JARClasspathLocation jarLocation = (JARClasspathLocation) location;
subclasses = jarLocation.getPredefinedPluginList();
}
// Add all found files ... if we have no predefined list
if (subclasses == null)
subclasses = manager.findSubclassesFor(location, Plugin.class);
// Try to load them
for (String string : subclasses) {
tryToLoadClassAsPlugin(location, string);
}
}
}
}
|
Java
|
/*
* InternalClasspathLoader.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.loader;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import net.xeoh.plugins.base.impl.PluginManagerImpl;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
/**
* @author rb
*
*/
public class HTTPLoader extends FileLoader {
/**
* @param pluginManager
*/
public HTTPLoader(PluginManagerImpl pluginManager) {
super(pluginManager);
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.loader.AbstractLoader#handlesURI(java.net.URI)
*/
@Override
public boolean handlesURI(URI uri) {
if (uri != null && "http".equals(uri.getScheme())) return true;
return false;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.loader.AbstractLoader#loadFrom(java.net.URI)
*/
@Override
public void loadFrom(URI url, AddPluginsFromOption[] options) {
// Handle http files
if ("http".equals(url.getScheme())) {
try {
// download the file (TODO: download could be improved a bit ...)
java.io.File tmpFile = java.io.File.createTempFile("jspfplugindownload", ".jar");
final FileOutputStream fos = new FileOutputStream(tmpFile);
final URL url2 = url.toURL();
final InputStream openStream = url2.openStream();
int read = 0;
byte buf[] = new byte[1024];
while ((read = openStream.read(buf)) > 0) {
fos.write(buf, 0, read);
}
fos.close();
openStream.close();
// BIG FAT TODO: Do signature check!!!
locateAllPluginsAt(tmpFile);
return;
} catch (Exception e) {
e.printStackTrace();
this.logger.warning("Error downloading plugins from " + url);
}
}
}
}
|
Java
|
/*
* JARClasspathLocation.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.locator.locations;
import static net.jcores.jre.CoreKeeper.$;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import net.jcores.jre.cores.CoreString;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache;
import net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation;
/**
* A multi-plugin in a meta-plugin containing several sub-plugins sharing the same class
* loader and have an external dependency folder.
*
* @author Ralf Biedert
*/
public class MultiPluginClasspathLocation extends AbstractClassPathLocation {
/** Maps our returned entries to contained JARs (so we know where too look if we want to resolve them) */
final Map<String, String> entryMapping = new HashMap<String, String>();
/** All the JARs we handle */
final Collection<String> allJARs;
/**
* @param cache
* @param realm
* @param location
*/
public MultiPluginClasspathLocation(JARCache cache, String realm, URI location) {
super(cache, realm, location);
this.allJARs = $(location).file().dir().filter(".*jar$").string().list();
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#getType()
*/
@Override
public LocationType getType() {
return LocationType.MULTI_PLUGIN;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#getClasspathLocations()
*/
@Override
public URI[] getClasspathLocations() {
return $(this.allJARs).as(CoreString.class).file().uri().array(URI.class);
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#getInputStream(java.lang.String)
*/
@Override
public InputStream getInputStream(String file) {
final String uri = this.entryMapping.get(file);
if (uri == null) return null;
try {
final JarURLConnection connection = (JarURLConnection) new URI("jar:" + new File(uri).toURI() + "!/").toURL().openConnection();
final JarFile jarFile = connection.getJarFile();
final Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
final JarEntry entry = entries.nextElement();
// We only search for class file entries
if (entry.isDirectory()) continue;
String name = entry.getName();
if (name.equals(file)) return jarFile.getInputStream(entry);
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
return null;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#listAllEntries()
*/
@Override
public Collection<String> listAllEntries() {
ArrayList<String> rval = new ArrayList<String>();
for (String entry : this.allJARs) {
final Collection<String> all = JARClasspathLocation.listAllEntriesFor(URI.create(entry));
for (String string : all) {
this.entryMapping.put(string, entry);
}
rval.addAll(all);
}
return rval;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#listToplevelClassNames()
*/
@Override
public Collection<String> listToplevelClassNames() {
ArrayList<String> rval = new ArrayList<String>();
for (String entry : this.allJARs) {
final Collection<String> all = JARClasspathLocation.listToplevelClassNamesForURI(new File(entry).toURI());
for (String string : all) {
this.entryMapping.put(string, entry);
}
rval.addAll(all);
}
return rval;
}
}
|
Java
|
/*
* JARClasspathLocation.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.locator.locations;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.regex.Pattern;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache;
import net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation;
/**
* @author rb
*
*/
public class FileClasspathLocation extends AbstractClassPathLocation {
/**
* @param cache
* @param realm
* @param location
*/
public FileClasspathLocation(JARCache cache, String realm, URI location) {
super(cache, realm, location);
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#getInputStream(java.lang.String)
*/
@Override
public InputStream getInputStream(String entry) {
final File toplevel = new File(this.location);
try {
return new FileInputStream(new File(toplevel.getAbsolutePath() + "/" + entry));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return null;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#getType()
*/
@Override
public LocationType getType() {
return LocationType.DIRECTORY;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#listAllEntries()
*/
@Override
public Collection<String> listAllEntries() {
final Collection<String> rval = new ArrayList<String>();
final File toplevel = new File(this.location);
try {
List<File> fileListing = getFileListing(toplevel, new ArrayList<String>());
for (File file : fileListing) {
// Only accept true files
if (file.isDirectory()) continue;
final String path = Pattern.quote(toplevel.getAbsolutePath());
String name = "";
name = file.getAbsolutePath().replaceAll(path, "");
name = name.substring(1);
name = name.replace("\\", "/");
rval.add(name);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return rval;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#listToplevelClassNames()
*/
@Override
public Collection<String> listToplevelClassNames() {
final Collection<String> rval = new ArrayList<String>();
final File toplevel = new File(this.location);
try {
List<File> fileListing = getFileListing(toplevel, new ArrayList<String>());
for (File file : fileListing) {
// Only accept class files
if (!file.getAbsolutePath().endsWith(".class")) continue;
//if (file.getAbsolutePath().contains("$")) continue; // Why are we ignoring files with a $ again?
final String path = Pattern.quote(toplevel.getAbsolutePath());
String name = "";
name = file.getAbsolutePath().replaceAll(path, "");
name = name.substring(1);
name = name.replace("\\", "/");
name = name.replace("/", ".");
// Remove trailing .class
if (name.endsWith("class")) {
name = name.substring(0, name.length() - 6);
}
rval.add(name);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return rval;
}
/**
* List all files
*
* @param aStartingDir
* @return
* @throws FileNotFoundException
*/
private List<File> getFileListing(File aStartingDir, List<String> visited)
throws FileNotFoundException {
// Sanity check
if (aStartingDir == null || aStartingDir.listFiles() == null)
return new ArrayList<File>();
this.logger.fine("Obtaining file listing for: " + aStartingDir);
final String[] ignoreList = new String[] { "/dev/", "/sys/", "/proc/" };
final List<File> result = new ArrayList<File>();
for (File file : aStartingDir.listFiles()) {
boolean skip = false;
// Very ugly Android related hack, remove this if we have a better solution to detect a recursion.
for (String ignore : ignoreList) {
if (file.getAbsolutePath().contains(ignore)) {
this.logger.warning("Android hack actve. Ignoring directory containing " + ignore);
skip = true;
}
}
// Now skip
if (skip) continue;
result.add(file);
// TODO: Is it possible that this doen't work as expected? Check if there is a better
// recursion test ...
{
String canonical = null;
// Why can this fail?
try {
canonical = file.getCanonicalPath();
} catch (IOException e) {
e.printStackTrace();
}
// Anyway, safteycheck: Only process this path if it hasn't already been seen
if (canonical != null) {
if (visited.contains(canonical)) continue;
visited.add(canonical);
}
}
// Okay, in here the sub element must have been new, inspect it.
if (file.isDirectory()) {
List<File> deeperList = getFileListing(file, visited);
result.addAll(deeperList);
}
}
return result;
}
}
|
Java
|
/*
* JARClasspathLocation.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.locator.locations;
import java.io.IOException;
import java.io.InputStream;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache.JARInformation;
import net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation;
/**
* Tries to load plugins from a JAR class path location.
*
* @author Ralf Biedert
*/
public class JARClasspathLocation extends AbstractClassPathLocation {
/**
* @param cache
* @param realm
* @param location
*/
public JARClasspathLocation(JARCache cache, String realm, URI location) {
super(cache, realm, location);
}
/**
* @return the location
*/
public JARInformation getCacheEntry() {
// If we have a JAR
if (getType() == LocationType.JAR && this.cache != null)
this.cacheEntry = this.cache.getJARInformationFor(this.location);
return this.cacheEntry;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#getType()
*/
@Override
public LocationType getType() {
return LocationType.JAR;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#getInputStream(java.lang.String)
*/
@Override
public InputStream getInputStream(String file) {
try {
final JarURLConnection connection = (JarURLConnection) new URI("jar:" + this.location + "!/").toURL().openConnection();
final JarFile jarFile = connection.getJarFile();
final Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
final JarEntry entry = entries.nextElement();
// We only search for class file entries
if (entry.isDirectory()) continue;
String name = entry.getName();
if (name.equals(file)) return jarFile.getInputStream(entry);
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
return null;
}
/**
* Returns a list of predefined plugins inside this jar.
*
* @return .
*/
public Collection<String> getPredefinedPluginList() {
return null;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#listAllEntries()
*/
@Override
public Collection<String> listAllEntries() {
return listAllEntriesFor(this.location);
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation#listToplevelClassNames()
*/
@Override
public Collection<String> listToplevelClassNames() {
final Collection<String> rval = listToplevelClassNamesForURI(this.location);
if (this.cacheEntry != null) this.cacheEntry.classesValid = true;
return rval;
}
/**
* Lists all entries for the given JAR.
*
* @param uri
* @return .
*/
public static Collection<String> listAllEntriesFor(URI uri) {
final Collection<String> rval = new ArrayList<String>();
try {
final JarURLConnection connection = (JarURLConnection) new URI("jar:" + uri + "!/").toURL().openConnection();
final JarFile jarFile = connection.getJarFile();
final Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
final JarEntry entry = entries.nextElement();
// We only search for class file entries
if (entry.isDirectory()) continue;
String name = entry.getName();
rval.add(name);
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
return rval;
}
/**
* Lists all top level class entries for the given URL.
*
* @param uri
* @return .
*/
public static Collection<String> listToplevelClassNamesForURI(URI uri) {
final Collection<String> rval = new ArrayList<String>();
// Ensure we have a proper cache entry ...
//getCacheEntry();
// Disabled: Not really necessary, is it? And not storing/retrieving these items
// makes the cache file smaller and saves several ms (~200) loading and storing it
//if (this.cacheEntry.classesValid) { return this.cacheEntry.classes; }
try {
final JarURLConnection connection = (JarURLConnection) new URI("jar:" + uri + "!/").toURL().openConnection();
final JarFile jarFile = connection.getJarFile();
final Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
final JarEntry entry = entries.nextElement();
// We only search for class file entries
if (entry.isDirectory()) continue;
if (!entry.getName().endsWith(".class")) continue;
String name = entry.getName();
name = name.replaceAll("/", ".");
// Remove trailing .class
if (name.endsWith("class")) {
name = name.substring(0, name.length() - 6);
}
// Disabled: Not really necessary, is it? And not storing/retrieving these items
// makes the cache file smaller and saves several ms (~200) loading and storing it
// Only store something if we have a cache entry
//if (this.cacheEntry != null) this.cacheEntry.classes.add(name);
rval.add(name);
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
return rval;
}
}
|
Java
|
/*
* ClasspathLocator.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.locator;
import static net.jcores.jre.CoreKeeper.$;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import net.jcores.jre.interfaces.functions.F1;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.diagnosis.channels.tracing.SpawnerTracer;
import net.xeoh.plugins.base.impl.PluginManagerImpl;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
import net.xeoh.plugins.base.options.addpluginsfrom.OptionSearchAround;
import net.xeoh.plugins.base.util.PluginConfigurationUtil;
import net.xeoh.plugins.diagnosis.local.Diagnosis;
import net.xeoh.plugins.diagnosis.local.util.DiagnosisChannelUtil;
/**
* Used to find classpaths, JARs and their contents.
*
* @author Ralf Biedert
*/
public class ClassPathLocator {
/** Cache to lookup elements */
private final JARCache cache;
/** Mainly used to access the config. */
private PluginManagerImpl pluginManager;
/**
* @param pluginManager
* @param cache
*/
public ClassPathLocator(PluginManagerImpl pluginManager, JARCache cache) {
this.pluginManager = pluginManager;
this.cache = cache;
}
/**
* Given a top level entry, finds a list of class path locations below the given
* entry. The top level entry can either be a folder, or it can be a JAR directly.
*
* @param toplevel The top level URI to start from.
* @return A list of class path locations.
*/
public Collection<AbstractClassPathLocation> findBelow(URI toplevel) {
final Collection<AbstractClassPathLocation> rval = new ArrayList<AbstractClassPathLocation>();
final File startPoint = new File(toplevel);
// First, check if the entry represents a multi-plugin (in that case we don't add
// anything else)
if ($(startPoint).filter(".*\\.plugin?$").get(0) != null) {
rval.add(AbstractClassPathLocation.newClasspathLocation(this.cache, toplevel.toString(), toplevel));
return rval;
}
// Check if this is a directory or a file
if (startPoint.isDirectory()) {
final File[] listFiles = startPoint.listFiles();
boolean hasJARs = false;
for (File file : listFiles) {
if (file.getAbsolutePath().endsWith(".jar")) {
rval.add(AbstractClassPathLocation.newClasspathLocation(this.cache, file.toURI().toString(), file.toURI()));
hasJARs = true;
}
if ($(file).filter(".*\\.plugin?$").get(0) != null) {
rval.add(AbstractClassPathLocation.newClasspathLocation(this.cache, file.toURI().toString(), file.toURI()));
hasJARs = true;
}
}
// If we have JARs, we already added them
if (hasJARs) return rval;
// If we have no JARs, this is probably a classpath, in this case warn that
// the method is not recommended
if (toplevel.toString().contains("/bin/") || toplevel.toString().contains("class")) {
System.err.println("Adding plugins in 'raw' classpaths, such as 'bin/' or 'classes/' is not recommended. Please use classpath://* instead (the video is a bit outdated in this respect).");
}
rval.add(AbstractClassPathLocation.newClasspathLocation(this.cache, toplevel.toString(), toplevel));
return rval;
}
// If this is directly a JAR, add this
if (startPoint.isFile() && startPoint.getAbsolutePath().endsWith(".jar")) {
rval.add(AbstractClassPathLocation.newClasspathLocation(this.cache, toplevel.toString(), toplevel));
return rval;
}
return rval;
}
/**
* Gets all contributing classpaths for a given class by traversing all parent-classloader.
*
* @since 1.1
* @param clazz The class to get all classloaders for.
* @return A list of all contributing classloaders.
*/
protected List<String> allClasspathsFor(Class<?> clazz) {
final DiagnosisChannelUtil<String> channel = new DiagnosisChannelUtil<String>(this.pluginManager.getPlugin(Diagnosis.class).channel(SpawnerTracer.class));
final List<String> rval = $.list();
channel.status("allclasspathsfor/start", "class", clazz.toString());
// In case JSPF has been loaded from an URL class loader as well (Issue #29)
URLClassLoader ourloader = $(clazz.getClassLoader()).cast(URLClassLoader.class).get(0);
while (ourloader != null) {
// Removed check for system classloader, might need its elements as well
channel.status("allclasspathsfor/urlloader");
rval.addAll($(ourloader.getURLs()).file().forEach(new F1<File, String>() {
@Override
public String f(File arg0) {
channel.status("allclasspathsfor/urlloader/path", "path", arg0);
return arg0.getAbsolutePath();
}
}).list());
ourloader = $(ourloader.getParent()).cast(URLClassLoader.class).get(0);
}
channel.status("allclasspathsfor/end");
return $(rval).unique().list();
}
/**
* Finds all locations inside the current classpath.
* @param options
*
* @return A list of all locations in the current classpath.
*/
@SuppressWarnings("boxing")
public Collection<AbstractClassPathLocation> findInCurrentClassPath(AddPluginsFromOption[] options) {
final DiagnosisChannelUtil<String> channel = new DiagnosisChannelUtil<String>(this.pluginManager.getPlugin(Diagnosis.class).channel(SpawnerTracer.class));
channel.status("findinclasspath/start");
final Collection<AbstractClassPathLocation> rval = new ArrayList<AbstractClassPathLocation>();
// Get our current classpath (TODO: Better get this using
// ClassLoader.getSystemClassLoader()?)
final boolean filter = new PluginConfigurationUtil(this.pluginManager.getPluginConfiguration()).getBoolean(PluginManager.class, "classpath.filter.default.enabled", true);
final String blacklist[] = new PluginConfigurationUtil(this.pluginManager.getPluginConfiguration()).getString(PluginManager.class, "classpath.filter.default.pattern", "/jre/lib/;/jdk/lib/;/lib/rt.jar").split(";");
final String pathSep = System.getProperty("path.separator");
final String classpath = System.getProperty("java.class.path");
final List<URL> toFilter = new ArrayList<URL>();
// Get the starting point
final Class<?> startPoint = $(options).get(OptionSearchAround.class, new OptionSearchAround(getClass())).getClazz();
// Get all classpaths
List<String> classpaths = $(classpath.split(pathSep)).list();
classpaths.addAll(allClasspathsFor(startPoint));
classpaths = $(classpaths).unique().list();
// Check if we should filter, if yes, get topmost classloader so we know
// what to filter out
if (filter) {
channel.status("findinclasspath/filter");
ClassLoader loader = ClassLoader.getSystemClassLoader();
while (loader != null && loader.getParent() != null)
loader = loader.getParent();
// Get 'blacklist' and add it to our filterlist
if (loader != null && loader instanceof URLClassLoader) {
URL[] urls = ((URLClassLoader) loader).getURLs();
for (URL url : urls) {
channel.status("findinclasspath/filter/add", "item", url);
toFilter.add(url);
}
}
}
// Process all possible locations
for (String string : classpaths) {
if(string == null) continue;
try {
final URL url = new File(string).toURI().toURL();
channel.status("findinclasspath/add", "raw", string, "url", url);
// Check if the url was already contained
if (toFilter.contains(url) || blacklisted(blacklist, url)) {
channel.status("findinclasspath/add/blacklisted", "raw", string, "url", url);
continue;
}
// And eventually add the location
rval.add(AbstractClassPathLocation.newClasspathLocation(this.cache, "#classpath", new File(string).toURI()));
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
return rval;
}
/**
* Checks if the given URL is blacklisted
*
* @param blacklist
* @param url
* @return
*/
private boolean blacklisted(String[] blacklist, URL url) {
// Default sanity check
if (blacklist == null || blacklist.length == 0 || blacklist[0].length() == 0)
return false;
// Go thorugh blacklist
for (String string : blacklist) {
if (url.toString().contains(string)) return true;
}
return false;
}
}
|
Java
|
/*
* ClasspathLoaction.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.classpath.locator;
import static net.jcores.jre.CoreKeeper.$;
import java.io.InputStream;
import java.net.URI;
import java.util.Collection;
import java.util.logging.Logger;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache;
import net.xeoh.plugins.base.impl.classpath.cache.JARCache.JARInformation;
import net.xeoh.plugins.base.impl.classpath.locator.locations.FileClasspathLocation;
import net.xeoh.plugins.base.impl.classpath.locator.locations.JARClasspathLocation;
import net.xeoh.plugins.base.impl.classpath.locator.locations.MultiPluginClasspathLocation;
/**
* Location of a classpath (i.e., either a JAR file or a toplevel directory)
*
* TODO: Constrict two subclasses, JARClassPathLocation and FileClassPathLocation
*
* @author Ralf Biedert
*
*/
public abstract class AbstractClassPathLocation {
/**
*
* Type of this location
*
* @author Ralf Biedert
*
*/
public enum LocationType {
/** Is a JAR */
JAR,
/** Is an ordinary dir */
DIRECTORY,
/** A multiplugin*/
MULTI_PLUGIN
}
/** */
protected final Logger logger = Logger.getLogger(this.getClass().getName());
/** Location of this item */
protected final URI location;
/** ID of this entry */
protected final String realm;
/** */
protected final JARCache cache;
/** Information for this location entry */
protected JARInformation cacheEntry = null;
/**
* @param cache
* @param realm
* @param location
*/
protected AbstractClassPathLocation(JARCache cache, String realm, URI location) {
this.cache = cache;
this.realm = realm;
this.location = location;
}
/**
* Constructs a new ClassPathLocation which handles all classes within.
*
* @param cache The cache to lookup the entrie's content.
* @param realm The real name.
* @param location URI location of the given classpath.
* @return The constructed location.
*/
public static AbstractClassPathLocation newClasspathLocation(JARCache cache,
String realm,
URI location) {
if ($(location).filter(".*\\.plugin[/]$").get(0) != null)
return new MultiPluginClasspathLocation(cache, realm, location);
if (location.toString().endsWith(".jar"))
return new JARClasspathLocation(cache, realm, location);
return new FileClasspathLocation(cache, realm, location);
}
/**
* Returns the top level classpath location. This is *NOT* equal to the
* the classpath-entries this location provides. Especially multi-plugins
* may consist of a number of JARs required for proper class resolution.
*
* @return The top level location
*/
public URI getToplevelLocation() {
return this.location;
}
/**
* Gets all classpath entries required to properly load plugins. Add them
* to a class loader.
*
* @return the location
*/
public URI[] getClasspathLocations() {
return new URI[] { this.location };
}
/**
* @return the location
*/
public String getRealm() {
return this.realm;
}
/**
* Get the type of this entry
*
* @return .
*/
public abstract LocationType getType();
/**
* Lists the name of all classes inside this classpath element
*
* @return .
*/
public abstract Collection<String> listToplevelClassNames();
/**
* Lists all entries in this location, no matter if class or file (excluding directories)
*
* @return .
*/
public abstract Collection<String> listAllEntries();
/**
* Creates an input stream for the requested item
*
* @param entry
*
* @return .
*/
public abstract InputStream getInputStream(String entry);
}
|
Java
|
/*
* PluginConfigurationImpl.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl;
import java.util.Properties;
import java.util.logging.Logger;
import net.xeoh.plugins.base.PluginConfiguration;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import net.xeoh.plugins.base.annotations.meta.Author;
import net.xeoh.plugins.base.annotations.meta.Version;
/**
*
*
* @author Ralf Biedert
*
*/
@Author(name = "Ralf Biedert")
@PluginImplementation
@Version(version = Version.UNIT_MAJOR)
public class PluginConfigurationImpl implements PluginConfiguration {
/** Actual properties object we use */
final Properties configuration;
/** */
final Logger logger = Logger.getLogger(this.getClass().getName());
/**
* @param initialProperties
*/
protected PluginConfigurationImpl(final Properties initialProperties) {
this.configuration = initialProperties;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.PluginConfiguration#getConfiguration(java.lang.Class,
* java.lang.String)
*/
public synchronized String getConfiguration(final Class<?> root, final String subkey) {
final String key = getKey(root, subkey);
final String value = this.configuration.getProperty(key);
this.logger.fine("Returning '" + value + "' for " + "'" + key + "'");
return value;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.PluginConfiguration#setConfiguration(java.lang.Class,
* java.lang.String, java.lang.String)
*/
public synchronized void setConfiguration(final Class<?> root, final String subkey,
final String value) {
final String key = getKey(root, subkey);
this.logger.fine("Setting '" + value + "' for " + "'" + key + "'");
this.configuration.setProperty(key, value);
}
/**
* Assemble a key for a given root class and subkey string
*
* @param root Root (may be null)
* @param subkey (subkey to use)
* @return The fully assembled key.
*/
private String getKey(final Class<?> root, final String subkey) {
String prefix = "";
if (root != null) {
prefix = root.getName() + ".";
}
this.logger.finer("Assembled key '" + prefix + subkey + "'");
return prefix + subkey;
}
}
|
Java
|
/*
* Benchmarker.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl.util;
import java.util.HashMap;
import java.util.Map;
/**
* @author rb
*
*/
public class Benchmarker {
static Map<Integer, Long> times = new HashMap<Integer, Long>();
/**
* @param id
*
*/
@SuppressWarnings("boxing")
public static void start(int id) {
times.put(id, System.nanoTime());
}
/**
* @param id
* @param label
*/
@SuppressWarnings("boxing")
public static void stop(int id, String label) {
long stop = System.nanoTime();
long d = stop - times.get(id);
System.out.println(label + ": " + (d / 1000));
}
}
|
Java
|
/*
* PluginManagerFactory.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.impl;
import java.util.Properties;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginConfiguration;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.util.JSPFProperties;
import net.xeoh.plugins.base.util.PluginManagerUtil;
/**
* Factory class to create new {@link PluginManager}. This is your entry and starting point for
* using JSPF. Create a new manager by calling one of the enclosed methods.<br/><br/>
*
* There should be no need to access this class (or call any of its methods) more than once
* during the lifetime of your application.
*
* @author Ralf Biedert
*/
public class PluginManagerFactory {
/** This class will not be instantiated. */
private PluginManagerFactory() {
//
}
/**
* Creates a new {@link PluginManager}, no user configuration is used. The manager will
* be (almost) empty, i.e., containing no {@link Plugin}s except some internal ones.<br/><br/>
*
* The next thing you should probably do is adding your own plugins by calling
* <code>addPluginsFrom()</code>.
*
* @return A fresh plugin manager.
*/
public static PluginManager createPluginManager() {
return createPluginManager(new Properties());
}
/**
* Creates a new {@link PluginManager} which will be wrapped in a {@link PluginManagerUtil} object,
* no user configuration is used. The manager will be (almost) empty, i.e., containing no {@link Plugin}s
* except some internal ones.<br/><br/>
*
* The next thing you should probably do is adding your own plugins by calling
* <code>addPluginsFrom()</code>.
*
* @since 1.0.3
* @return A freshly wrapped plugin manager.
*/
public static PluginManagerUtil createPluginManagerX() {
return new PluginManagerUtil(createPluginManager());
}
/**
* Creates a new {@link PluginManager} with a supplied user configuration. The user configuration
* can be obtained by using the {@link PluginConfiguration}. <br/><br/>
*
* The next thing you should probably do is adding your own plugins by calling
* <code>addPluginsFrom()</code>.<br/><br/>
*
* In order to assist debugging, you can set one of {@link JSPFProperties}'s preferences by
* calling: <code>setProperty(PluginManager.class, "logging.level", "INFO")</code> (INFO
* can be replaced by OFF, WARNING, INFO, FINE, FINER or FINEST respectively.
*
* @param initialProperties Initial properties to use.
*
* @return A fresh manager with the supplied configuration.
*/
public static PluginManager createPluginManager(final Properties initialProperties) {
// Setup logging
if (initialProperties.containsKey("net.xeoh.plugins.base.PluginManager.logging.level")) {
final String level = initialProperties.getProperty("net.xeoh.plugins.base.PluginManager.logging.level");
setLogLevel(Level.parse(level));
}
// Lower the JMDNS level (TODO: Why doen't this work?)
Logger.getLogger("javax.jmdns").setLevel(Level.OFF);
return new PluginManagerImpl(initialProperties);
}
/**
* Creates a new {@link PluginManager}, wrapped in a {@link PluginManagerUtil} object, with a supplied user
* configuration. The user configuration can be obtained by using the {@link PluginConfiguration}. <br/><br/>
*
* The next thing you should probably do is adding your own plugins by calling
* <code>addPluginsFrom()</code>.<br/><br/>
*
* In order to assist debugging, you can set one of {@link JSPFProperties}'s preferences by
* calling: <code>setProperty(PluginManager.class, "logging.level", "INFO")</code> (INFO
* can be replaced by OFF, WARNING, INFO, FINE, FINER or FINEST respectively.
*
* @param initialProperties Initial properties to use.
* @since 1.0.3
* @return A freshly wrapped manager with the supplied configuration.
*/
public static PluginManagerUtil createPluginManagerX(final Properties initialProperties) {
return new PluginManagerUtil(createPluginManager(initialProperties));
}
/**
* Sets logging to the specified level.
*/
private static void setLogLevel(Level level) {
Logger.getLogger("").setLevel(level);
Handler[] handlers = Logger.getLogger("").getHandlers();
for (Handler handler : handlers) {
handler.setLevel(level);
}
}
}
|
Java
|
/*
* Plugin.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import net.xeoh.plugins.base.util.PluginUtil;
/**
* The base class of all plugins. Plugin creation is fairly simple: <br>
* <br>
* 1. Create a new top level package for your plugin, e.g.,
* <code>com.company.plugins.imagedb</code> in case of an image database.<br>
* <br>
* 2. Create an interface within that package. The interface should (well, must)
* extend Plugin. Add all the methods you like, for example <code>listImages()</code><br>
* <br>
* 3. Create an impl sub-package with the plugin package, in our case this is
* <code>com.company.plugins.imagedb.impl</code>. The <i>impl</i>-name is not
* required, but should be kept as a convention. In the future there might exist
* tools that depend on it, or work better with it. If you have multiple implementations,
* create several sub-packages within the impl folder. In our example case, this
* could be the implementations <code>impl.simple</code> (for a simple test
* implementation), <code>impl.distributed</code> (for our distributed image storage)
* and <code>impl.compatiblity</code> (for the old DB API)<br>
* <br>
* 4. Implement your interfaces, i.e., create a class / classes inside the
* respective <code>impl</code> folder.<br>
* <br>
* 5. Add the @{@link PluginImplementation} annotation to your implemented
* class(es).<br>
* <br>
* 6. You're done. Technically your plugin is ready now to use. It can be compiled
* now (Eclipse will probably have done this for you already). You might want to
* have a look at the {@link PluginManager} documentation to see how you can load and retrieve
* it (see <code>addPluginsFrom()</code> and <code>getPlugin()</code>).<br>
* <br>
* NOTE: You should <b>ensure that all implementations of your plugins are thread
* safe</b>! Expect your functions to be called any time in any state.
*
* @author Ralf Biedert
* @see PluginManager
* @see PluginUtil
*/
public interface Plugin {
}
|
Java
|
/*
* PluginManager.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base;
import java.net.URI;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import net.xeoh.plugins.base.annotations.injections.InjectPlugin;
import net.xeoh.plugins.base.impl.PluginManagerFactory;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
import net.xeoh.plugins.base.options.GetPluginOption;
import net.xeoh.plugins.base.util.JSPFProperties;
import net.xeoh.plugins.base.util.PluginManagerUtil;
import net.xeoh.plugins.base.util.uri.ClassURI;
import net.xeoh.plugins.informationbroker.InformationBroker;
/**
* This is your entry point to and the heart of JSPF. The plugin manager keeps track of all
* registed plugins and gives you methods to add and query them. You cannot instantiate the
* PluginManager directly, instead you<br/><br/>
*
* <center>create this class the first time by a call to {@link PluginManagerFactory}<code>.createPluginManager()</code></center>
*
* <br/><br/>
* Afterwards you probably want to add some of your own plugins. During the lifetime of your
* application there should only be one PluginManager. The PluginManager does not have to be
* passed to the inside of your plugins, instead, they can request it by the @{@link InjectPlugin}
* annotation (i.e, create a field '<code>public PluginManager manager</code>' and add the
* annotation).<br/><br/>
*
* There are also a number of default plugins you can retrieve right away (without calling
* <code>addPluginsFrom()</code> explicitly.). These are:<br/><br/>
*
* <ul>
* <li>{@link PluginConfiguration} - enables you to get and set config options</li>
* <li>{@link PluginInformation} - provides meta information about plugins</li>
* <li>{@link InformationBroker} - supports information exchange between plugins while keeping them decoupled</li>
* </ul><br/>
*
* In addition (and after loading the specific plugin) you can also retrieve a RemoteAPI.
* <br/><br/>
*
* The following configuration sub-keys are usually known for this class (see {@link PluginConfiguration}, keys must be set
* <em>before</em> createPluginManager() is being called, i.e., set in the {@link JSPFProperties} object!):<br/><br/>
*
* <ul>
* <li><b>cache.enabled</b> - Specifies if the known plugins should be cached. Specify either {true, false}.</li>
* <li><b>cache.mode</b> - If we should use strong caching (slow but more accurate) or weak (much faster). Specify either {stong, weak}. </li>
* <li><b>cache.file</b> - Cache file to use. Specify any relative or absolute file path, file will be created / overwritten.</li>
* <li><b>classpath.filter.default.enabled</b> - If Java default classpaths (e.g., jre/lib/*) should be filtered. Specify either {true, false}. Might not work on all platforms as expected.</li>
* <li><b>classpath.filter.default.pattern</b> - Specify what to filter in addition to default classpaths. Specify a list of ';' separated tokens, e.g., "jdk/lib;jre/lib". Will be matched against URL representations, so all \\ will be converted to / (and ' ' might become %20, ...).</li>
* <li><b>logging.level</b> - Either {OFF, FINEST, FINER, FINE, INFO, WARNING, ALL}. Specifies what to log on the console. </li>
* </ul><br/>
* @see PluginManagerUtil
*
* @author Ralf Biedert
*/
public interface PluginManager extends Plugin {
/**
* Requests the plugin manager to add plugins from a given path. The path can be
* either a folder-like item where existing .zip and .jar files are trying to be
* added, as well as existing class files. The path can also be a singular .zip or
* .jar which is added as well.<br><br>
*
* The manager will search for classes having the @{@link PluginImplementation}
* annotation and evaluate this annotation. Thereafter the plugin will be instantiated.<br><br>
*
* Currently supported are classpath-folders (containing no .JAR files), plugin folders
* (containing .JAR files or multiplugins), single plugins and HTTP locations. Example
* calls look like this:<br/><br/>
*
* <ul>
* <li><code>addPluginsFrom(new URI("classpath://*"))</code> (add all plugins within the current classpath).</li>
* <li><code>addPluginsFrom(new File("plugins/").toURI())</code> (all plugins from the given folder, scanning for JARs and <a href="http://code.google.com/p/jspf/wiki/FAQ">multi-plugins</a>).</li>
* <li><code>addPluginsFrom(new File("plugin.jar").toURI())</code> (the given plugin directly, no scanning is being done).</li>
* <li><code>addPluginsFrom(new URI("http://sample.com/plugin.jar"))</code> (downloads and adds the given plugin, use with caution).</li>
* <li><code>addPluginsFrom(new ClassURI(ServiceImpl.class).toURI())</code> (adds the specific plugin implementation already present in the classpath; very uncomfortable, very fast).</li>
* </ul>
*
*
* @see ClassURI
*
* @param url The URL to add from. If this is "classpath://*"; the plugin manager will
* load all plugins within it's own classpath.
*
* @param options A set of options supported. Please see the individual options for more
* details.
* @return This plugin manager.
*/
public PluginManager addPluginsFrom(URI url, AddPluginsFromOption... options);
/**
* Returns the next best plugin for the requested interface. The way the plugin is being
* selected is undefined, you should assume that a random plugin implementing the requested
* interface is chosen. <br><br>
*
* This method is more powerful than it looks like on first sight, especially in conjunction
* with the right {@link GetPluginOption}.
*
* @param <P> Type of the plugin / return value.
*
* @param plugin The interface to request. The given class <b>must</b> derive from Plugin. You <b>MUST NOT</b> pass
* implementation classes. Only interface classes are accepted (i.e. <code>getPlugin(Service.class)</code>
* is fine, while <code>getPlugin(ServiceImpl.class)</code> isn't.
* @param options A set of options for the request.
*
* @return A randomly chosen Object that implements <code>plugin</code>.
*/
public <P extends Plugin> P getPlugin(Class<P> plugin, GetPluginOption... options);
/**
* Tells the plugin manager to shut down. This may be useful in cases where you want all
* created plugins to be destroyed and shutdown hooks called. Normally this happens during
* application termination automatically, but sometimes you create a 2nd instance in the same
* machine and want the first one to close properly.
*
* All invocations after the first one have no effect.
*/
public void shutdown();
}
|
Java
|
/*
* InitPlugin.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Methods marked with @Timer will called periodically from a timer. The method
* may return a boolean value. If this value is true, the timer will be canceled. For
* example, to specify that after the plugin's creation a specific method should be
* called from a timer, you would write:<br/><br/>
*
* <code>
* @Timer<br/>
* public void ping() { ... }
* </code><br/><br/>
*
* All timers are terminated upon <code>PluginManager.shutdown()</code>.
* @author Ralf Biedert
* @see Thread
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Timer {
/**
* Type of the timer.
*
* @author Ralf Biedert
*
*/
public static enum TimerType {
/**
* Delay based timer
*/
DELAY_BASED,
/**
* Rate based timer
*/
RATE_BASED
}
/**
* Period of the timer.
*
* @return .
*/
long period();
/**
* When to start the timer.
*
* @return .
*/
long startupDelay() default 0;
/**
* Specifies the type of this timer.
*
* @return .
*/
TimerType timerType() default TimerType.DELAY_BASED;
}
|
Java
|
/*
* InitPlugin.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.annotations.events.Init;
import net.xeoh.plugins.base.options.getplugin.OptionCapabilities;
/**
* Methods marked with Capabilities are queried by PluginInformation. The method MUST be
* public and it MUST return a String[] array. If several methods are annotated it is
* undefined which one will be called. <br/><br/>
*
* As soon as the @{@link Init} annotation is processed the capabilities function must be
* operational. Use this function for example to tell which file extensions you can handle
* or the (limited number of) host you can connect to. While this method can return different
* values on every call it is considered "bad taste" if latter calls return anything less
* than the previous calls.<br/><br/>
*
* For example, if you want a plugin to indicate that it can handle a set of languages,
* you could write:<br/><br/>
*
* <code>
* @Capabilities<br/>
* public String[] capabilities() { return new String[] {"language:english", "language:german"}; }
* </code><br/><br/>
*
* Later on, you can use {@link OptionCapabilities} within the {@link PluginManager}'s <code>getPlugin()</code> method to
* retrieve all plugins providing certain capabilities.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Capabilities {
//
}
|
Java
|
/*
* InitPlugin.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.events;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.annotations.Timer;
import net.xeoh.plugins.base.annotations.injections.InjectPlugin;
/**
* Use this annotation to mark functions which should be called on initialization. You
* can be sure that at this phase all required plugins (see @{@link InjectPlugin}),
* that have not been marked as optional, are available. So, for
* example, if you want a method to be called when the plugin is ready, you could
* write:<br/><br/>
*
* <code>
* @Init<br/>
* public void startup() { ... }
* </code><br/><br/>
*
* This method usually does not have to return a value (return type <code>void</code>).
* It may, however, return as well a boolean. If it then returns <code>false</code>, initialization of
* this plugin will be canceled, no @{@link net.xeoh.plugins.base.annotations.Thread} or @{@link Timer} will be started, no other
* @{@link Init} methods will be called and the plugin will not be touched any more. <br/><br/>
*
* Note: Methods annotated with this have to be PUBLIC, otherwise they won't be found.
*
* @author Ralf Biedert
* @see Shutdown
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Init {
// Just a marker interface
}
|
Java
|
/*
* InitPlugin.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package net.xeoh.plugins.base.annotations.events;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.annotations.injections.InjectPlugin;
/**
*
* Called when a plugin of the given interface was registered. For example, if you want to
* be called when a new Plugin of the type <code>StorageService</code> was added, you could
* write:<br/><br/>
*
* <code>
* @PluginLoaded<br/>
* public void checkPlugin(StorageService service) { ... }
* </code><br/><br/>
*
* This method is especially useful in the case of plugins added <i>in the future</i>. Sometimes
* you rely on a plugin which is not there in the early stage of your application lifetime. If you
* depended on it with {@link InjectPlugin}, you either would not see it, or your own plugin would
* be suspended until it was loaded. Using the <code>PluginLoaded</code> you can start up anyway
* and wait for it in this callback-like mechanism.<br/><br/>
*
* Note: Methods annotated with this have to be PUBLIC, otherwise they won't be found.
*
* @author Ralf Biedert
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface PluginLoaded {
//
}
|
Java
|
/**
* Annoations related to plugin events.
*
* @since 1.0
*/
package net.xeoh.plugins.base.annotations.events;
|
Java
|
/*
* InitPlugin.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.events;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.PluginManager;
/**
* Methods marked with this interface will be called on the shutdown of the {@link PluginManager}.
* Plugins *must not* assume anything about the status of other plugins, even if they depend on them;
* everyone dies alone. Just free all resources you allocated yourself, and do it fast. For
* example, if you want a method to be called upon the Manager's shutdown, you could
* write:<br/><br/>
*
* <code>
* @Shutdown<br/>
* public void bye() { ... }
* </code><br/><br/>
*
*
* Note: Methods annotated with this have to be PUBLIC, otherwise they won't be found.
*
* @author Ralf Biedert
* @see Init
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Shutdown {
// Just a marker interface
}
|
Java
|
/**
* Core annotations for plugins. Please note that all of these annotations
* only work directly inside the plugin class and NOT in any of its embedded
* objects.
*
* @since 1.0
*/
package net.xeoh.plugins.base.annotations;
|
Java
|
/*
* InitPlugin.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Methods marked with @Thread will be called from a newly created thread. For example,
* to specify that after the plugin's creation a specific method should be called from a
* dedicated thread, you would write:<br/><br/>
*
* <code>
* @Thread<br/>
* public void background() { ... }
* </code><br/><br/>
*
* All threads are terminated upon <code>PluginManager.shutdown()</code>.
*
*
* @author Ralf Biedert
* @see Timer
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Thread {
/**
* If the thread should be daemonic.
*
* @return True if the VM may exit with the thread still running..
*/
boolean isDaemonic() default true;
}
|
Java
|
/*
* ConfigurationFile.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.configuration;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.prefs.Preferences;
/**
* Specifies a configuration file relative to the given plugin. Its content will be added
* to the global configuration (@see PluginConfiguration). For example, to specify that the
* configuration file <code>config.properties</code> in the same package as the plugin should
* be added the the configuration, write<br/><br/>
*
* <code>
* @PluginImplementation<br/>
* @ConfigurationFile(file="config.properties")<br/>
* public class ServiceImpl implements Service { ... }
* </code><br/><br/>
*
* The configuration file is a standard Java preferences file.
*
* @author Ralf Biedert
* @see Preferences
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ConfigurationFile {
/**
* The configuration File to load, relative to the package root. Note that the file
* will only be added to the global configuration if the plugin is not disabled.
*
* @return Relative path to the configuration file.
*/
String file() default "";
}
|
Java
|
/*
* IsDisabled.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.configuration;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.annotations.PluginImplementation;
/**
* Marks the given plugin is diabled and will not be spawned. Nor will its configuration
* be added to the global configuration. Use this to quickly disable a plugin for testing
* purposes. For example, to specify that a plugin should be disabled, write<br/><br/>
*
* <code>
* @IsDisabled<br/>
* @PluginImplementation<br/>
* public class ServiceImpl implements Service { ... }
* </code><br/><br/>
*
* Might be removed in the future (as removing {@link PluginImplementation} has the same
* effect).
*
* @author Ralf Biedert
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface IsDisabled {
// Marker only
}
|
Java
|
/**
* Annotations related to plugin loading.
*
* @since 1.0
*/
package net.xeoh.plugins.base.annotations.configuration;
|
Java
|
/*
* AutoInject.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.injections;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.jcores.jre.annotations.Beta;
import net.xeoh.plugins.base.PluginManager;
/**
* Inject all possible instance implementing into this plugin. The same as if you annotated
* each variable and method with {@link InjectPlugin}.<br/><br/>
*
* <code>
* @AutoInject<br/>
* @PluginImplementation<br/>
* public class MyPlugin ...;
* </code><br/><br/>
*
* Please note: The annotated variable has to be <b>public</b>!
*
* @author Ralf Biedert
* @see PluginManager
*
*/
@Beta
@Target(value = { ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoInject {
}
|
Java
|
/*
* InjectPluginManager.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.injections;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.annotations.Capabilities;
/**
* Inject some instance implementing the given plugin interface. If the plugin is not available
* at spawntime (and the dependency is marked as optional), null will be inserted. If the plugin
* was not marked as optional this plugin will not be spawned. For example,
* to specify that the PluginManager should be injected into the plugin, you would write:<br/><br/>
*
* <code>
* @InjectPlugin<br/>
* public PluginManager pluginManager;
* </code><br/><br/>
*
* Another example. To specify that a language service for Swahili should be injected in case it
* is there and null in case it is not, you could write:<br/><br/>
*
* <code>
* @InjectPlugin(requiredCapabilities = {"language:swahili"}, isOptional=true)<br/>
* public LanguageService service;
* </code><br/><br/>
*
* This ensures that the returned plugin, if it is there, is of type <code>LanguageService</code> and has the
* capability (see {@link Capabilities}) of processing Swahili. If <code>isOptional</code> is <code>false</code>
* or omitted then it is even ensured that this plugin will not be spawned unless the given service is available.
* <br/><br/>
*
* Please note: The annotated variable has to be <b>public</b>!
*
* @author Ralf Biedert
* @see PluginManager
*
*/
@Target(value = { ElementType.FIELD, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectPlugin {
/**
* All the capabilities the plugins must have in order to be instanciated
*
* @return Number of classes that the plugin explicitly depends on.
*/
String[] requiredCapabilities() default {};
/**
* If set to true, the PluginManager may instanciate the plugin anyway, even if the
* other plugin is not present yet.
*
* @return .
*/
boolean isOptional() default false;
}
|
Java
|
/**
* Annotations related to injecting variables.
*
* @since 1.0
*/
package net.xeoh.plugins.base.annotations.injections;
|
Java
|
/*
* Version.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.meta;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.PluginInformation;
/**
* Version of the given plugin. For example, to specify that a given
* plugin is version 1.3.2, write:<br/><br/>
*
* <code>
* @Version(version = 10302)<br/>
* @PluginImplementation<br/>
* public class ServiceImpl implements Service { ... }
* </code><br/><br/>
*
* This information can be queried using the {@link PluginInformation} plugin.
*
* @author Ralf Biedert
* @see PluginInformation.Information
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Version {
/** Major version */
public final static int UNIT_MAJOR = 10000;
/** Minor version */
public final static int UNIT_MINOR = 100;
/** Release version */
public final static int UNIT_RELEASE = 1;
/**
* Version of this plugin. For example, a version of 10000 should be read as 1.00.00
*
* @return .
*/
int version() default 1 * UNIT_MAJOR + 0 * UNIT_MINOR + 0 * UNIT_RELEASE;
}
|
Java
|
/**
* Annotations related to plugin information.
*
* @since 1.0
*/
package net.xeoh.plugins.base.annotations.meta;
|
Java
|
/*
* Author.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.meta;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.Option;
/**
* Specifies the given method does accept and evaluate a given
* parameter.<br/><br/>
*
* Work in progress, annotation will change! Also, it is not being
* evaluated at the moment.
*
*
* @author Ralf Biedert
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RecognizesOption {
/**
* Options understood
*
* @return .
*/
Class<? extends Option> option();
}
|
Java
|
/*
* Version.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.meta;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Marker interface to signal that JSPF may hot swap the component behind the scenes
* without causing trouble to existing components.<br/><br/>
*
* Not functional right now!<br/><br/>
*
* TODO: Does it make really sense / do we *really* want such a functionality? It
* complicates many things and is only relevant to a small number of projects (which
* are likely better off with OSGi and the like)
*
* @author Ralf Biedert
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Stateless {
//
}
|
Java
|
/*
* Author.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations.meta;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.PluginInformation;
/**
* Specifies an author of the given plugin. For example, to specify that a given
* plugin was written by John Doe, write:<br/><br/>
*
* <code>
* @Author(name = "John Doe")<br/>
* @PluginImplementation<br/>
* public class ServiceImpl implements Service { ... }
* </code><br/><br/>
*
* This information can be queried using the {@link PluginInformation} plugin.
*
* @author Ralf Biedert
* @see PluginInformation.Information
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Author {
/**
* Author of this plugin.
*
* @return .
*/
String name() default "Unknown Author";
}
|
Java
|
/*
* PluginInstance.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.xeoh.plugins.base.Plugin;
/**
* This annotation can be used to mark plugin instances which should be initialized at
* runtime. If you don't annotate your plugin with this annotation, nothing will happen.
* For example, to specify that a specific class should be treated as a plugin you would
* write:<br/><br/>
*
* <code>
* @PluginImplementation<br/>
* public class ServiceImpl implements Service { ... }
* </code><br/><br/>
*
* In this case, <code>Service</code> has to extend {@link Plugin}.
*
* @author Ralf Biedert
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface PluginImplementation {
//
}
|
Java
|
package net.xeoh.plugins.base.diagnosis.channels.tracing;
/*
* ClassPathTracer.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
import java.io.Serializable;
import java.util.Map;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
/**
* Traces general messages related to class path issues.
*
* @author Ralf Biedert
*/
public class ClassPathTracer extends DiagnosisChannelID<String> {
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.DiagnosisChannelID#toUserRepresentation(java.io.Serializable, java.util.Map)
*/
@Override
public String toUserRepresentation(String t, Map<String, Serializable> args) {
// TODO Auto-generated method stub
return super.toUserRepresentation(t, args);
}
}
|
Java
|
/*
* AddPlugins.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.diagnosis.channels.tracing;
import java.io.Serializable;
import java.util.Map;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
/**
* Traces general messages for the Spawner.
*
* @author Ralf Biedert
*/
public class SpawnerTracer extends DiagnosisChannelID<String> {
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.DiagnosisChannelID#toUserRepresentation(java.io.Serializable, java.util.Map)
*/
@Override
public String toUserRepresentation(String t, Map<String, Serializable> args) {
// TODO Auto-generated method stub
return super.toUserRepresentation(t, args);
}
}
|
Java
|
/*
* AddPlugins.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.diagnosis.channels.tracing;
import java.io.Serializable;
import java.util.Map;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
/**
* Traces general messages for the plugin manager.
*
* @author Ralf Biedert
*/
public class PluginManagerTracer extends DiagnosisChannelID<String> {
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.DiagnosisChannelID#toUserRepresentation(java.io.Serializable, java.util.Map)
*/
@Override
public String toUserRepresentation(String t, Map<String, Serializable> args) {
// TODO Auto-generated method stub
return super.toUserRepresentation(t, args);
}
}
|
Java
|
/*
* URIUtil.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.util.uri;
import java.net.URI;
/**
* Returns an URI for something.
*
* @author Ralf Biedert
*/
public abstract class URIUtil {
/**
* The URI.
*
* @return The URI.
*/
public abstract URI toURI();
}
|
Java
|
/**
* Utilities for URIs.
*
* @since 1.0
*/
package net.xeoh.plugins.base.util.uri;
|
Java
|
/*
* ClassURI.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.util.uri;
import java.net.URI;
import java.net.URISyntaxException;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginManager;
/**
* Convenience method to load plugins from the classpath
*
* @author Ralf Biedert
* @see PluginManager
*/
public class ClassURI extends URIUtil {
/** Means we should add all plugins we have in our classpath */
public static final URI CLASSPATH = URI.create("classpath://*");
/**
* Specifies a pattern to add from the current classpath.
*
* @param pattern For example net.xeoh.myplugins.**
*
* @return The generated pattern.
*/
public static final URI CLASSPATH(String pattern) {
return URI.create("classpath://" + pattern);
}
/**
* Specifies that the given plugin should be added.
*
* @param clazz The plugin to add
* @return The generated URI pattern for the plugin.
*/
public static final URI PLUGIN(Class<? extends Plugin> clazz) {
return new ClassURI(clazz).toURI();
}
/** The class we wrapped */
private final Class<? extends Plugin> clazz;
/**
* Construct a new class URI for the given class.
*
* @param clazz The class to wrap.
*/
public ClassURI(Class<? extends Plugin> clazz) {
if (clazz.isInterface())
throw new IllegalArgumentException("The paramter must be a concrete plugin class, not a plugin interface.");
this.clazz = clazz;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.util.uri.URIUtil#toURI()
*/
@Override
public URI toURI() {
try {
return new URI("classpath://" + this.clazz.getCanonicalName());
} catch (URISyntaxException e) {
e.printStackTrace();
}
return null;
}
}
|
Java
|
/*
* PluginUtil.java
*
* Copyright (c) 2010, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import net.xeoh.plugins.base.Plugin;
/**
* A set of inspection methods for an existing plugin. Should only be required
* and used internally.
*
* @author Ralf Biedert
*/
public class PluginUtil extends VanillaPluginUtil<Plugin> {
/**
* The plugin to wrap.
*
* @param plugin
*/
public PluginUtil(Plugin plugin) {
super(plugin);
}
/**
* Lists all primary interfaces.
*
* @return A list of primary interfaces.>
*/
@SuppressWarnings({ "unchecked" })
public Collection<Class<? extends Plugin>> getPrimaryInterfaces() {
final Collection<Class<? extends Plugin>> rval = getPluginInterfaces();
List<Class<?>> candidates = new ArrayList<Class<?>>();
// Filter all redundant interfaces
int lastSize = 0;
do {
lastSize = rval.size();
// Create a copy of all our plugins
candidates = new ArrayList<Class<?>>(rval);
rval.clear();
// For every plugin ...
for (Class<?> class2 : candidates) {
// ... compare it with every other ...
boolean hasSuper = false;
for (Class<?> class3 : candidates) {
// ... and see if it can be assigned from another one that is not the same, if that
// is the case, it's useless, if not, we keep it.
if (class2.isAssignableFrom(class3) && class2 != class3) {
hasSuper = true;
}
}
if (!hasSuper && !rval.contains(class2))
rval.add((Class<? extends Plugin>) class2);
}
} while (lastSize != rval.size());
return rval;
}
/**
* Lists all toplevel plugin interfaces
*
* @return The list of all plugin interfaces.
*/
@SuppressWarnings({ "unchecked" })
public Collection<Class<? extends Plugin>> getPluginInterfaces() {
final Collection<Class<? extends Plugin>> rval = new ArrayList<Class<? extends Plugin>>();
List<Class<?>> candidates = new ArrayList<Class<?>>();
Class<?> current = this.object.getClass();
// Check the plugin class and all its parents what interfaces they contain
while (current != null && !Object.class.equals(current)) {
final List<Class<?>> c = Arrays.asList(current.getInterfaces());
for (Class<?> class1 : c) {
if (candidates.contains(class1)) continue;
candidates.add(class1);
}
current = current.getSuperclass();
}
// Filter first round (only plugin interfaces should be left)
for (Class<?> class1 : candidates) {
if (!Plugin.class.isAssignableFrom(class1)) continue;
rval.add((Class<? extends Plugin>) class1);
}
return rval;
}
/**
* Lists all plugin interfaces.
*
* @return Lists all primary interfaces.
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public Collection<Class<? extends Plugin>> getAllPluginInterfaces() {
final Collection<Class<? extends Plugin>> pluginInterfaces = getPluginInterfaces();
final Collection<Class<? extends Plugin>> rval = new ArrayList<Class<? extends Plugin>>();
final ArrayList<Class<? extends Plugin>> x = new ArrayList<Class<? extends Plugin>>(pluginInterfaces);
// As long as there are new classes (or ones we havent seen yet)
while (x.size() > 0) {
Class c = x.get(0);
x.remove(0);
// And walk up that class.
if (!rval.contains(c)) {
rval.add(c);
}
// Get all super interfaces
Class[] interfaces = c.getInterfaces();
for (Class class1 : interfaces) {
if (x.contains(class1)) continue;
x.add(class1);
}
}
return rval;
}
}
|
Java
|
/**
* Some utilities and wrappers for other objects / interfaces.
*
* @since 1.0
*/
package net.xeoh.plugins.base.util;
|
Java
|
/*
* JSPFProperties.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.util;
import java.util.Properties;
import net.xeoh.plugins.base.PluginConfiguration;
import net.xeoh.plugins.base.impl.PluginManagerFactory;
/**
* Can be used to set properties more easily. Pass this object to the {@link PluginManagerFactory}'s
* <code>createPluginManager()</code> method to set initial properties.<br/><br/>
*
* A good overview on how properties can be used is in the {@link PluginConfiguration}'s documentation.
*
* @author Ralf Biedert
*/
public class JSPFProperties extends Properties {
/** */
private static final long serialVersionUID = -4275521676384493982L;
/**
* Sets a property using a class as prefix. For example, if
* <code>GeoService</code> is in the package <code>com.company.plugins.geoservice</code>
* the following call:<br/><br/>
* <code>
* setProperty(GeoService.class, "remote.url", "http://geo.ip/q?");
* </code><br/><br/>
* would set the configuration key <code>com.company.plugins.geoservice.GeoService.remote.url</code>
* to the value <code>http://geo.ip/q?</code>.
*
* @param root Root class to set an option for.
* @param subkey The subkey to set.
* @param value The value to set.
*/
public void setProperty(final Class<?> root, final String subkey, final String value) {
setProperty(getKey(root, subkey), value);
}
/**
* Assembles a key, only used internally.
*
* @param root Root class.
* @param subkey Subkey to assemble.
* @return The assembled key.
*/
public static String getKey(final Class<?> root, final String subkey) {
String prefix = "";
if (root != null) {
prefix = root.getName() + ".";
}
return prefix + subkey;
}
}
|
Java
|
/*
* OptionUtils.java
*
* Copyright (c) 2009, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.util;
import java.util.ArrayList;
import java.util.Collection;
import net.jcores.jre.utils.VanillaUtil;
import net.xeoh.plugins.base.Option;
/**
* Handles options within plugin methods. Likely to be replaced by
* <a href="http://jcores.net">jCores</a>.
*
* @author Ralf Biedert
*
* @param <T> Type paramter.
*/
public class OptionUtils<T extends Option> extends VanillaUtil<T[]> {
/**
* Creates a new options array.
*
* @param options
*/
public OptionUtils(T... options) {
super(options);
}
/**
* Check if the selection option is available
*
* @param option
* @return .
*/
public boolean contains(Class<? extends T> option) {
for (T t : this.object) {
if (t == null) continue;
if (option.isAssignableFrom(t.getClass())) return true;
}
return false;
}
/**
* Check if the selection option is available
*
* @param option
* @return .
*/
public boolean containsAny(Class<? extends T>... option) {
for (T t : this.object) {
if (t == null) continue;
for (Class<? extends T> cls : option) {
if (cls.isAssignableFrom(t.getClass())) return true;
}
}
return false;
}
/**
* Returns the selection option
*
* @param <O>
*
* @param option
* @param deflt
* @return .
*/
@SuppressWarnings("unchecked")
public <O extends T> O get(Class<? extends O> option, O... deflt) {
for (T t : this.object) {
if (t == null) continue;
if (option.isAssignableFrom(t.getClass())) return (O) t;
}
// return the default if there is any
if (deflt.length > 0) return deflt[0];
return null;
}
/**
* Returns the selection option
*
* @param <O>
*
* @param option
* @return .
*/
@SuppressWarnings("unchecked")
public <O extends T> Collection<O> getAll(Class<? extends O> option) {
final Collection<O> rval = new ArrayList<O>();
for (T t : this.object) {
if (t == null) continue;
if (option.isAssignableFrom(t.getClass())) {
rval.add((O) t);
}
}
return rval;
}
/**
* Returns the selection option
*
* @param <O>
*
* @param option
* @param handler
*
*/
@SuppressWarnings("unchecked")
public <O extends T> void handle(Class<? extends O> option, OptionHandler<O> handler) {
for (T t : this.object) {
if (t == null) continue;
if (option.isAssignableFrom(t.getClass())) {
handler.handle((O) t);
}
}
}
}
|
Java
|
package net.xeoh.plugins.base.util;
import net.xeoh.plugins.base.Option;
/**
* Handles options. Only used internally.
*
* @author Ralf Biedert
*
* @param <T> Type parameter.
*/
public interface OptionHandler<T extends Option> {
/**
* Called with e
*
* @param option
*/
public void handle(T option);
}
|
Java
|
/*
* BusImpl.java
*
* Copyright (c) 2008, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.util;
import java.util.logging.Logger;
import net.xeoh.plugins.base.PluginConfiguration;
/**
* Helper functions for PluginConfiguration interface. The util uses the embedded
* interface to provide more convenience features.
*
* @author Ralf Biedert
* @see PluginConfiguration
*/
public class PluginConfigurationUtil extends VanillaPluginUtil<PluginConfiguration> implements PluginConfiguration {
/**
* Creates a new util for the given interface.
*
* @param pc The interface to create the utils for.
*/
public PluginConfigurationUtil(PluginConfiguration pc) {
super(pc);
}
final Logger logger = Logger.getLogger(this.getClass().getName());
/**
* Returns the requested key as an integer.
*
* @param root Root class to request.
* @param subkey Subkey to return.
* @param defautvalue Default value to return if nothing was found.
* @return The requested key, or the default value if the key was not found, or 0 if neither was present.
*/
@SuppressWarnings("boxing")
public int getInt(final Class<?> root, final String subkey,
final Integer... defautvalue) {
final String configuration = this.object.getConfiguration(root, subkey);
if (configuration == null) {
if (defautvalue.length >= 1) return defautvalue[0];
this.logger.warning("Returning default 0, but nothing was specified. Your application might behave strangely. Subkey was " + subkey);
return 0;
}
return Integer.parseInt(configuration);
}
/**
* Returns the reqeusted key or a default string.
*
* @param root Root class to request.
* @param subkey Subkey to return.
* @param defautvalue Default value to return if nothing was found.
* @return The requested key, or the default value if the key was not found, or "" if neither was present.
*/
public String getString(final Class<?> root, final String subkey,
final String... defautvalue) {
final String configuration = this.object.getConfiguration(root, subkey);
if (configuration == null) {
if (defautvalue.length >= 1) return defautvalue[0];
this.logger.warning("Returning default '', but nothing was specified. Your application might behave strangely. Subkey was " + subkey);
return "";
}
return configuration;
}
/**
* Returns the reqeusted key or a default float.
*
* @param root Root class to request.
* @param subkey Subkey to return.
* @param defautvalue Default value to return if nothing was found.
* @return The requested key, or the default value if the key was not found, or 0.0 if neither was present.
*/
@SuppressWarnings("boxing")
public float getFloat(final Class<?> root, final String subkey,
final Float... defautvalue) {
final String configuration = this.object.getConfiguration(root, subkey);
if (configuration == null) {
if (defautvalue.length >= 1) return defautvalue[0];
this.logger.warning("Returning default '', but nothing was specified. Your application might behave strangely. Subkey was " + subkey);
return 0;
}
return Float.parseFloat(configuration);
}
/**
* Returns the reqeusted key or a default boolean.
*
* @param root Root class to request.
* @param subkey Subkey to return.
* @param defautvalue Default value to return if nothing was found.
* @return The requested key, or the default value if the key was not found, or <code>false</code> if neither was
* present.
*/
@SuppressWarnings("boxing")
public boolean getBoolean(final Class<?> root, final String subkey,
final Boolean... defautvalue) {
final String configuration = this.object.getConfiguration(root, subkey);
if (configuration == null) {
if (defautvalue.length >= 1) return defautvalue[0];
this.logger.warning("Returning default '', but nothing was specified. Your application might behave strangely. Subkey was " + subkey);
return false;
}
return Boolean.parseBoolean(configuration);
}
/**
* Returns the reqeusted key or a default double.
*
* @param root Root class to request.
* @param subkey Subkey to return.
* @param defautvalue Default value to return if nothing was found.
* @return The requested key, or the default value if the key was not found, or 0.0 if neither was present.
*/
@SuppressWarnings("boxing")
public double getDouble(final Class<?> root, final String subkey,
final Double... defautvalue) {
final String configuration = this.object.getConfiguration(root, subkey);
if (configuration == null) {
if (defautvalue.length >= 1) return defautvalue[0];
this.logger.warning("Returning default '', but nothing was specified. Your application might behave strangely. Subkey was " + subkey);
return 0;
}
return Double.parseDouble(configuration);
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.PluginConfiguration#getConfiguration(java.lang.Class, java.lang.String)
*/
@Override
public String getConfiguration(Class<?> root, String subkey) {
return this.object.getConfiguration(root, subkey);
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.base.PluginConfiguration#setConfiguration(java.lang.Class, java.lang.String,
* java.lang.String)
*/
@Override
public void setConfiguration(Class<?> root, String subkey, String value) {
this.object.setConfiguration(root, subkey, value);
}
}
|
Java
|
/*
* BusImpl.java
*
* Copyright (c) 2008, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.util;
import static net.jcores.jre.CoreKeeper.$;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginManager;
import net.xeoh.plugins.base.options.AddPluginsFromOption;
import net.xeoh.plugins.base.options.GetPluginOption;
import net.xeoh.plugins.base.options.getplugin.OptionCapabilities;
import net.xeoh.plugins.base.options.getplugin.OptionPluginSelector;
import net.xeoh.plugins.base.options.getplugin.PluginSelector;
/**
* Helper functions for {@link PluginManager} interface. The util uses the embedded
* interface to provide more convenience features.
*
* @author Ralf Biedert
* @see PluginManager
* @since 1.0
*/
public class PluginManagerUtil extends VanillaPluginUtil<PluginManager> implements PluginManager {
/**
* Creates a new util for the given interface.
*
* @param pm The interface to create the utils for.
*/
public PluginManagerUtil(PluginManager pm) {
super(pm);
}
/**
* Returns all plugins implementing the given interface, not just the first,
* 'random' match. Use this method if you want to list the registed plugins (or
* select from them on your own). For example, to get all plugins implementing the
* <code>Chat</code> interface, write:<br/><br/>
*
* <code>
* getPlugins(Chat.class);
* </code>
*
* @param <P> Type of the requested plugin.
* @param plugin The interface to request.
* @see OptionPluginSelector
* @return A collection of all plugins implementing the given interface.
*/
public <P extends Plugin> Collection<P> getPlugins(final Class<P> plugin) {
return getPlugins(plugin, new PluginSelector<P>() {
public boolean selectPlugin(final P p) {
return true;
}
});
}
/**
* Returns all plugins. Use this method if you want to list all registed plugins.
*
* @see OptionPluginSelector
* @return A collection of all plugins implementing the given interface.
*/
public Collection<Plugin> getPlugins() {
return getPlugins(Plugin.class);
}
/**
* Returns all interfaces implementing the given interface AND satisfying the
* given plugin selector. Use this method if you want to list some of the
* registed plugins (or select from them on your own).
*
* @param <P> Type of the requested plugin.
* @param plugin The interface to request.
* @param selector The selector will be called for each available plugin. When
* it returns <code>true</code> the plugin will be added to the return value.
* @see OptionPluginSelector
* @return A collection of plugins for which the collector return true.
*/
public <P extends Plugin> Collection<P> getPlugins(final Class<P> plugin,
final PluginSelector<P> selector) {
final Collection<P> allPlugins = new ArrayList<P>();
this.object.getPlugin(plugin, new OptionPluginSelector<P>(new PluginSelector<P>() {
public boolean selectPlugin(final P p) {
if (selector.selectPlugin(p)) {
allPlugins.add(p);
}
return false;
}
}));
return allPlugins;
}
/**
* Returns the next best plugin implementing the requested interface and fulfilling
* all capabilities specified.
*
* @since 1.0.3
* @param <P> Type of the requested plugin.
* @param plugin The interface to request.
* @param cap1 The first capability to consider.
* @param caps The other, optional, capabilities to consider.
* @see OptionCapabilities
* @return A collection of plugins for which the collector return true.
*/
public <P extends Plugin> P getPlugin(Class<P> plugin, String cap1, String... caps) {
return this.object.getPlugin(plugin, new OptionCapabilities($(cap1).add(caps).unsafearray()));
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.PluginManager#addPluginsFrom(java.net.URI, net.xeoh.plugins.base.options.AddPluginsFromOption[])
*/
@Override
public PluginManagerUtil addPluginsFrom(URI url, AddPluginsFromOption... options) {
this.object.addPluginsFrom(url, options);
return this;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.PluginManager#getPlugin(java.lang.Class, net.xeoh.plugins.base.options.GetPluginOption[])
*/
@Override
public <P extends Plugin> P getPlugin(Class<P> plugin, GetPluginOption... options) {
return this.object.getPlugin(plugin, options);
}
/* (non-Javadoc)
* @see net.xeoh.plugins.base.PluginManager#shutdown()
*/
@Override
public void shutdown() {
this.object.shutdown();
}
}
|
Java
|
/*
* VanillaPluginUtil.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base.util;
import net.jcores.jre.utils.VanillaUtil;
import net.xeoh.plugins.base.Plugin;
/**
* Vanilla wrapper for plugins.
*
* @author Ralf Biedert
* @param <T>
*/
public abstract class VanillaPluginUtil<T extends Plugin> extends VanillaUtil<T> {
public VanillaPluginUtil(T object) {
super(object);
}
}
|
Java
|
/*
* PluginConfiguration.java
*
* Copyright (c) 2007, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.base;
import net.xeoh.plugins.base.annotations.configuration.ConfigurationFile;
import net.xeoh.plugins.base.impl.PluginManagerFactory;
import net.xeoh.plugins.base.util.JSPFProperties;
import net.xeoh.plugins.base.util.PluginConfigurationUtil;
/**
* Gives you access to configuration items of plugins. In general there are three ways
* of adding configuration:
* <ol>
* <li>by calling <code>setPreferences()</code></li>
* <li>by providing a {@link JSPFProperties} object to the {@link PluginManagerFactory}</li>
* <li>by using the @{@link ConfigurationFile} annotation.<br/><br/></li>
* </ol>
*
* @author Ralf Biedert
* @see PluginConfigurationUtil
*/
public interface PluginConfiguration extends Plugin {
/**
* Gets a configuration key. Root may be added for convenience and will
* prefix the subkey with its fully qualified name. Thus, if there is an interface
* <code>GeoService</code> in the package <code>com.company.plugins.geoservice</code>
* the following call:<br/><br/>
* <code>
* getConfiguration(GeoService.class, "remote.url")
* </code><br/><br/>
* would try to return the configuration key <code>com.company.plugins.geoservice.GeoService.remote.url</code>.
*
* @param root May also be null.
* @param subkey If used in conjunction with root it should not be prefixed
* with a dot (".")
*
* @return The corresponding value or null if nothing was found.
*/
public String getConfiguration(Class<?> root, String subkey);
/**
* Set the key for a value. Root may be added for convenience and will
* prefix the subkey with its FQN. Usually the configuration is added
* by providing JSPFProperties object to the {@link PluginManagerFactory}
*
* @param root May also be null.
* @param subkey If used in conjunction with root it should not be prefixed
* with a dot (".")
* @param value The value to set.
*/
public void setConfiguration(Class<?> root, String subkey, String value);
}
|
Java
|
/**
* Top level package, nothing to see here.
*
* @since 1.0
*/
package net.xeoh.plugins;
|
Java
|
/*
* DiagnosisChannel.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local;
import net.xeoh.plugins.diagnosis.local.options.StatusOption;
/**
* @author Ralf Biedert
* @since 1.1
* @param <T>
*/
public interface DiagnosisChannel<T> {
/**
* @param value
* @param options
*/
public void status(T value, StatusOption... options);
}
|
Java
|
/*
* DiagnosisChannel.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local;
import java.io.Serializable;
import java.util.Map;
/**
* @author Ralf Biedert
* @since 1.1
* @param <T>
*/
public abstract class DiagnosisChannelID<T extends Serializable> {
// Note: The ChannelID itself does not have to be Serializable, as we never write any
// object. We only instantiate it when we want to use some of its methods.
/**
* Returns an end user readable string. For example, if the channel reported Floats
* representing temperature, you could convert a value of 30.7 to a string of
* "30.7°C".
*
* @param t The value to convert.
* @param args The optional arguments passed as OptionInfo().
* @return The converted value.
*/
public String toUserRepresentation(final T t, final Map<String, Serializable> args) {
if (t == null) return "null";
return t.toString();
}
}
|
Java
|
/*
* DiagnosisListener.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local;
import java.io.Serializable;
/**
* Listens to diagnosis status change messages.
*
* @author Ralf Biedert
*
* @param <T> Type of the status.
*/
public interface DiagnosisMonitor<T extends Serializable> {
public void onStatusChange(DiagnosisStatus<T> status);
}
|
Java
|
/*
* StatusOption.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.options;
import net.xeoh.plugins.base.Option;
/**
* @author Ralf Biedert
* @since 1.1
*/
public interface StatusOption extends Option {
}
|
Java
|
/*
* RegisterConditionOption.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.options;
import net.xeoh.plugins.base.Option;
/**
* @author Ralf Biedert
* @since 1.1
*/
public interface RegisterConditionOption extends Option {
}
|
Java
|
/*
* ChannelOption.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.options;
import net.xeoh.plugins.base.Option;
public interface ChannelOption extends Option {
}
|
Java
|
/*
* OptionAtomic.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.options.status;
import net.xeoh.plugins.diagnosis.local.options.StatusOption;
public class OptionComment implements StatusOption {
/** */
private static final long serialVersionUID = 1294219941602892411L;
/**
* @param comment
*/
public OptionComment(String comment) {
}
}
|
Java
|
/*
* OptionAtomic.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.options.status;
import net.xeoh.plugins.diagnosis.local.options.StatusOption;
public class OptionAtomic implements StatusOption {
/** */
private static final long serialVersionUID = 1294219941602892411L;
}
|
Java
|
/*
* OptionInfo.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.options.status;
import java.io.Serializable;
import net.xeoh.plugins.diagnosis.local.options.StatusOption;
public class OptionInfo implements StatusOption {
/** */
private static final long serialVersionUID = 5703900703387071451L;
/** */
private final Serializable value;
/** */
private final String key;
/**
* @param key
* @param value
*/
public OptionInfo(String key, Serializable value) {
this.key = key;
this.value = value;
}
/**
* @return the value
*/
public Serializable getValue() {
return this.value;
}
/**
* @return the key
*/
public String getKey() {
return this.key;
}
}
|
Java
|
/*
* StatusChange.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local;
import java.io.Serializable;
import net.xeoh.plugins.diagnosis.local.options.status.OptionInfo;
/**
* Reflects a new diagnosis status on a given channel.
*
* @author Ralf Biedert
*
* @param <T>
*/
public interface DiagnosisStatus<T extends Serializable> {
/**
* Returns the channel for which some change happened.
*
* @return The channel for which something happened.
*/
public Class<? extends DiagnosisChannelID<T>> getChannel();
/**
* Returns the channel as a string. Mostly used for replay.
*
* @return String representation of the channel.
*/
public String getChannelAsString();
/**
* Returns the new value.
*
* @return The value.
*/
public T getValue();
/**
* Returns the associated info object.
*
* @return the info objects.
*/
public OptionInfo[] getInfos();
/**
* Returns the date when this status was generated.
*
* @return The date.
*/
public long getDate();
}
|
Java
|
/*
* Diagnosis.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local;
import java.io.Serializable;
import net.xeoh.plugins.base.Plugin;
import net.xeoh.plugins.base.PluginConfiguration;
import net.xeoh.plugins.base.util.JSPFProperties;
import net.xeoh.plugins.diagnosis.local.options.ChannelOption;
import net.xeoh.plugins.diagnosis.local.util.DiagnosisUtil;
/**
* Main enty point to the diagnosis. Allows your application to record diagnosis data to various channels, which
* can then be stored in a diagnosis.record for later analysis.
*
*
* The following configuration sub-keys are usually known for this class (see {@link PluginConfiguration}, keys must be set
* <em>before</em> createPluginManager() is being called, i.e., set in the {@link JSPFProperties} object!):<br/><br/>
*
* <ul>
* <li><b>recording.enabled</b> - If we should record to a file or not. If switched off, diagnosis has virtually no overhead. Specify either {true, false}.</li>
* <li><b>recording.file</b> - File to which the record should be writte (will be overwritten).</li>
* <li><b>recording.format</b> - Format to write. Should be <code>java/serialization</code> for now.</li>
* <li><b>analysis.stacktraces.enabled</b> - If true, a stack trace will also be written. Very helpful, rather slow. Specify either {true, false}.</li>
* <li><b>analysis.stacktraces.depth</b> - Depth of the stacktrace. Specify either something from 1 to 10000.</li>
* </ul><br/>
*
* @author Ralf Biedert
* @since 1.1
* @see DiagnosisUtil
*/
public interface Diagnosis extends Plugin {
/**
* Returns a given channel.
*
* @param <T>
* @param channel
* @param options
* @return .
*/
public <T extends Serializable> DiagnosisChannel<T> channel(Class<? extends DiagnosisChannelID<T>> channel,
ChannelOption... options);
/**
* Registers a listener to the diagnosis.
*
* @param <T>
* @param channel
* @param listener
*/
public <T extends Serializable> void registerMonitor(Class<? extends DiagnosisChannelID<T>> channel, DiagnosisMonitor<T> listener);
/**
* Adds a replay listener for a given file.
*
* @param file
* @param listener
*/
public void replay(String file, DiagnosisMonitor<?> listener);
}
|
Java
|
/*
* DiagnosisImpl.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.impl;
import static net.jcores.jre.CoreKeeper.$;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import net.xeoh.plugins.base.PluginConfiguration;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import net.xeoh.plugins.base.annotations.events.Shutdown;
import net.xeoh.plugins.base.util.PluginConfigurationUtil;
import net.xeoh.plugins.diagnosis.local.Diagnosis;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannel;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
import net.xeoh.plugins.diagnosis.local.DiagnosisMonitor;
import net.xeoh.plugins.diagnosis.local.DiagnosisStatus;
import net.xeoh.plugins.diagnosis.local.impl.serialization.java.Entry;
import net.xeoh.plugins.diagnosis.local.impl.serialization.java.EntryCallback;
import net.xeoh.plugins.diagnosis.local.impl.serialization.java.LogFileReader;
import net.xeoh.plugins.diagnosis.local.impl.serialization.java.LogFileWriter;
import net.xeoh.plugins.diagnosis.local.options.ChannelOption;
import net.xeoh.plugins.diagnosis.local.options.status.OptionInfo;
@PluginImplementation
public class DiagnosisImpl implements Diagnosis {
/** Stores information on a key */
class KeyEntry {
/** Locks access to this item */
final Lock entryLock = new ReentrantLock();
/** All listeners subscribed to this item */
final Collection<DiagnosisMonitor<?>> allListeners = new ArrayList<DiagnosisMonitor<?>>();
/** The current channel holder */
DiagnosisStatus<?> lastItem = null;
}
/** Manages all information regarding a key */
final Map<Class<? extends DiagnosisChannelID<?>>, KeyEntry> items = new ConcurrentHashMap<Class<? extends DiagnosisChannelID<?>>, KeyEntry>();
/** Plugin configuration (will be injected manually by the PluginManager) */
public PluginConfiguration configuration;
/** If true, the whole plugin will be disabled */
boolean isDisabled = false;
/** If true, if we should dump stack traces */
boolean useStackTraces = false;
/** If we should compress our output */
boolean compressOutput = true;
/** Depth of stack traces */
int stackTracesDepth = 1;
/** The file to which we record to */
String recordingFile = null;
/** The actual serializer we use */
volatile LogFileWriter serializer = null;
/** If recording should be enabled */
boolean recordingEnabled = false;
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.Diagnosis#channel(java.lang.Class,
* net.xeoh.plugins.diagnosis.local.options.ChannelOption[])
*/
@SuppressWarnings("unchecked")
@Override
public <T extends Serializable> DiagnosisChannel<T> channel(Class<? extends DiagnosisChannelID<T>> channel,
ChannelOption... options) {
// In case we are disabled, return a dummy
if (this.isDisabled) {
final DiagnosisChannel<?> impl = new DiagnosisChannelDummyImpl(this, channel);
return (DiagnosisChannel<T>) impl;
}
// In case this was the first call, create a serializer
synchronized (this) {
if (this.serializer == null && this.recordingEnabled) {
this.serializer = createWriter();
}
}
final DiagnosisChannel<?> impl = new DiagnosisChannelImpl(this, channel);
return (DiagnosisChannel<T>) impl;
}
/**
* Try to create a write for our logging data.
*
* @return
*/
LogFileWriter createWriter() {
// First try to return a writer with the given name
try {
return new LogFileWriter(this.recordingFile, this.compressOutput);
} catch (Exception e) {}
// First try to return a writer with some time stamp attached (in case the old one was not overwritable)
try {
return new LogFileWriter(this.recordingFile + "." + System.currentTimeMillis(), this.compressOutput);
} catch (Exception e) {}
// Now we are out of luck
return null;
}
/**
* Stores the given entry to our record file
*
* @param status
* @param entry
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public void recordEntry(DiagnosisStatus<?> status, Entry entry) {
if (this.serializer != null)
this.serializer.record(entry);
final KeyEntry keyEntry = getKeyEntry(status.getChannel());
// Now process entry
try {
keyEntry.entryLock.lock();
keyEntry.lastItem = status;
// Check if we should publish silently.
for (DiagnosisMonitor<?> listener : keyEntry.allListeners) {
try {
((DiagnosisMonitor<?>) listener).onStatusChange((DiagnosisStatus) status);
} catch (Exception e) {
e.printStackTrace();
}
}
} finally {
keyEntry.entryLock.unlock();
}
}
/** Opens all required streams */
@SuppressWarnings("boxing")
// This MUST NOT be tagged with @Init, as it will be executed manually by the PluginManager.
public void init() {
final PluginConfigurationUtil util = new PluginConfigurationUtil(this.configuration);
this.isDisabled = !util.getBoolean(Diagnosis.class, "general.enabled", true);
this.recordingEnabled = util.getBoolean(Diagnosis.class, "recording.enabled", false);
this.recordingFile = util.getString(Diagnosis.class, "recording.file", "diagnosis.record");
this.useStackTraces = util.getBoolean(Diagnosis.class, "analysis.stacktraces.enabled", false);
this.stackTracesDepth = util.getInt(Diagnosis.class, "analysis.stacktraces.depth", 1);
String mode = util.getString(Diagnosis.class, "recording.format", "java/serialization/gzip");
if ("java/serialization/gzip".equals(mode)) {
this.compressOutput = true;
}
if ("java/serialization".equals(mode)) {
this.compressOutput = false;
}
}
/** Close the log file */
@Shutdown
public void shutdown() {
// TODO
// this.serializer...()
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.Diagnosis#registerListener(java.lang.Class,
* net.xeoh.plugins.diagnosis.local.DiagnosisListener)
*/
@SuppressWarnings("unchecked")
@Override
public <T extends Serializable> void registerMonitor(Class<? extends DiagnosisChannelID<T>> channel,
DiagnosisMonitor<T> listener) {
if (channel == null || listener == null) return;
// Get the meta information for the requested id
final KeyEntry keyEntry = getKeyEntry(channel);
// Now process and add the entry
try {
keyEntry.entryLock.lock();
// If there has been a channel established, use that one
if (keyEntry.lastItem != null) {
try {
listener.onStatusChange((DiagnosisStatus<T>) keyEntry.lastItem);
} catch (Exception e) {
e.printStackTrace();
}
}
keyEntry.allListeners.add(listener);
} finally {
keyEntry.entryLock.unlock();
}
}
/**
* Returns the key entry of a given ID.
*
* @param id The ID to request
* @return The key entry.
*/
private KeyEntry getKeyEntry(Class<? extends DiagnosisChannelID<?>> id) {
KeyEntry keyEntry = null;
synchronized (this.items) {
keyEntry = this.items.get(id);
if (keyEntry == null) {
keyEntry = new KeyEntry();
this.items.put(id, keyEntry);
}
}
return keyEntry;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.Diagnosis#replay(java.lang.String,
* net.xeoh.plugins.diagnosis.local.DiagnosisMonitor)
*/
@Override
public void replay(final String file, final DiagnosisMonitor<?> listener) {
final LogFileReader reader = new LogFileReader(file);
reader.replay(new EntryCallback() {
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public void nextEntry(Entry entry) {
// Convert the entry to a status events
final List<OptionInfo> infos = new ArrayList<OptionInfo>();
for (String value : entry.additionalInfo.keySet()) {
infos.add(new OptionInfo(value, (Serializable) entry.additionalInfo.get(value)));
}
final DiagnosisStatusImpl<?> event = new DiagnosisStatusImpl(entry.channel, (Serializable) entry.value, entry.date, $(infos).array(OptionInfo.class));
listener.onStatusChange((DiagnosisStatus) event);
}
});
}
}
|
Java
|
/*
* DiagnosisStatusImpl.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.impl;
import java.io.Serializable;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
import net.xeoh.plugins.diagnosis.local.DiagnosisStatus;
import net.xeoh.plugins.diagnosis.local.options.status.OptionInfo;
/**
* @author Ralf Biedert
*
* @param <T>
*/
public class DiagnosisStatusImpl<T extends Serializable> implements DiagnosisStatus<T> {
/** */
final private Class<? extends DiagnosisChannelID<T>> channel;
/** */
final private String channelString;
/** */
final private T value;
/** */
final private long date;
/** */
final private OptionInfo[] infos;
/**
* @param channel
* @param value
* @param date
* @param infos
*/
public DiagnosisStatusImpl(Class<? extends DiagnosisChannelID<T>> channel, T value, long date, OptionInfo[] infos) {
this.channel = channel;
this.channelString = channel.getCanonicalName();
this.value = value;
this.date = date;
this.infos = infos;
}
/**
* @param channelName
* @param value
* @param date
* @param infos
*/
public DiagnosisStatusImpl(String channelName, T value, long date, OptionInfo[] infos) {
this.channel = null;
this.channelString = channelName;
this.value = value;
this.date = date;
this.infos = infos;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.DiagnosisStatus#getChannel()
*/
@Override
public Class<? extends DiagnosisChannelID<T>> getChannel() {
return this.channel;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.DiagnosisStatus#getValue()
*/
@Override
public T getValue() {
return this.value;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.DiagnosisStatus#getInfos()
*/
@Override
public OptionInfo[] getInfos() {
return this.infos;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.DiagnosisStatus#getDate()
*/
@Override
public long getDate() {
return this.date;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.DiagnosisStatus#getChannelAsString()
*/
@Override
public String getChannelAsString() {
return this.channelString;
}
}
|
Java
|
/*
* EntryCallback.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.impl.serialization.java;
public interface EntryCallback {
public void nextEntry(Entry entry);
}
|
Java
|
/*
* Entry.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.impl.serialization.java;
import java.io.IOException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
* Reflects an entry on a given channel.
*
* @author Ralf Biedert
*/
public class Entry implements Serializable {
/** */
private static final long serialVersionUID = -361673738793578516L;
/** The actual version we serialize */
private short version = 1;
/** Specifies when this entry was observed */
public long date;
/** Thread ID for which this entry was observed */
public long threadID;
/** Stack trace for this call */
public String[] stackTrace;
/** Channel this entry was observed on */
public String channel;
/** Value that was observed */
public Object value;
/** Additional information */
public Map<String, Object> additionalInfo = new HashMap<String, Object>();
/**
* We do this ourself.
*
* @param stream
* @throws IOException
*/
private void writeObject(java.io.ObjectOutputStream stream) throws IOException {
stream.writeShort(this.version);
stream.writeLong(this.date);
stream.writeLong(this.threadID);
stream.writeUnshared(this.stackTrace);
stream.writeUnshared(this.channel);
stream.writeUnshared(this.value);
stream.writeUnshared(this.additionalInfo);
}
/**
* We do this ourself.
*
* @param stream
* @throws IOException
* @throws ClassNotFoundException
*/
@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream stream) throws IOException,
ClassNotFoundException {
this.version = stream.readShort();
if (this.version != 1)
throw new ClassNotFoundException("Version mismatch, cannot handle " + this.version);
this.date = stream.readLong();
this.threadID = stream.readLong();
this.stackTrace = (String[]) stream.readUnshared();
this.channel = (String) stream.readUnshared();
this.value = stream.readUnshared();
try {
this.additionalInfo = (Map<String, Object>) stream.readUnshared();
} catch (ClassNotFoundException e) {
// FIXME: Due to a Java 'feature' we cannot prevent the CNFException to propagate upwards ... This means the object
// will be missing ...
// System.err.println("Unknown type in infos (" + e.getMessage() + "). You should run this in the orig app's classpath!");
}
}
}
|
Java
|
/*
* SerializationFile.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.impl.serialization.java;
import static net.jcores.jre.CoreKeeper.$;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.zip.GZIPOutputStream;
public class LogFileWriter {
/** Raw file to write into */
FileOutputStream fileOutputStream;
/** Object stream to use when writing */
ObjectOutputStream objectOutputStream;
/** Zip stream to compress */
GZIPOutputStream zipStream;
/** Entries to write into the file */
LinkedBlockingQueue<Entry> eventQueue = new LinkedBlockingQueue<Entry>();
/**
* Creates a new serializer
*
* @param file The file to write into.
* @param compressOutput
*/
public LogFileWriter(String file, boolean compressOutput) {
try {
$(file).file().delete();
this.fileOutputStream = new FileOutputStream($(file).get("diagnosis.fallback.record"));
if (compressOutput) {
this.zipStream = new GZIPOutputStream(this.fileOutputStream);
this.objectOutputStream = new ObjectOutputStream(this.zipStream);
} else
this.objectOutputStream = new ObjectOutputStream(this.fileOutputStream);
} catch (Exception e) {
e.printStackTrace();
return;
}
// Create recording thread
final Thread thread = new Thread(new Runnable() {
@Override
public void run() {
int flushCount = 0;
while (true) {
try {
final Entry take = LogFileWriter.this.eventQueue.take();
LogFileWriter.this.objectOutputStream.writeUnshared(take);
if (flushCount++ > 50) {
LogFileWriter.this.objectOutputStream.reset();
LogFileWriter.this.objectOutputStream.flush();
if (LogFileWriter.this.zipStream != null) {
LogFileWriter.this.zipStream.flush();
}
LogFileWriter.this.fileOutputStream.flush();
flushCount = 0;
}
}
catch (InterruptedException e) {}
catch (IOException e) {
e.printStackTrace();
}
}
}
});
thread.setName("LogFileWriter.serializer");
thread.setDaemon(true);
thread.start();
// Registers a shutdown hook to flush the queue
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
@Override
public void run() {
terminate();
}
}));
}
/** Flushes and closes the recording streams */
void terminate() {
try {
this.objectOutputStream.flush();
if (this.zipStream != null)
this.zipStream.flush();
this.fileOutputStream.flush();
// this.objectOutputStream.close();
// this.fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Records the given entry.
*
* @param entry Entry to record.
*/
public void record(Entry entry) {
this.eventQueue.add(entry);
}
}
|
Java
|
/*
* SerializationFile.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.impl.serialization.java;
import static net.jcores.jre.CoreKeeper.$;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.StreamCorruptedException;
public class LogFileReader {
/** */
private final String file;
/**
* Creates a new serializer
*
* @param file The file to write into.
*/
public LogFileReader(String file) {
this.file = file;
}
/**
* @param callback
*/
public void replay(EntryCallback callback) {
try {
final ObjectInputStream stream = new ObjectInputStream(new FileInputStream(this.file));
while (true) {
try {
callback.nextEntry((Entry) stream.readObject());
} catch(Exception e) {
if(e instanceof EOFException) break;
if(e instanceof StreamCorruptedException) break;
if(e instanceof ClassNotFoundException) { System.err.println("Skipping one entry due to a class not found: " + e.getMessage()); continue; }
e.printStackTrace();
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// e.printStackTrace();
System.out.println("End of File");
}
}
/**
* @param args
*/
public static void main(String[] args) {
final LogFileReader reader = new LogFileReader("diagnosis.record");
reader.replay(new EntryCallback() {
@Override
public void nextEntry(Entry entry) {
final long time = entry.date;
final String name = $(entry.channel).split("\\.").get(-1);
final Object value = entry.value;
final StringBuilder sb = new StringBuilder(100);
for (final String string : entry.additionalInfo.keySet()) {
sb.append(":" + string + "=" + entry.additionalInfo.get(string));
}
final String opts = (sb.length() > 0) ? sb.substring(1) : "";
final String output = time + "\t" + name + "\t" + value + "\t" + opts;
System.out.println(output);
}
});
}
}
|
Java
|
/*
* DiagnosisChannel.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.impl;
import static net.jcores.jre.CoreKeeper.$;
import java.io.Serializable;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannel;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
import net.xeoh.plugins.diagnosis.local.impl.serialization.java.Entry;
import net.xeoh.plugins.diagnosis.local.options.StatusOption;
import net.xeoh.plugins.diagnosis.local.options.status.OptionInfo;
public class DiagnosisChannelImpl implements DiagnosisChannel<Object> {
/** Main diagnosis */
private final DiagnosisImpl diagnosis;
/** Main channel */
private final Class<? extends DiagnosisChannelID<?>> channel;
/**
* Creates a new channel
*
* @param diagnosis
*
* @param channel
*/
public DiagnosisChannelImpl(DiagnosisImpl diagnosis,
Class<? extends DiagnosisChannelID<?>> channel) {
this.diagnosis = diagnosis;
this.channel = channel;
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.DiagnosisChannel#status(java.lang.Object)
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public void status(Object value, StatusOption... options) {
final long timestamp = System.currentTimeMillis();
final long id = Thread.currentThread().getId();
final Entry entry = new Entry();
entry.date = timestamp;
entry.threadID = id;
entry.channel = this.channel.getCanonicalName();
entry.value = value;
// Generate stack trace if requested
if (this.diagnosis.useStackTraces) {
final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
entry.stackTrace = $(stackTrace).slice(2, Math.min(this.diagnosis.stackTracesDepth, stackTrace.length - 2)).string().array(String.class);
}
// Process all option infos
final OptionInfo[] infos = $(options).cast(OptionInfo.class).array(OptionInfo.class);
for (OptionInfo oi : infos) {
entry.additionalInfo.put(oi.getKey(), oi.getValue());
}
// Create status object
final DiagnosisStatusImpl status = new DiagnosisStatusImpl((Class<? extends DiagnosisChannelID>) this.channel, (Serializable) value, timestamp, infos);
this.diagnosis.recordEntry(status, entry);
}
}
|
Java
|
/*
* DiagnosisChannel.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.impl;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannel;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
import net.xeoh.plugins.diagnosis.local.options.StatusOption;
public class DiagnosisChannelDummyImpl implements DiagnosisChannel<Object> {
/**
* @param diagnosis
* @param channel
*/
public DiagnosisChannelDummyImpl(DiagnosisImpl diagnosis,
Class<? extends DiagnosisChannelID<?>> channel) {
//
}
/*
* (non-Javadoc)
*
* @see net.xeoh.plugins.diagnosis.local.DiagnosisChannel#status(java.lang.Object)
*/
@Override
public void status(Object value, StatusOption... options) {
//
}
}
|
Java
|
/*
* DiagnosisChannelUtil.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.util;
import static net.jcores.jre.CoreKeeper.$;
import java.io.Serializable;
import net.jcores.jre.interfaces.functions.Fn;
import net.jcores.jre.utils.VanillaUtil;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannel;
import net.xeoh.plugins.diagnosis.local.options.StatusOption;
import net.xeoh.plugins.diagnosis.local.options.status.OptionInfo;
/**
* Wraps a {@link DiagnosisChannel} and provides helper functions.
*
* @author Ralf Biedert
*
* @param <T> The type of the diagnosis object.
*/
public class DiagnosisChannelUtil<T> extends VanillaUtil<DiagnosisChannel<T>> implements DiagnosisChannel<T> {
/**
* Creates a new util with the given channel.
*
* @param object
*/
public DiagnosisChannelUtil(DiagnosisChannel<T> object) {
super(object);
}
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.DiagnosisChannel#status(java.lang.Object, net.xeoh.plugins.diagnosis.local.options.StatusOption[])
*/
@Override
public void status(T value, StatusOption... options) {
this.object.status(value, options);
}
/**
* Logs the value and creates an {@link OptionInfo} for each
* two info parameters (key, value).
*
* @param value The value to log.
* @param infos The info parameters.
*/
public void status(T value, Serializable... infos) {
if(infos == null) {
this.object.status(value);
return;
}
// Convert the options we have
final OptionInfo[] options = $(infos).forEach(new Fn<Serializable, OptionInfo>() {
@Override
public OptionInfo f(Serializable... arg0) {
return new OptionInfo(arg0[0].toString(), arg0[1]);
}
}, 2).array(OptionInfo.class);
this.object.status(value, options);
}
}
|
Java
|
/*
* DiagnosisUtil.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.util;
import java.io.Serializable;
import net.xeoh.plugins.base.util.VanillaPluginUtil;
import net.xeoh.plugins.diagnosis.local.Diagnosis;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
import net.xeoh.plugins.diagnosis.local.DiagnosisMonitor;
import net.xeoh.plugins.diagnosis.local.options.ChannelOption;
import net.xeoh.plugins.diagnosis.local.util.conditions.Condition;
/**
* Wraps a {@link Diagnosis} object and provides helper functions.
*
* @author Ralf Biedert
*/
public class DiagnosisUtil extends VanillaPluginUtil<Diagnosis> implements Diagnosis {
/**
* @param diagnosis
*/
public DiagnosisUtil(Diagnosis diagnosis) {
super(diagnosis);
}
/**
* Registers a monitor listening to many channels.
*
* @param listener
* @param all
*/
@SuppressWarnings("unchecked")
public void registerMonitors(final DiagnosisMonitor<?> listener,
final Class<?>... all) {
if (listener == null || all == null || all.length == 0) return;
// Stores all items we received so far
for (final Class<?> c : all) {
final Class<? extends DiagnosisChannelID<Serializable>> cc = (Class<? extends DiagnosisChannelID<Serializable>>) c;
this.object.registerMonitor(cc, (DiagnosisMonitor<Serializable>) listener);
}
}
/**
* Registers a condition to the enclode diagnosis.
*
* @param condition
*/
public void registerCondition(Condition condition) {
if(condition == null) return;
registerMonitors(condition, condition.getRequiredChannels());
}
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.Diagnosis#channel(java.lang.Class, net.xeoh.plugins.diagnosis.local.options.ChannelOption[])
*/
@Override
public <T extends Serializable> DiagnosisChannelUtil<T> channel(Class<? extends DiagnosisChannelID<T>> channel,
ChannelOption... options) {
return new DiagnosisChannelUtil<T>(this.object.channel(channel, options));
}
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.Diagnosis#registerMonitor(java.lang.Class, net.xeoh.plugins.diagnosis.local.DiagnosisMonitor)
*/
@Override
public <T extends Serializable> void registerMonitor(Class<? extends DiagnosisChannelID<T>> channel,
DiagnosisMonitor<T> listener) {
this.object.registerMonitor(channel, listener);
}
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.Diagnosis#replay(java.lang.String, net.xeoh.plugins.diagnosis.local.DiagnosisMonitor)
*/
@Override
public void replay(String file, DiagnosisMonitor<?> listener) {
this.object.replay(file, listener);
}
}
|
Java
|
/*
* TwoStateCondition.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.util.conditions;
import java.io.Serializable;
import java.util.Set;
import net.xeoh.plugins.diagnosis.local.DiagnosisChannelID;
import net.xeoh.plugins.diagnosis.local.DiagnosisStatus;
import net.xeoh.plugins.diagnosis.local.util.conditions.matcher.Matcher;
/**
* Reflects an abstract two-state condition, that can either be on, or off.
*
* @author Ralf Biedert
*/
public abstract class TwoStateMatcherAND extends TwoStateMatcher {
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.DiagnosisMonitor#onStatusChange(net.xeoh.plugins.diagnosis.local.DiagnosisStatus)
*/
@Override
public void onStatusChange(DiagnosisStatus<Serializable> status) {
// First, update our values
this.currentStatus.put(status.getChannel(), status.getValue());
// Next match status agains on status
Set<Class<? extends DiagnosisChannelID<?>>> keySet = this.onRequirements.keySet();
for (Class<? extends DiagnosisChannelID<?>> c : keySet) {
final Matcher requirement = this.onRequirements.get(c);
final Object is = this.currentStatus.get(c);
if(!requirement.matches(is)) {
announceState(STATE.OFF);
return;
}
}
// Match dependant conditions
for (@SuppressWarnings("unused") TwoStateCondition twoState : this.requiredConditions) {
// FIXME: Aarrgh. javac failes on the following line while eclipse doesn't ...
//if(!$(twoState.getRequiredChannels()).contains(status.getChannel())) continue;
// twoState.onStatusChange(status);
/*
if(twoState.getState() == STATE.OFF) {
announceState(STATE.OFF);
return;
}
*/
}
announceState(STATE.ON);
}
}
|
Java
|
/*
* TwoStateCondition.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.util.conditions;
/**
* Reflects an abstract two-state condition, that can either be on, or off.
*
* @author Ralf Biedert
*/
public abstract class TwoStateCondition extends Condition {
/** The state of this condition */
public static enum STATE { ON, OFF }
/** Memorize last state we had */
STATE lastState = STATE.OFF;
/**
* Announces the state in case it differs from our last announcement.
*
* @param state
*/
public void announceState(STATE state) {
if(state == this.lastState) return;
stateChanged(state);
this.lastState = state;
}
/**
* Called when the state has changed based on some matching input.
*
* @param state The new state.
*/
public abstract void stateChanged(STATE state);
/**
* Returns the current state of this condition.
*
* @return The current state.
*/
public STATE getState() {
return this.lastState;
}
}
|
Java
|
/*
* Matcher.java
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.util.conditions.matcher;
/**
* @author Ralf Biedert
*/
public abstract class Matcher {
/**
* Returns true if the matcher matches, false if not.
* @param object
* @return .
*/
public abstract boolean matches(Object object);
}
|
Java
|
/*
* Contains
*
* Copyright (c) 2011, Ralf Biedert All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the author nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package net.xeoh.plugins.diagnosis.local.util.conditions.matcher;
/**
* @author Ralf Biedert
*/
public class Contains extends Matcher {
private String string;
/**
* @param string
*/
public Contains(String string) {
this.string = string;
}
/* (non-Javadoc)
* @see net.xeoh.plugins.diagnosis.local.util.conditions.matcher.Matcher#matches(java.lang.Object)
*/
@Override
public boolean matches(Object object) {
if(object == null) return false;
if(!(object instanceof String)) return false;
String s = (String) object;
return s.contains(this.string);
}
}
|
Java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.