ComponentManagerImpl (Nuxeo ECM Projects 9.10 API)

java.lang.Object
- org.nuxeo.runtime.model.impl.ComponentManagerImpl

All Implemented Interfaces:

ComponentManager
```
public class ComponentManagerImpl
extends Object
implements ComponentManager
```
Author:

Bogdan Stefanescu, Florent Guillaume

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`ComponentManagerImpl.Listeners`
`protected static class`	`ComponentManagerImpl.RIApplicationStartedComparator` TODO we use for now the same sorter as OSGIRuntimeService - should be improved later.
`protected static class`	`ComponentManagerImpl.Stash`

Nested classes/interfaces inherited from interface org.nuxeo.runtime.model.ComponentManager
ComponentManager.Listener

Field Summary

Fields
Modifier and Type	Field and Description
`protected Set<String>`	`blacklist`
`protected boolean`	`changed`
`protected boolean`	`isFlushingStash`
`protected ConcurrentMap<ComponentName,Set<Extension>>`	`pendingExtensions`
`protected ComponentRegistry`	`registry`
`protected ComponentRegistry`	`snapshot`
`protected List<RegistrationInfo>`	`standby` The list of standby components (sorted according to the start order) This list is null if component were not yet started or not yet put in standby When putting components in standby all started components are stopped and the `started` list is assigned to `standby` list then the `started` field is nullified.
`protected List<RegistrationInfo>`	`started` The list of started components (sorted according to the start order).
`protected ComponentManagerImpl.Stash`	`stash` A list of registrations that were deployed while the manager was started.

Constructor Summary

Constructors
Constructor and Description

ComponentManagerImpl(RuntimeService runtime)

