All Classes and Interfaces
Class
Description
An base class for managing registration and unregistration of a JMX MXBean.
Represents the base class for all plugins.
Loads resources from the given class classloader.
Loads resources from directories configured via the system property
plugin.resource.directories, which should
be a comma-delimited list of file paths that contain resources to load.Loads resources from the plugin.
An alternative resource loader for use by plugins that wish to also support loading resources outside the usual
resource loading of the particular plugin type.
Deprecated.
Listener method selector that looks for a specific marker annotation
Allows to extract the plugin keys defined by 'applications' built on top of a 'product'
This component should be overridden by the host product (if it supports the concept of 'applications')
For example: For the 'JIRA' product, we have applications such as 'JIRA Service Desk', 'JIRA Software', etc.
A Plugin loader that manages a set of bundled plugins, meaning that they can can be upgraded, but
not deleted.
URL connection from a byte array
URL stream handler of a byte array
Marks
ModuleDescriptor implementations that cannot be disabled.A class loader that delegates to a list of class loaders.
Module descriptor factory that checks multiple factories in sequence.
This utility provides a thread local stack of
ClassLoaders.This class is extremely useful for loading resources and classes in a fault tolerant manner
that works across different applications servers.
Looks on the classpath for three files named: application-provided-plugins.txt - used to list the plugin
keys of all plugins that are provided by the host application application-required-plugins.txt - used to
list the plugin keys that are considered required for the application to function correctly
application-required-modules.txt - used to list the module keys that are considered required for the application
to function correctly Note that all files in that package space with those names will be included.
Loads plugins from the classpath
The ClassModuleFactory creates a java bean for the given module class by using either the plugins container or the hostcontainer, depending
if the plugin implements
ContainerManagedPlugin.Class utility methods
Allows to check if the application (e.g.
A factory which creates a DescriptorParserFactory by composing together multiple XML descriptors
InvocationHandler for a dynamic proxy that ensures all methods are executed with the
object class's class loader as the context class loader.
Utility to run Runnable implementations in a different ClassLoader.
A dynamically loaded plugin is loaded through the plugin class loader.
Simple host container that instantiates classes directly.
Default implementation of a descriptor factory that allows filtering of
descriptor keys
Creates plugin artifacts by handling URI's that are files and looking at the file's extension
Simple, synchronous event manager that uses one or more method selectors to determine event listeners.
This implementation delegates the initiation and classloading of plugins to a
list of
PluginLoaders and records the
state of plugins in a
PluginPersistentStateStore.A default implementation that uses the
ClasspathFilePluginMetadata
plugin metadata implementation to resolve the application provided plugin metadata.Tracks enabled plugin module descriptors, focusing on fast reads
Immutable implementation of the
PluginPersistentState interface.This is used by the application this library is bundled with, it shouldn't be changed without also changing all the products it is bundled with.
Default implementation of
SafeModeManager
NB: The safe mode applies only in single node environment! The end application (e.g.Default implementation of
StoredPluginStateAccessor -- delegates to PluginPersistentStateStore.Delegating wrapper for
PluginPersistentStateStore.A class loader that delegates to another class loader.
Interface for parsing a plugin descriptor file, e.g.
A factory for creating descriptor parsers.
A plugin loader to load plugins from a directory on disk.
Scans the filesystem for changed or added plugin files and stores a map of the currently known ones.
A PluginLoader which requires plugins to be discarded after load if they are not removed.
Plugin loader that supports installed plugins at runtime
String utility methods designed for memory / cpu efficiency
A
Scanner which never finds anything.A caching decorator which caches
EnabledModuleCachingPluginAccessor.getEnabledModuleDescriptorsByClass(Class) and EnabledModuleCachingPluginAccessor.getEnabledModulesByClass(Class) on PluginAccessor interface.A
Predicate that matches enabled modules.A
Predicate that matches enabled plugins.Utilities for Java Enum classes.
Deprecated.
in 5.0 for removal in 6.0 when
ScopeManager is removed completely.A scanner that simply scans a given set of input files.
File-based implementation of a PluginInstaller which writes plugin artifact
to a specified directory.
Forwarding delegate for a
Scanner.Thrown when a plugin operation has been attempted when the plugin is in an incompatible state.
The implementation of PluginArtifact that is backed by a jar file.
Deploys version 1.0 plugins into the legacy custom classloader structure that gives each plugin its own classloader.
Determines if a method on a listener is a listener method or not
A read-only implementation of
PluginPersistentStateStore which returns a state provided on construction.A basic plugin state store that stores state in memory.
Listener method selector that makes its determination by matching the method name
A
Predicate that matches modules for which their descriptor is the given type.Assists in implementing a consistent implementation of
ModuleDescriptor.equals(Object) methods for
module descriptors based on the complete key of the descriptor.Assists in implementing
Object.hashCode() methods for module descriptors based on the hashCode
of their complete key.This exception is thrown by
module descriptors when a set of their required permissions is
not met by the plugin declaring them.Reads module information from a plugin descriptor.
This is copied from Classwords 1.1 org.codehaus.classworlds.uberjar.protocol.jar.Handler
so that an additional dependency does not need to be added to plugins.
This is copied from Classwords 1.1 org.codehaus.classworlds.uberjar.protocol.jar.JarURLConnection
so that an additional dependency does not need to be added to plugins.
Resource loader that always returns null
The equivalent of the old plugin system behaviour
Creates a plugin artifact from a URL
A class loader used to load classes and resources from a given plugin.
A simple class to read the basic elements of a plugin descriptor.
Helper class that handles the problem of enabling a set of plugins at once.
This allows the Host application to intercept a plugin exception and do something meaningful with it.
General utility functions for plugin framework.
Reads plugin information from a plugin descriptor.
A place to store plugins which can be installed and uninstalled.
Methods that are necessary for the plugin framework, however should not be exposed via public API.
A plugin predicate which matches regular expressions against plugin keys.
Handles loading and unloading plugin artifacts from a location
The JMX interface to plugin manager facilities.
Tracks enabled plugin module descriptors, focusing on fast reads.
Implement this to customize how and which descriptors are stored
Interface that represents a configuration state for plugins and plugin modules.
Builder for
PluginPersistentState instances.A wrapper object that the user implements to store the persisted state of plugins.
Contains tasks that are specific to migrating data in the product's PluginPersistentStateStore.
A ClassLoader that will loop over all enabled Plugins, attempting to load the given class (or other resource) from
the ClassLoader of each plugin in turn.
Util class for emitting counter metrics to JMX.
Optional instrumentation provider for plugin system internals.
Utility for wrapping an action triggering sending plugin events with
PluginTransactionStartEvent and
PluginTransactionEndEvent.General plugin utility methods
The default implementation of a
ModuleFactory.A module factory that is matched when its prefix is matched, and therefore, relies an a delegating module factory
that determines the prefix somehow.
Utility functions for constructing regular expressions.
Provides the keys for both plugins and modules that have
been marked as required by the host application.
Marks
ModuleDescriptor implementations that require a restart of the application to
start the plugin when installed at runtime.A type of PluginInstaller that supports reverting plugin artifacts installed during the current running.
A PluginLoader which manages plugins specified by a roster file.
A Scanner which polls a file containing a list of file names to define its content.
This is used by the application this library is bundled with, it shouldn't be changed without also changing all the products it is bundled with.
Interface for
SafeModeCommandLineArguments factory, this instantiates an instance of
SafeModeCommandLineArguments with the appropriate parametersControls what plugins are enabled when plugins are disabled from start-up using command-line options.
Safely extracts the module instance from module descriptors,
handling exceptions and disabling broken plugins as appropriate.
Monitors some hypothetical space for deployed plugins.
Plugin loader that delegates the detection of plugins to a Scanner instance.
Constructs module instances, matching the constructor with the largest number of arguments first.
Loads a single plugin from the descriptor provided, which can either be an InputStream
or a resource on the classpath.
Wrapper around an
OpTimer that may be safely used even if that
class is not present in the class loader.Augments the life-cycle of the plugin system with the ability to split
PluginSystemLifecycle.init() for two phase
startup.Stream based ZIP extractor
A wrapper to add exclusion and logging to a
PluginPersistentStateStore.Deprecated.
in 5.0 for removal in 6.0 when
ScopeManager is removed completelyWrapper around an
OpTimer that may be safely used even if that class is not present in the class loader.Instances of this class represent a module which could not be loaded, not a module
which can be unloaded.
Utility class to create UnloadableModuleDescriptor instances when there are problems
This class represents a Plugin that was not able to be loaded by the PluginManager.
Utility class to create UnloadablePlugin instances.
Utility class to create UnloadableModuleDescriptor instances when there are problems
Exception for a validation error parsing DOM4J nodes
Represents a version range.
Compares dotted version strings of varying length.
Utility methods for synchronising on asynchronous processes
The condition to determine when to stop waiting
Provides access to the descriptor information retrieved from an XML InputStream.
Creates XML descriptor parser instances.
A dynamic XML plugin that consists of the Atlassian plugin descriptor
Deploys plugins that consist of an XML descriptor file.
An XML plugin artifact that is just the atlassian-plugin.xml file
ScopeManageris removed completely