| java.lang.Object
 org.netbeans.ModuleInstaller
| ModuleInstaller | | abstract public class ModuleInstaller (Code) | | Responsible for actually installing the contents of module JARs into the IDE.
While the manager tracks which modules are enabled and their dependencies,
the installer actually understands the manifest contents and is able to
add layers, sections, etc. to the IDE's runtime.
author:
Jesse Glick |
| Constructor Summary | |
| protected | ModuleInstaller()
No-op constructor for subclasses. |
| Method Summary | |
| abstract public void | close(List<Module> modules)
Notify modules the IDE will be shut down. | | abstract public boolean | closing(List<Module> modules)
Ask to shut down the IDE from a set of modules. | | abstract public void | dispose(Module m)
Called when a module is being uninstalled and runtime information
about it is no longer needed.
The installer should remove any associated cache entries and try
to release anything that might have been loaded with the module's
classloader. | | abstract public void | load(List<Module> modules)
Actually load some modules into the IDE.
They will all have been prepared already, and their classloaders
will be contained in the system classloader.
It is expected to handle any resultant exceptions appropriately
(e.g. | | public Manifest | loadManifest(File jar)
Scan a disabled module JAR file for its manifest contents.
Subclasses may implement this efficiently, e.g. | | abstract public void | prepare(Module m)
Called to ensure that a module is valid to be installed, before continuing.
Should examine the manifest and check its syntax (may keep cached parse
information about that syntax). | | public void | refineClassLoader(Module m, List parents)
Permit a module installer to add extra parent classloaders for a module. | | public void | refineDependencies(Module m, Set<Dependency> dependencies)
Optionally refine the dependencies for a module. | | public String[] | refineProvides(Module m)
Optionally adds additional token for the module. | | public boolean | shouldDelegateResource(Module m, Module parent, String pkg)
Optionally mask package use in a module classloader.
For example, an installer might decide that a module may not use a
package in the application classpath because it is an unguaranteed
implementation package and the module has not explicitly requested
to use it.
The module system automatically excludes improper access
to non-public packages (as declared via OpenIDE-Module-Public-Packages)
and cross-module access to the META-INF/ directory.
The default implementation of this method permits all other
package delegation.
Parameters:
m - the module requesting use of a given package
Parameters:
parent - the module which might possibly supply that package, ornull if the possible provider is not a module (i.e. | | abstract public void | unload(List<Module> modules)
Unload some modules from the IDE. |
| ModuleInstaller | | protected ModuleInstaller()(Code) | | No-op constructor for subclasses.
|
| close | | abstract public void close(List<Module> modules)(Code) | | Notify modules the IDE will be shut down.
Will begin with dependent and end with basic modules.
|
| closing | | abstract public boolean closing(List<Module> modules)(Code) | | Ask to shut down the IDE from a set of modules.
Will begin with dependent and end with basic modules.
|
| dispose | | abstract public void dispose(Module m)(Code) | | Called when a module is being uninstalled and runtime information
about it is no longer needed.
The installer should remove any associated cache entries and try
to release anything that might have been loaded with the module's
classloader. The classloader may still be valid at this point but
better not to use it.
|
| load | | abstract public void load(List<Module> modules)(Code) | | Actually load some modules into the IDE.
They will all have been prepared already, and their classloaders
will be contained in the system classloader.
It is expected to handle any resultant exceptions appropriately
(e.g. skipping over a module, or skipping over that piece of a module).
Where load order is significant, items should be installed in the order
supplied: starting with basic modules and ending with dependent modules.
Installers may choose to install all resources of a certain type (e.g.
layers) from every module, then all of the next type, etc., for purposes
of efficiency.
Note that "loading" could really mean installing or restoring or upgrading,
depending on module history.
|
| loadManifest | | public Manifest loadManifest(File jar) throws IOException(Code) | | Scan a disabled module JAR file for its manifest contents.
Subclasses may implement this efficiently, e.g. to use a special cache.
The default implementation simply opens the JAR and gets its manifest
using the standard JRE calls.
Never called for reloadable JARs.
Parameters:
jar - a module JAR to open its manifest
throws:
IOException - if the JAR cannot be opened or does not have a manifest at all
since:
org.netbeans.core/1 1.5
See Also: "#26786" |
| prepare | | abstract public void prepare(Module m) throws InvalidException(Code) | | Called to ensure that a module is valid to be installed, before continuing.
Should examine the manifest and check its syntax (may keep cached parse
information about that syntax). When this method is called, the module's
classloader should be ready for use, but the system classloader will not
yet contain it. It may (but need not) try to load
mentioned resources from that classloader in order to catch errors early
on. For some resources it may be preferable to load them lazily.
If the installer indicates the module is invalid, it will not be installed.
InvalidException thrown from here must include a reference to the module.
|
| refineClassLoader | | public void refineClassLoader(Module m, List parents)(Code) | | Permit a module installer to add extra parent classloaders for a module.
Called during enablement of a module.
The default implementation does nothing.
Parameters:
m - a module which is about to be enabled
Parameters:
parents - current list of ClassLoader parents; may be mutated (appended to)
since:
org.netbeans.core/1 > 1.6
See Also: "#27853" |
| refineDependencies | | public void refineDependencies(Module m, Set<Dependency> dependencies)(Code) | | Optionally refine the dependencies for a module.
For example, an installer might decide to automatically add a dependency
on a "stock" library module for all client modules meeting some criterion.
The default implementation makes no change.
Parameters:
m - a module to possibly refine dependencies for; overriders must not callgetDependencies on this module nor attempt to directly change itin any way; overriders may ask for module code name, version, etc.
Parameters:
dependencies - a set of Dependency's; mutable, entries may be added or removedduring the dynamic scope of this call
since:
org.netbeans.core/1 1.2 |
| refineProvides | | public String[] refineProvides(Module m)(Code) | | Optionally adds additional token for the module.
Parameters:
m - the module to add token to null or list of tokens this module provides
since:
org.netbeans.core/1 > 1.25
See Also: "#46833" |
| shouldDelegateResource | | public boolean shouldDelegateResource(Module m, Module parent, String pkg)(Code) | | Optionally mask package use in a module classloader.
For example, an installer might decide that a module may not use a
package in the application classpath because it is an unguaranteed
implementation package and the module has not explicitly requested
to use it.
The module system automatically excludes improper access
to non-public packages (as declared via OpenIDE-Module-Public-Packages)
and cross-module access to the META-INF/ directory.
The default implementation of this method permits all other
package delegation.
Parameters:
m - the module requesting use of a given package
Parameters:
parent - the module which might possibly supply that package, ornull if the possible provider is not a module (i.e. applicationclasspath)
Parameters:
pkg - the name of the package in use, in the form "org/netbeans/modules/foo/"(i.e. slash-separated and ending in a slash as well)
since:
org.netbeans.core/1 1.3 |
| unload | | abstract public void unload(List<Module> modules)(Code) | | Unload some modules from the IDE.
Where unload order is significant, items should be uninstalled in the order
supplied: starting with dependent modules and ending with basic modules.
Module classloaders will still be in the system classloader.
|
|
|