Constructors
Constructor and Description
`ComponentManagerImpl(RuntimeService runtime)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`activateComponent(RegistrationInfo ri)` Activates the given `RegistrationInfo`.
`protected List<RegistrationInfo>`	`activateComponents()` Activate all the resolved components and return the list of activated components in the activation order
`void`	`addComponentListener(ComponentListener listener)` Adds a component listener.
`void`	`addListener(ComponentManager.Listener listener)` Add a listener to be notified on manager actions like start / stop components.
`protected void`	`applyStash(ComponentManagerImpl.Stash stash)`
`protected void`	`deactivateComponent(RegistrationInfo ri, boolean isShutdown)` Deactivates the given `RegistrationInfo`.
`protected void`	`deactivateComponents(boolean isShutdown)` Deactivate all active components in the reverse resolve order
`Collection<ComponentName>`	`getActivatingRegistrations()` Gets the pending extensions by component.
`Set<String>`	`getBlacklist()`
`ComponentInstance`	`getComponent(ComponentName name)` Gets object instance managed by the named component.
`ComponentInstance`	`getComponentProvidingService(Class<?> serviceClass)` Gets the component that provides the given service.
`Map<ComponentName,Set<Extension>>`	`getMissingRegistrations()` Returns the missing registrations, linked to missing target extension points.
`Set<ComponentName>`	`getNeededRegistrations()` Get the needed component names.
`Set<Extension>`	`getPendingExtensions(ComponentName name)` Get the pending extensions.
`Map<ComponentName,Set<ComponentName>>`	`getPendingRegistrations()` Gets the pending registrations and their dependencies.
`RegistrationInfo`	`getRegistrationInfo(ComponentName name)` Gets the component if there is one having the given name.
`Collection<RegistrationInfo>`	`getRegistrations()` Gets the registered components.
`protected Collection<ComponentName>`	`getRegistrations(int state)`
`ComponentRegistry`	`getRegistry()`
`Collection<ComponentName>`	`getResolvedRegistrations()` Gets the resolved component names in the order they were resolved
`<T> T`	`getService(Class<T> serviceClass)` Gets the service of type serviceClass if such a service was declared by a resolved runtime component.
`String[]`	`getServices()` Get the list of all registered service names An empty array is returned if no registered services are found.
`Collection<ComponentName>`	`getStartFailureRegistrations()` Gets the components that fail on applicationStarted notification
`protected static void`	`handleError(String message, Exception e)`
`boolean`	`hasChanged()` Tests whether components were deployed over the initial snapshot (i.e.
`boolean`	`hasComponentFromLocation(String sourceId)` Given a source location tests if a component was deployed from that location This method was added to support undeploying by location needed by tests.
`boolean`	`hasSnapshot()` Check if a snapshot was done
`boolean`	`isRegistered(ComponentName name)` Checks whether or not a component with the given name was registered.
`boolean`	`isRunning()` Tests whether the components are running.
`boolean`	`isStandby()` Tests whether the components are in standby mode.
`boolean`	`isStarted()` Tests whether the components were already started.
`boolean`	`isStashEmpty()` Tests if the stash is empty
`static void`	`loadContributions(RegistrationInfo ri, Extension xt)`
`boolean`	`refresh()` Shortcut for refresh(false).
`boolean`	`refresh(boolean reset)` Refresh the registry using stashed registrations if any.
`void`	`register(RegistrationInfo ri)` Handles the registration of the given registration info.
`void`	`registerExtension(Extension extension)`
`void`	`registerServices(RegistrationInfo ri)`
`void`	`removeComponentListener(ComponentListener listener)` Removes a component listener.
`void`	`removeListener(ComponentManager.Listener listener)` Remove the component manager listener previously added by `ComponentManager.addListener(Listener)`.
`boolean`	`reset()` Reset the registry to the last snapshot if any and stop the components (if they are currently started).
`void`	`restart(boolean reset)` Optionally reset the registry to the last snapshot and restart the components.
`protected void`	`restoreSnapshot()`
`void`	`resume()` Start standby components.
`protected static void`	`runWihtinTimeout(long timeout, TimeUnit unit, String warn, Runnable runnable)` Log a warning message if the timeout is reached while executing the given runnable.
`void`	`setBlacklist(Set<String> blacklist)`
`protected boolean`	`shouldStash()` Tests whether new registrations should be stashed at registration time.
`void`	`shutdown()` Shuts down the component registry.
`int`	`size()` Gets the number of registered objects in this registry.
`void`	`snapshot()` Make a snapshot of the component registry.
`void`	`standby()` Stop all started components but don't deactivate them.
`void`	`standby(int timeoutInSeconds)` Same as `ComponentManager.standby()` but log a warning if the timeout is reached while stopping components
`boolean`	`start()` Activate and start all resolved components.
`protected void`	`startComponent(RegistrationInfo ri)` Starts the given `RegistrationInfo`.
`protected void`	`startComponents(List<RegistrationInfo> ris, boolean isResume)` Start all given components
`boolean`	`stop()` Stop and deactivate all resolved components.
`void`	`stop(int timeoutInSeconds)` Same as `ComponentManager.stop()` but log a warning if the timeout is reached while stopping components
`protected void`	`stopComponent(RegistrationInfo ri)` Stops the given `RegistrationInfo`.
`protected void`	`stopComponents(boolean isStandby)` Stop all started components.
`void`	`unregister(ComponentName name)` Unregisters a component given its name.
`void`	`unregister(RegistrationInfo regInfo)` Handles the unregistration of the given registration info.
`boolean`	`unregisterByLocation(String sourceId)` This method was added only to support unregistering by location which is used by some tests.
`void`	`unregisterExtension(Extension extension)`
`void`	`unregisterServices(RegistrationInfo ri)`
`void`	`unstash()` Apply the stash if not empty.
`protected void`	`writeDevMetrics(Watch watch, String type)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - pendingExtensions
```
protected final ConcurrentMap<ComponentName,Set<Extension>> pendingExtensions
```
  - blacklist
```
protected volatile Set<String> blacklist
```
  - started
