| org.apache.geronimo.kernel.config.ConfigurationManager
All known Subclasses: org.apache.geronimo.kernel.config.SimpleConfigurationManager, org.apache.geronimo.kernel.mock.MockConfigurationManager,
| ConfigurationManager | | public interface ConfigurationManager (Code) | | Encapsulates logic for dealing with configurations.
Configurations have a lifecycle with three states: installed, loaded, and
running. Installed means that the configuration is present in the server's
repository. Loaded means that the Configuration GBean (including the
configuration's ClassLoader) is running. Running means that all the GBeans
in the Configuration are running.
From a user perspective, there's not much difference between installed and
loaded if the configuration has not been started (it still shows up as not
running). However, certain operations will cause a configuration to be
loaded but not started. For example, if ModuleA depends on ModuleB, then
when ModuleA is distributed ModuleB will normally be loaded (to fire up the
ClassLoader and validate ModuleA). But ModuleB will not be started at that
point. It can be started manually or it will be started automatically when
ModuleA is started.
When a Configuration is not loaded, only its ConfigurationData is available
for inspection. It's normally not possible to inspect the GBeans in the
configuration because there's no ClassLoader that could be used to load the
classes needed by the GBeanDatas in the configuration. Once the
configuration has been loaded, it's ClassLoader is available so the
GBeanDatas can be loaded and inspected. But the GBean instances are not
instantiated and started until the configuration is started.
version:
$Rev: 620729 $ $Date: 2008-02-12 01:19:46 -0800 (Tue, 12 Feb 2008) $ |
| Method Summary | |
| ArtifactResolver | getArtifactResolver()
Gets the common ArtifactResolver in case the caller wants to use this
directly. | | Configuration | getConfiguration(Artifact configurationId)
Gets a loaded Configuration (does not see unloaded configurations). | | Artifact[] | getInstalled(Artifact query)
Given an artifact that's not fully resolved (e.g. | | Artifact[] | getLoaded(Artifact query)
Given an artifact that's not fully resolved (e.g. | | Collection<? extends Repository> | getRepositories()
| | Artifact[] | getRunning(Artifact query)
Given an artifact that's not fully resolved (e.g. | | ConfigurationStore | getStoreForConfiguration(Artifact configuration)
Gets the configuration store responsible for the specified
configuration, or null if there is none. | | ConfigurationStore[] | getStores()
| | boolean | isConfiguration(Artifact artifact)
| | boolean | isInstalled(Artifact configurationId)
Is the specified configuration installed into the server
environment? That is, does it exist in the configuration store,
regardless of whether it's loaded or running? Note that this
always returns false if the argument does not represent a
configuration (e.g. | | boolean | isLoaded(Artifact configurationId)
Is the specified configuration loaded into the kernel? Note that this
always returns false if the argument does not represent a
configuration (e.g. | | boolean | isOnline()
Online means full functionality. | | boolean | isRunning(Artifact configurationId)
Is the specified configuation running? Note that this
always returns false if the argument does not represent a
configuration (e.g. | | List | listConfigurations()
Gets a List>ConfigurationInfo< of every of every available configuation. | | List | listConfigurations(AbstractName store)
Return a list of the configurations in a specific store. | | List | listStores()
Return a list of the stores this manager knows about. | | LifecycleResults | loadConfiguration(Artifact configurationId)
Load the specified configuration (from a config store) and all
configurations it depends on into the kernel. | | LifecycleResults | loadConfiguration(ConfigurationData configurationData)
Load the specified configurationData and all configurations it depends
on (from a config store) into the kernel. | | LifecycleResults | loadConfiguration(Artifact configurationId, LifecycleMonitor monitor)
Load the specified configuration (from a config store) and all
configurations it depends on into the kernel. | | LifecycleResults | loadConfiguration(ConfigurationData configurationData, LifecycleMonitor monitor)
Load the specified configurationData and all configurations it depends
on (from a config store) into the kernel. | | LifecycleResults | reloadConfiguration(Artifact configurationId)
| | LifecycleResults | reloadConfiguration(Artifact configurationId, LifecycleMonitor monitor)
| | LifecycleResults | reloadConfiguration(Artifact configurationId, Version version)
| | LifecycleResults | reloadConfiguration(Artifact configurationId, Version version, LifecycleMonitor monitor)
| | LifecycleResults | reloadConfiguration(ConfigurationData configurationData)
| | LifecycleResults | reloadConfiguration(ConfigurationData configurationData, LifecycleMonitor monitor)
| | LifecycleResults | restartConfiguration(Artifact configurationId)
| | LifecycleResults | restartConfiguration(Artifact configurationId, LifecycleMonitor monitor)
| | void | setOnline(boolean online)
| | LinkedHashSet<Artifact> | sort(List<Artifact> ids, LifecycleMonitor monitor)
| | LifecycleResults | startConfiguration(Artifact configurationId)
Loads and starts all of the gbeans contained within the configuration.
If any of the gbeans fails to fully start, all gbeans will be unloaded
and an exception will be thrown. | | LifecycleResults | startConfiguration(Artifact configurationId, LifecycleMonitor monitor)
Loads and starts all of the gbeans contained within the configuration.
If any of the gbeans fails to fully start, all gbeans will be unloaded
and an exception will be thrown. | | LifecycleResults | stopConfiguration(Artifact configurationId)
Stop the gbeans contained within the configuration. | | LifecycleResults | stopConfiguration(Artifact configurationId, LifecycleMonitor monitor)
Stop the gbeans contained within the configuration. | | void | uninstallConfiguration(Artifact configurationId)
Unstalls the specified configuration from the server. | | LifecycleResults | unloadConfiguration(Artifact configurationId)
Stops and unloads the configuration. | | LifecycleResults | unloadConfiguration(Artifact configurationId, LifecycleMonitor monitor)
Stops and unloads the configuration. |
| getArtifactResolver | | ArtifactResolver getArtifactResolver()(Code) | | Gets the common ArtifactResolver in case the caller wants to use this
directly. It is configured for all the repositories known to this
configuration manager, etc.
|
| getConfiguration | | Configuration getConfiguration(Artifact configurationId)(Code) | | Gets a loaded Configuration (does not see unloaded configurations).
Parameters:
configurationId - the unique ID of the configuration to get, whichmust be fully resolved (isResolved() == true) the specified configuration or null if the configuration has not been loaded |
| getInstalled | | Artifact[] getInstalled(Artifact query)(Code) | | Given an artifact that's not fully resolved (e.g. some parts are
missing), check whether there are any instances installed into
the server environment. That is, are there any matches in the
configuration store, regardless of whether they're loaded or running?
Note that this always returns an empty array if the argument does not
represent a configuration (e.g. if it's for a plain JAR).
Parameters:
query - The partially-complete artifact name to check for All matching artifacts that are loaded in the server |
| getLoaded | | Artifact[] getLoaded(Artifact query)(Code) | | Given an artifact that's not fully resolved (e.g. some parts are
missing), check whether there are any instances loaded.
Note that this always returns an empty array if the argument does not
represent a configuration (e.g. if it's for a plain JAR).
Parameters:
query - The partially-complete artifact name to check for All matching artifacts that are loaded in the server |
| getRunning | | Artifact[] getRunning(Artifact query)(Code) | | Given an artifact that's not fully resolved (e.g. some parts are
missing), check whether there are any instances running.
Note that this always returns an empty array if the argument does not
represent a configuration (e.g. if it's for a plain JAR).
Parameters:
query - The partially-complete artifact name to check for All matching artifacts that are loaded in the server |
| getStoreForConfiguration | | ConfigurationStore getStoreForConfiguration(Artifact configuration)(Code) | | Gets the configuration store responsible for the specified
configuration, or null if there is none. The configuration need not be
loaded or running; this just checks which store holds the data for it.
Parameters:
configuration - The unique ID for the configuration to check for,which must be fully resolved (isResolved() == true) The ConfigurationStore for this configuration, or null if theconfiguration was not found in any configuration store. |
| isConfiguration | | boolean isConfiguration(Artifact artifact)(Code) | | Is the specified artifact a configuration?
Parameters:
artifact - the ID of the artifact to check, which must be fullyresolved (isResolved() == true) true if the artifact is a configuration available in theserver (regardless of whether it has been loaded/started) |
| isInstalled | | boolean isInstalled(Artifact configurationId)(Code) | | Is the specified configuration installed into the server
environment? That is, does it exist in the configuration store,
regardless of whether it's loaded or running? Note that this
always returns false if the argument does not represent a
configuration (e.g. if it's for a plain JAR).
Parameters:
configurationId - the configuration identifier, which must befully resolved (isResolved() == true) true if the configuration has been loaded; false otherwise |
| isLoaded | | boolean isLoaded(Artifact configurationId)(Code) | | Is the specified configuration loaded into the kernel? Note that this
always returns false if the argument does not represent a
configuration (e.g. if it's for a plain JAR).
Parameters:
configurationId - the configuration identifier, which must befully resolved (isResolved() == true) true if the configuration has been loaded; false otherwise |
| isOnline | | boolean isOnline()(Code) | | Online means full functionality. Offline typically means that configurations will never be started,
although they may be marked in the persistent configuration list.
online status of ConfigurationManager |
| isRunning | | boolean isRunning(Artifact configurationId)(Code) | | Is the specified configuation running? Note that this
always returns false if the argument does not represent a
configuration (e.g. if it's for a plain JAR).
Parameters:
configurationId - the configuration identifier, which must befully resolved (isResolved() == true) true if the configuration is running, false otherwise |
| listConfigurations | | List listConfigurations()(Code) | | Gets a List>ConfigurationInfo< of every of every available configuation.
This includes all configurations installed, regardless of whether they are
currently loaded or running.
|
| listConfigurations | | List listConfigurations(AbstractName store) throws NoSuchStoreException(Code) | | Return a list of the configurations in a specific store.
Parameters:
store - the store to list a List>ConfigurationInfo< of all the configurations in the store
throws:
NoSuchStoreException - if the store could not be located |
| listStores | | List listStores()(Code) | | Return a list of the stores this manager knows about.
a List>AbstractName< of the stores this manager controls |
| loadConfiguration | | LifecycleResults loadConfiguration(Artifact configurationId) throws NoSuchConfigException, LifecycleException(Code) | | Load the specified configuration (from a config store) and all
configurations it depends on into the kernel. This causes the
configuration gbean to be loaded and started, but does not load any of
the gbeans contained within the configuration.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true) the results of the operation
throws:
NoSuchConfigException - if no configuration with the given id exists in the configuration stores
throws:
LifecycleException - if there is a problem loading the configuration |
| loadConfiguration | | LifecycleResults loadConfiguration(ConfigurationData configurationData) throws NoSuchConfigException, LifecycleException(Code) | | Load the specified configurationData and all configurations it depends
on (from a config store) into the kernel. This causes the configuration
gbean to be loaded and started, but does not load any of the gbeans
contained within the configuration.
Parameters:
configurationData - the configuration to load the results of the operation
throws:
NoSuchConfigException - if no configuration with the given id exists in the configuration stores
throws:
LifecycleException - if there is a problem loading the configuration |
| loadConfiguration | | LifecycleResults loadConfiguration(Artifact configurationId, LifecycleMonitor monitor) throws NoSuchConfigException, LifecycleException(Code) | | Load the specified configuration (from a config store) and all
configurations it depends on into the kernel. This causes the
configuration gbean to be loaded and started, but does not load any of
the gbeans contained within the configuration.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
Parameters:
monitor - the monitor that should receive events as the operation is carried out the results of the operation
throws:
NoSuchConfigException - if no configuration with the given id exists in the configuration stores
throws:
LifecycleException - if there is a problem loading the configuration |
| loadConfiguration | | LifecycleResults loadConfiguration(ConfigurationData configurationData, LifecycleMonitor monitor) throws NoSuchConfigException, LifecycleException(Code) | | Load the specified configurationData and all configurations it depends
on (from a config store) into the kernel. This causes the configuration
gbean to be loaded and started, but does not load any of the gbeans
contained within the configuration.
Parameters:
configurationData - the configuration to load
Parameters:
monitor - the monitor that should receive events as the operation is carried out the results of the operation
throws:
NoSuchConfigException - if no configuration with the given id exists in the configuration stores
throws:
LifecycleException - if there is a problem loading the configuration |
| reloadConfiguration | | LifecycleResults reloadConfiguration(Artifact configurationId, LifecycleMonitor monitor) throws NoSuchConfigException, LifecycleException(Code) | | Reloads the specified configuration and all configurations that have a
dependency on the specified configuration
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
Parameters:
monitor - the monitor that should receive events as the operation is carried out the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded
throws:
LifecycleException - if there is a problem loading the configuration |
| reloadConfiguration | | LifecycleResults reloadConfiguration(Artifact configurationId, Version version) throws NoSuchConfigException, LifecycleException(Code) | | Reloads the specified configuration and all configurations that have a
dependency on the specified configuration
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
Parameters:
version - new version to load from the config store the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded
throws:
LifecycleException - if there is a problem loading the configuration |
| reloadConfiguration | | LifecycleResults reloadConfiguration(Artifact configurationId, Version version, LifecycleMonitor monitor) throws NoSuchConfigException, LifecycleException(Code) | | Reloads the specified configuration and all configurations that have a
dependency on the specified configuration
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
Parameters:
monitor - the monitor that should receive events as the operation is carried out
Parameters:
version - new version to load from the config store the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded
throws:
LifecycleException - if there is a problem loading the configuration |
| restartConfiguration | | LifecycleResults restartConfiguration(Artifact configurationId) throws NoSuchConfigException, LifecycleException(Code) | | Restarts the specified configuration and all configurations that have a
service dependency on the specified configuration
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true) the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded
throws:
LifecycleException - if there is a problem loading the configuration |
| restartConfiguration | | LifecycleResults restartConfiguration(Artifact configurationId, LifecycleMonitor monitor) throws NoSuchConfigException, LifecycleException(Code) | | Restarts the specified configuration and all configurations that have a
service dependency on the specified configuration
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
Parameters:
monitor - the monitor that should receive events as the operation is carried out the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded
throws:
LifecycleException - if there is a problem loading the configuration |
| setOnline | | void setOnline(boolean online)(Code) | | |
| startConfiguration | | LifecycleResults startConfiguration(Artifact configurationId) throws NoSuchConfigException, LifecycleException(Code) | | Loads and starts all of the gbeans contained within the configuration.
If any of the gbeans fails to fully start, all gbeans will be unloaded
and an exception will be thrown. This operation causes all
configurations that the specified configuration has a service dependency
on to be started.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true) the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded |
| startConfiguration | | LifecycleResults startConfiguration(Artifact configurationId, LifecycleMonitor monitor) throws NoSuchConfigException, LifecycleException(Code) | | Loads and starts all of the gbeans contained within the configuration.
If any of the gbeans fails to fully start, all gbeans will be unloaded
and an exception will be thrown. This operation causes all
configurations that the specified configuration has a service dependency
on to be started.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
Parameters:
monitor - the monitor that should receive events as the operation is carried out the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded |
| stopConfiguration | | LifecycleResults stopConfiguration(Artifact configurationId) throws NoSuchConfigException(Code) | | Stop the gbeans contained within the configuration. This operation
causes all configurations that have a service dependency on the
specified configuration to be stopped.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true) the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded |
| stopConfiguration | | LifecycleResults stopConfiguration(Artifact configurationId, LifecycleMonitor monitor) throws NoSuchConfigException(Code) | | Stop the gbeans contained within the configuration. This operation
causes all configurations that have a service dependency on the
specified configuration to be stopped.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
Parameters:
monitor - the monitor that should receive events as the operation is carried out the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded |
| uninstallConfiguration | | void uninstallConfiguration(Artifact configurationId) throws IOException, NoSuchConfigException(Code) | | Unstalls the specified configuration from the server. This operation
can not be reversed.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
throws:
IOException - if there was a problem removing the configuration
throws:
NoSuchConfigException - if the configuration is not loaded |
| unloadConfiguration | | LifecycleResults unloadConfiguration(Artifact configurationId) throws NoSuchConfigException(Code) | | Stops and unloads the configuration. This causes all contained gbeans
to be stopped and unloaded, and the configuration gbean is stopped and
unloaded. This operation causes all configurations that have a class
or service dependency on the specified configuration to be stopped and
unloaded.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true) the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded |
| unloadConfiguration | | LifecycleResults unloadConfiguration(Artifact configurationId, LifecycleMonitor monitor) throws NoSuchConfigException(Code) | | Stops and unloads the configuration. This causes all contained gbeans
to be stopped and unloaded, and the configuration gbean is stopped and
unloaded. This operation causes all configurations that have a class
or service dependency on the specified configuration to be stopped and
unloaded.
Parameters:
configurationId - the configuration identifier, which must be fullyresolved (isResolved() == true)
Parameters:
monitor - the monitor that should receive events as theoperation is carried out the results of the operation
throws:
NoSuchConfigException - if the configuration is not loaded |
|
|