```
protected volatile List<RegistrationInfo> started
```
    The list of started components (sorted according to the start order). This list is null if the components were not yet started or were stopped
    
    Since:
    
    9.2
  - standby
```
protected volatile List<RegistrationInfo> standby
```
    The list of standby components (sorted according to the start order) This list is null if component were not yet started or not yet put in standby When putting components in standby all started components are stopped and the started list is assigned to standby list then the started field is nullified. When resuming standby components the started list is restored from the standby list and the standby field is nullified
    
    Since:
    
    9.2
  - stash
```
protected volatile ComponentManagerImpl.Stash stash
```
    A list of registrations that were deployed while the manager was started.
    
    Since:
    
    9.2
  - registry
```
protected volatile ComponentRegistry registry
```
    Since:
    
    9.2
  - snapshot
```
protected volatile ComponentRegistry snapshot
```
    Since:
    
    9.2
  - isFlushingStash
```
protected volatile boolean isFlushingStash
```
    Since:
    
    9.2
  - changed
```
protected volatile boolean changed
```
    Since:
    
    9.2
- Constructor Detail
  - ComponentManagerImpl
```
public ComponentManagerImpl(RuntimeService runtime)
```
- Method Detail
  - getRegistry
```
public final ComponentRegistry getRegistry()
```
    Since:
    
    9.2
  - getRegistrations
```
public Collection<RegistrationInfo> getRegistrations()
```
    Description copied from interface: ComponentManager
    
    Gets the registered components.
    
    Specified by:
    
    getRegistrations in interface ComponentManager
    
    Returns:
    
    a read-only collection of components
  - getResolvedRegistrations
```
public Collection<ComponentName> getResolvedRegistrations()
```
    Description copied from interface: ComponentManager
    
    Gets the resolved component names in the order they were resolved
    
    Specified by:
    
    getResolvedRegistrations in interface ComponentManager
    
    Since:
    
    9.2
  - getPendingRegistrations
```
public Map<ComponentName,Set<ComponentName>> getPendingRegistrations()
```
    Description copied from interface: ComponentManager
    
    Gets the pending registrations and their dependencies.
    
    Specified by:
    
    getPendingRegistrations in interface ComponentManager
    
    Returns:
    
    the pending registrations
  - getMissingRegistrations
```
public Map<ComponentName,Set<Extension>> getMissingRegistrations()
```
    Description copied from interface: ComponentManager
    
    Returns the missing registrations, linked to missing target extension points.
    
    Specified by:
    
    getMissingRegistrations in interface ComponentManager
  - getNeededRegistrations
```
public Set<ComponentName> getNeededRegistrations()
```
    Get the needed component names. The returned set is not a copy
  - getPendingExtensions
```
public Set<Extension> getPendingExtensions(ComponentName name)
```
    Get the pending extensions. The returned set is not a copy
  - getRegistrationInfo
```
public RegistrationInfo getRegistrationInfo(ComponentName name)
```
    Description copied from interface: ComponentManager
    
    Gets the component if there is one having the given name.
    
    Specified by:
    
    getRegistrationInfo in interface ComponentManager
    
    Parameters:
    
    name - the component name
    
    Returns:
    
    the component if any was registered with that name, null otherwise
  - isRegistered
```
public boolean isRegistered(ComponentName name)
```
    Description copied from interface: ComponentManager
    
    Checks whether or not a component with the given name was registered.
    
    Specified by:
    
    isRegistered in interface ComponentManager
    
    Parameters:
    
    name - the object name
    
    Returns:
    
    true if an object with the given name was registered, false otherwise
  - size
```
public int size()
```
    Description copied from interface: ComponentManager
    
    Gets the number of registered objects in this registry.
    
    Specified by:
    
    size in interface ComponentManager
    
    Returns:
    
    the number of registered objects
  - getComponent
```
public ComponentInstance getComponent(ComponentName name)
```
    Description copied from interface: ComponentManager
    
    Gets object instance managed by the named component.
    
    Specified by:
    
    getComponent in interface ComponentManager
    
    Parameters:
    
    name - the object name
    
    Returns:
    
    the object instance if any. may be null
  - shutdown
```
public void shutdown()
```
    Description copied from interface: ComponentManager
    
    Shuts down the component registry.
    This unregisters all objects registered in this registry.
    
    Specified by:
    
    shutdown in interface ComponentManager
  - getBlacklist
```
public Set<String> getBlacklist()
```
    Specified by:
    
    getBlacklist in interface ComponentManager
  - setBlacklist
```
public void setBlacklist(Set<String> blacklist)
```
    Specified by:
    
    setBlacklist in interface ComponentManager
  - register
```
public void register(RegistrationInfo ri)
```
    Description copied from interface: ComponentManager
    
    Handles the registration of the given registration info.
    This is called by the main registry when all dependencies of this registration info were solved and the object can be registered.
    If true is returned, the object will be added to the main registry under the name given in RegistrationInfo.
    
    Specified by:
    
    register in interface ComponentManager
    
    Parameters:
    
    ri - the registration info
  - unregister
```
public void unregister(RegistrationInfo regInfo)
```
    Description copied from interface: ComponentManager
    
    Handles the unregistration of the given registration info.
    This is called by the main registry when the object is unregistered.
    If true is returned, the object will be removed from the main registry.
    
    Specified by:
    
    unregister in interface ComponentManager
    
    Parameters:
    
    regInfo - the registration info
  - unregister
```
public void unregister(ComponentName name)
```
    Description copied from interface: ComponentManager
    
    Unregisters a component given its name.
    
    Specified by:
    
    unregister in interface ComponentManager
    
    Parameters:
    
    name - the component name
  - unregisterByLocation
```
public boolean unregisterByLocation(String sourceId)
```
    Description copied from interface: ComponentManager
    
    This method was added only to support unregistering by location which is used by some tests. Removing by location should be managed at a higher level (it is useful only for tests) and this method should be removed
    
    Specified by:
    
    unregisterByLocation in interface ComponentManager
    
    Parameters:
    
    sourceId - the location from where the component was deployed
    
    Returns:
    
    false if no component was registered from that location, true otherwise
    
    See Also:
    
    for more on this
  - hasComponentFromLocation
```
public boolean hasComponentFromLocation(String sourceId)
```
    Description copied from interface: ComponentManager
    
    Given a source location tests if a component was deployed from that location
    This method was added to support undeploying by location needed by tests. Should be removed and a test specific helper implemented to support locations
    
    Specified by:
    
    hasComponentFromLocation in interface ComponentManager
  - addComponentListener
```
public void addComponentListener(ComponentListener listener)
```
    Description copied from interface: ComponentManager
    
    Adds a component listener.
    Does nothing if the given listener is already registered.
    
    Specified by:
    
    addComponentListener in interface ComponentManager
    
    Parameters:
    
    listener - the component listener to add
  - removeComponentListener
```
public void removeComponentListener(ComponentListener listener)
```
    Description copied from interface: ComponentManager
    
    Removes a component listener.
    Does nothing if the given listener is not registered.
    
    Specified by:
    
    removeComponentListener in interface ComponentManager
    
    Parameters:
    
    listener - the component listener to remove
  - addListener
```
public void addListener(ComponentManager.Listener listener)
```
    Description copied from interface: ComponentManager
    
    Add a listener to be notified on manager actions like start / stop components.
    
    Specified by:
    
    addListener in interface ComponentManager
  - removeListener
```
public void removeListener(ComponentManager.Listener listener)
```
    Description copied from interface: ComponentManager
    
    Remove the component manager listener previously added by ComponentManager.addListener(Listener). If the listener were not added then nothing is done.
    
    Specified by:
    
    removeListener in interface ComponentManager
  - getComponentProvidingService
```
public ComponentInstance getComponentProvidingService(Class<?> serviceClass)
```
    Description copied from interface: ComponentManager
    
    Gets the component that provides the given service.
    
    Specified by:
    
    getComponentProvidingService in interface ComponentManager
    
    Parameters:
    
    serviceClass - the service class
    
    Returns:
    
    the component or null if none
  - getService
```
public <T> T getService(Class<T> serviceClass)
```
    Description copied from interface: ComponentManager
    
    Gets the service of type serviceClass if such a service was declared by a resolved runtime component.
    If the component is not yet activated it will be prior to return the service.
    
    Specified by:
    
    getService in interface ComponentManager
    
    Type Parameters:
    
    T - the service type
    
    Parameters:
    
    serviceClass - the service class
    
    Returns:
    
    the service object
  - getActivatingRegistrations
```
public Collection<ComponentName> getActivatingRegistrations()
```
    Description copied from interface: ComponentManager
    
    Gets the pending extensions by component.
    
    Specified by:
    
    getActivatingRegistrations in interface ComponentManager
    
    Returns:
    
    the pending extensions
  - getStartFailureRegistrations
```
public Collection<ComponentName> getStartFailureRegistrations()
```
    Description copied from interface: ComponentManager
    
    Gets the components that fail on applicationStarted notification
    
    Specified by:
    
    getStartFailureRegistrations in interface ComponentManager
  - getRegistrations
```
protected Collection<ComponentName> getRegistrations(int state)
```
  - registerExtension
```
public void registerExtension(Extension extension)
```
  - unregisterExtension
```
public void unregisterExtension(Extension extension)
```
  - loadContributions
```
public static void loadContributions(RegistrationInfo ri,
                                     Extension xt)
```
  - registerServices
```
public void registerServices(RegistrationInfo ri)
```
  - unregisterServices
```
public void unregisterServices(RegistrationInfo ri)
```
  - getServices
```
public String[] getServices()
```
    Description copied from interface: ComponentManager
    
    Get the list of all registered service names An empty array is returned if no registered services are found.
    
    Specified by:
    
    getServices in interface ComponentManager
    
    Returns:
    
    an array of registered service.
  - handleError
```
protected static void handleError(String message,
                                  Exception e)
```
  - activateComponents
```
protected List<RegistrationInfo> activateComponents()
```
    Activate all the resolved components and return the list of activated components in the activation order
    
    Returns:
    
    the list of the activated components in the activation order
    
    Since:
    
    9.2
  - activateComponent
```
protected void activateComponent(RegistrationInfo ri)
```
    Activates the given RegistrationInfo. This step will activate the component, register extensions and then register services.
    
    Since:
    
    9.3
  - deactivateComponents
```
protected void deactivateComponents(boolean isShutdown)
```
    Deactivate all active components in the reverse resolve order
    
    Since:
    
    9.2
  - deactivateComponent
```
protected void deactivateComponent(RegistrationInfo ri,
                                   boolean isShutdown)
```
    Deactivates the given RegistrationInfo. This step will unregister the services, unregister the extensions and then deactivate the component.
    
    Since:
    
    9.3
  - startComponents
```
protected void startComponents(List<RegistrationInfo> ris,
                               boolean isResume)
```
    Start all given components
    
    Since:
    
    9.2
  - startComponent
```
protected void startComponent(RegistrationInfo ri)
```
    Starts the given RegistrationInfo. This step will start the component.
    
    Since:
    
    9.3
  - stopComponents
```
protected void stopComponents(boolean isStandby)
```
    Stop all started components. Stopping components is done in reverse start order.
    
    Since:
    
    9.2
  - stopComponent
```
protected void stopComponent(RegistrationInfo ri)
                      throws InterruptedException
```
    Stops the given RegistrationInfo. This step will stop the component.
    
    Throws:
    
    InterruptedException
    
    Since:
    
    9.3
  - start
```
public boolean start()
```
    Description copied from interface: ComponentManager
    
    Activate and start all resolved components. If components were already started do nothing.
    
    Specified by:
    
    start in interface ComponentManager
    
    Returns:
    
    false if components were already started, true otherwise
  - stop
```
public boolean stop()
```
    Description copied from interface: ComponentManager
    
    Stop and deactivate all resolved components. If components were not yet started do nothing
    
    Specified by:
    
    stop in interface ComponentManager
    
    Returns:
    
    false if components were not yet started, true otherwise
  - stop
```
public void stop(int timeoutInSeconds)
```
    Description copied from interface: ComponentManager
    
    Same as ComponentManager.stop() but log a warning if the timeout is reached while stopping components
    
    Specified by:
    
    stop in interface ComponentManager
  - standby
```
public void standby()
```
    Description copied from interface: ComponentManager
    
    Stop all started components but don't deactivate them. After calling this method you can safely contribute new extensions (i.e. modify extension registries).
    If any components were previously started do nothing
    
    Specified by:
    
    standby in interface ComponentManager
  - standby
```
public void standby(int timeoutInSeconds)
```
    Description copied from interface: ComponentManager
    
    Same as ComponentManager.standby() but log a warning if the timeout is reached while stopping components
    
    Specified by:
    
    standby in interface ComponentManager
  - resume
```
public void resume()
```
    Description copied from interface: ComponentManager
    
    Start standby components. If components are not in standby mode the it does nothing.
    
    Specified by:
    
    resume in interface ComponentManager
  - isStarted
```
public boolean isStarted()
```
    Description copied from interface: ComponentManager
    
    Tests whether the components were already started.
    
    Specified by:
    
    isStarted in interface ComponentManager
    
    Returns:
    
    true if components are started, false
  - isStandby
```
public boolean isStandby()
```
    Description copied from interface: ComponentManager
    
    Tests whether the components are in standby mode. That means they were started and then stopped - waiting to be started again.
    When putting components in standby they are stopped but not deactivated. You start back the standby components by calling #resume
    While in standby mode the component manager remains in running state.
    
    Specified by:
    
    isStandby in interface ComponentManager
  - isRunning
```
public boolean isRunning()
```
    Description copied from interface: ComponentManager
    
    Tests whether the components are running. That means they are either started either in standby mode.
    
    Specified by:
    
    isRunning in interface ComponentManager
  - hasSnapshot
```
public boolean hasSnapshot()
```
    Description copied from interface: ComponentManager
    
    Check if a snapshot was done
    
    Specified by:
    
    hasSnapshot in interface ComponentManager
    
    Returns:
    
    true if a snapshot already exists, false otherwise
  - hasChanged
```
public boolean hasChanged()
```
    Description copied from interface: ComponentManager
    
    Tests whether components were deployed over the initial snapshot (i.e. the actual registry differs from the snapshot) If no snapshot was done returns false.
    
    Specified by:
    
    hasChanged in interface ComponentManager
  - snapshot
```
public void snapshot()
```
    Description copied from interface: ComponentManager
    
    Make a snapshot of the component registry. When calling restart
    
    Specified by:
    
    snapshot in interface ComponentManager
  - isStashEmpty
```
public boolean isStashEmpty()
```
    Description copied from interface: ComponentManager
    
    Tests if the stash is empty
    
    Specified by:
    
    isStashEmpty in interface ComponentManager
  - restart
```
public void restart(boolean reset)
```
    Description copied from interface: ComponentManager
    
    Optionally reset the registry to the last snapshot and restart the components.
    When restarting components all components will be stopped, deactivated and re-instantiated. It means that all references to components before a restart will become invalid after the restart.
    If no snapshot was created then the components will be restarted without changing the registry.
    If the reset argument is true then the registry will be reverted to the last snapshot before starting the components.
    
    Specified by:
    
    restart in interface ComponentManager
    
    Parameters:
    
    reset - whether or not to revert to the last snapshot
  - reset
```
public boolean reset()
```
    Description copied from interface: ComponentManager
    
    Reset the registry to the last snapshot if any and stop the components (if they are currently started). After a reset all the components are stopped so we can contribute new components if needed. You must call ComponentManager.start() to start again the components
    
    Specified by:
    
    reset in interface ComponentManager
    
    Returns:
    
    true if the components were stopped, false otherwise
  - refresh
```
public boolean refresh()
```
    Description copied from interface: ComponentManager
    
    Shortcut for refresh(false).
    
    Specified by:
    
    refresh in interface ComponentManager
    
    See Also:
    
    ComponentManager.refresh(boolean)
  - refresh
```
public boolean refresh(boolean reset)
```
    Description copied from interface: ComponentManager
    Refresh the registry using stashed registrations if any. If the reset argument is true then the registry will be reverted to the last snapshot before applying the stash.
    If the stash is empty it does nothing and return true, otherwise it will:
    1. stop the components (if they are started)
    2. revert to the last snapshot (if reset flag is true)
    3. apply the stash (the stash will remain empty after this operation)
    4. start the components (if they was started)
    Specified by:
    
    refresh in interface ComponentManager
    
    Parameters:
    
    reset - whether or not to revert to the last snapshot
    
    Returns:
    
    false if stash is empty and nothing was done, true otherwise
  - restoreSnapshot
```
protected void restoreSnapshot()
```
  - shouldStash
```
protected boolean shouldStash()
```
    Tests whether new registrations should be stashed at registration time. If the component manager was started then new components should be stashed otherwise they can be registered.
    TODO: current implementation is stashing after the start completion. Should we also stashing while start is in progress?
  - applyStash
```
protected void applyStash(ComponentManagerImpl.Stash stash)
```
  - unstash
```
public void unstash()
```
    Description copied from interface: ComponentManager
    
    Apply the stash if not empty. This is a low level operation and may not be safe to call when the component manager is running ComponentManager.isRunning().
    For compatibility reasons (to be able to emulate the old hot deploy mechanism or to speed up tests) this method will force a registry refresh in all 3 component manager states: stopped, standby, started.
    Usually you should apply the stash by calling ComponentManager.refresh() which is similar to stop(); [restoreSnapshot();] unstash(); start();
    
    Specified by:
    
    unstash in interface ComponentManager
  - writeDevMetrics
```
protected void writeDevMetrics(Watch watch,
                               String type)
```
  - runWihtinTimeout
```
protected static void runWihtinTimeout(long timeout,
                                       TimeUnit unit,
                                       String warn,
                                       Runnable runnable)
                                throws InterruptedException
```
    Log a warning message if the timeout is reached while executing the given runnable.
    
    Throws:
    
    InterruptedException

Class ComponentManagerImpl

Nested Class Summary

Nested classes/interfaces inherited from interface org.nuxeo.runtime.model.ComponentManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

pendingExtensions

blacklist

started

standby

stash

registry

snapshot

isFlushingStash

changed

Constructor Detail

ComponentManagerImpl

Method Detail

getRegistry

getRegistrations

getResolvedRegistrations

getPendingRegistrations

getMissingRegistrations

getNeededRegistrations

getPendingExtensions

getRegistrationInfo

isRegistered

size

getComponent

shutdown

getBlacklist

setBlacklist

register

unregister

unregister

unregisterByLocation

hasComponentFromLocation

addComponentListener

removeComponentListener

addListener

removeListener

getComponentProvidingService

getService

getActivatingRegistrations

getStartFailureRegistrations

getRegistrations

registerExtension

unregisterExtension

loadContributions

registerServices

unregisterServices

getServices

handleError

activateComponents

activateComponent

deactivateComponents

deactivateComponent

startComponents

startComponent

stopComponents

stopComponent

start

stop

stop

standby

standby

resume

isStarted

isStandby

isRunning

hasSnapshot

hasChanged

snapshot

isStashEmpty

restart

reset

refresh

refresh