Overview | Package | Class | Use | Tree | Deprecated | Index | Help
|  | BEA Systems, Inc.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## weblogic.deploy.api.spi
Interface WebLogicDeploymentManager

All Superinterfaces:
  DeploymentManager

    public interface WebLogicDeploymentManager

extends DeploymentManager

This interface provides WebLogic Server extensions to the `DeploymentManager` interface.

A WebLogicDeploymentManager object is a stateless interface into the Weblogic Server deployment framework. It provides basic deployment features as well as extended WebLogic Server deployment features such as production redeployment and partial deployment of modules in an Enterprise Application. Acquire a WebLogicDeploymentManager object using `DeploymentFactory`.

See Also:
  `DeploymentFactory.getDeploymentManager(java.lang.String, java.lang.String, java.lang.String)`

Method Summary
`ProgressObject` | `activate(TargetModuleID[] tmids, File application, File plan, DeploymentOptions options)` Deprecated.
`DeploymentConfiguration` | `createConfiguration(DeployableObject deployableObject)` Creates a DeploymentConfiguration object for the provided DeployableObject.
`WebLogicTargetModuleID` | `createTargetModuleID(String app, ModuleType type, Target target)` Factory for creating a root TargetModuleID object.
`WebLogicTargetModuleID` | `createTargetModuleID(TargetModuleID base, String module, ModuleType type)` Factory for creating child TargetModuleID objects.
`ProgressObject` | `deploy(TargetModuleID[] tmids, File application, File plan, DeploymentOptions options)` A convenience method for distributing and starting an application.
`ProgressObject` | `distribute(Target[] targets, File application, File plan)` Copies the complete deployment bundle, module, configuration data and any additional generated code to the target.
`ProgressObject` | `distribute(Target[] targets, File application, File plan, DeploymentOptions options)` Distributes an application.
`ProgressObject` | `distribute(Target[] targets, InputStream application, InputStream plan)` Moves the complete deployment bundle, module, configuration data and any additional generated code to the target.
`ProgressObject` | `distribute(Target[] targets, InputStream application, InputStream plan, DeploymentOptions options)` Distributes an application.
`ProgressObject` | `distribute(TargetModuleID[] targets, File application, File plan, DeploymentOptions options)` Distributes an application.
`void` | `enableFileUploads()` Causes a file distribution operation to first perform an upload operation.
`TargetModuleID[]` | `filter(TargetModuleID[] modules, String appName, String moduleName, String versionId)` Returns a subset of the input module list based on the specified application name, module name, and version identifier.
`TargetModuleID[]` | `getAvailableModules(ModuleType moduleType, Target[] targets)` Retrieves a list of all configured modules of a specified type.
`Locale` | `getCurrentLocale()` Returns the locale that the plugin is currently using.
`DConfigBeanVersionType` | `getDConfigBeanVersion()` Indicates the J2EE platform version being used to generate server configuration information.
`Locale` | `getDefaultLocale()` Returns the locale of the plugin that was established when the DeploymentManager was constructed
`String` | `getDomain()` Returns the Weblogic Server domain name associated with this DeploymentManager.
`TargetModuleID[]` | `getModules(weblogic.management.configuration.ConfigurationMBean mbean)` Returns TargetModuleID objects associated with application MBeans.
`TargetModuleID[]` | `getNonRunningModules(ModuleType moduleType, Target[] targets)` Retrieves a list of configured, inactive modules of the specified type.
`TargetModuleID[]` | `getRunningModules(ModuleType moduleType, Target[] targets)` Retrieves a list of active modules of the specified type.
`Locale[]` | `getSupportedLocales()` Returns the locales supported by the JVM.
`Target[]` | `getTargets()` Returns known targets in the currently-connected WebLogic Server domain.
`boolean` | `isConnected()` Indicates whether this DeploymentManager is currently connected to an administrative domain.
`boolean` | `isDConfigBeanVersionSupported(DConfigBeanVersionType version)` Indicates support for a specific J2EE platform version for generating server configuration information.
`boolean` | `isLocal()` Indicates whether this DeploymentManager is running local to the Administration Server for the domain.
`boolean` | `isLocaleSupported(Locale locale)` Indicates whether the specified locale is supported.
`boolean` | `isRedeploySupported()` Indicates whether the `WebLogicDeploymentManager.redeploy(javax.enterprise.deploy.spi.TargetModuleID[], java.io.File, java.lang.String[], weblogic.deploy.api.spi.DeploymentOptions)` methods support transparent redeployment of an application.
`ProgressObject` | `redeploy(TargetModuleID[] modules, File application, File plan)` Redeploys an application and deployment plan without affecting the session state.
`ProgressObject` | `redeploy(TargetModuleID[] modules, File application, File plan, DeploymentOptions options)` Redeploys an application and plan without affecting the session state.
`ProgressObject` | `redeploy(TargetModuleID[] modules, File app, String[] delta, DeploymentOptions options)` Redeploys named files in a staged application.
`ProgressObject` | `redeploy(TargetModuleID[] modules, InputStream application, InputStream plan)` Redeploys an application, replacing the current application files and plan with an updated version.
`ProgressObject` | `redeploy(TargetModuleID[] modules, InputStream application, InputStream plan, DeploymentOptions options)` Redeploys an application and deployment plan without affecting the session state.
`void` | `release()` Releases all server resources held by the DeploymentManager, and places it in a disconnected state.
`void` | `setDConfigBeanVersion(DConfigBeanVersionType version)` Changes the J2EE platform version used for generating server configuration information.
`void` | `setLocale(Locale locale)` Establishes the locale for the deployment SPI plugin.
`ProgressObject` | `start(TargetModuleID[] modules)` Starts an application, making it available to users.
`ProgressObject` | `start(TargetModuleID[] modules, DeploymentOptions options)` Starts an application, making it available to users.
`ProgressObject` | `stop(TargetModuleID[] modules)` Stops an application, making it unavailable to users.
`ProgressObject` | `stop(TargetModuleID[] modules, DeploymentOptions options)` Stops an application, making it unavailable to users.
`ProgressObject` | `undeploy(TargetModuleID[] modules)` Undeploys an application, removing it from the domain configuration.
`ProgressObject` | `undeploy(TargetModuleID[] modules, DeploymentOptions options)` Undeploys an application, removing it from the domain configuration.
`ProgressObject` | `undeploy(TargetModuleID[] modules, File app, String[] delta, DeploymentOptions options)` Removes staged files from an existing deployment.
`ProgressObject` | `update(TargetModuleID[] modules, File plan, DeploymentOptions options)` Allows for updating an application configuration using an changed deployment plan.

Method Detail

### createTargetModuleID

    WebLogicTargetModuleID createTargetModuleID(String app,
                                                ModuleType type,
                                                Target target)

  Factory for creating a root TargetModuleID object. This object can be used as the base TargetModuleID when creating module level TargetModuleIDs.

  Parameters:
    `app` - is name of the application root module
    `type` - is the type of module
    `target` - is where the application will be targeted
  Returns:
    root TargetModuleID representing the root module on the named target

### createTargetModuleID

    WebLogicTargetModuleID createTargetModuleID(TargetModuleID base,
                                                String module,
                                                ModuleType type)

  Factory for creating child TargetModuleID objects. These TargetModuleIDs allow for fine grain control of module level targeting. When used in a deployment operation, only the lowest, targeted, level module is processed. The base module is not explicitly targeted. The resulting TargetModuleID is based on the base module. The module being targeted is a child of the resulting TargetModuleID.

  Parameters:
    `base` - is the parent of the module to be created
    `module` - is the name of the module
    `type` - is the type of module
  Returns:
    the root module of the new chain of TargetModuleID's. The newly created module is either a child or grandchild of the root.

### isLocal

    boolean isLocal()

  Indicates whether this DeploymentManager is running local to the Administration Server for the domain.

### getDomain

    String getDomain()

  Returns the Weblogic Server domain name associated with this DeploymentManager. The domain name is meaningful only when the WebLogicDeploymentManager is connected.

### isConnected

    boolean isConnected()

  Indicates whether this DeploymentManager is currently connected to an administrative domain.

### deploy

    ProgressObject deploy(TargetModuleID[] tmids,
                          File application,
                          File plan,
                          DeploymentOptions options)
                          throws TargetException,
                                 IllegalStateException

  A convenience method for distributing and starting an application. The application source files and deployment plan are distributed to the deployment targets. If distribution is successful, the application is then started on each of the targets. Successful deployment requires that all targets receive both the archive and deployment plan.

  If any modules are currently running, this method immediately restarts those modules using the newer files. Restarting modules in this manner is not the same as redeployment, because session state is not preserved for the active modules.

  Parameters:
    `tmids` - represent the targeted modules to receive a copy of the application files and deployment plan.
    `application` - A supported J2EE application or module archive, or a root directory for the application or module.
    `plan` - The deployment plan for this application. The deployment plan is a serialized version of a `WebLogicDeploymentConfiguration` object.
    `options` - Allows for overriding the deployment options. May be null.
  Returns:
    ProgressObject Provides the state of the distribution. All other errors are reported via the returned ProgressObject.
  Throws:
    `IllegalStateException` - If the DeploymentManager is not currently connected.
    `TargetException`

### update

    ProgressObject update(TargetModuleID[] modules,
                          File plan,
                          DeploymentOptions options)
                          throws IllegalStateException

  Allows for updating an application configuration using an changed deployment plan.

  A configuration update is equivalent to replacing the application's deployment plan. The deployment plan is redeployed in-place. A new version of the application is not started, even if the new deployment plan has a different version.

  The update succeeds only if changes to the deployment plan do not require the application to be restarted. Configuration changes in the new deployment plan must be limited to tuning the application. Changes to resource bindings causes the update to fail. Use `WebLogicDeploymentManager.redeploy(TargetModuleID[],File,File)` to apply resource binding changes to a production application.

  This method targets only root modules. Module level targeting is not supported.

  The target list is derived from the TargetModuleID list.

  Parameters:
    `modules` - The modules to be redeployed. All modules must identify the same version of the application. This parameter must not be null.
    `plan` - The deployment plan containing the new deployment configuration information.
    `options` - Allows for overriding the deployment options. May be null.
  Returns:
    ProgressObject An object that tracks and reports the status of the distribution process.
  Throws:
    `IllegalStateException` - If the DeploymentManager has been released.
  See Also:
    `WebLogicDeploymentManager.redeploy(TargetModuleID[],File,File)`

### enableFileUploads

    void enableFileUploads()
                           throws IllegalStateException

  Causes a file distribution operation to first perform an upload operation. By default, all files are assumed to be local to the Admininistration Server for the target domain. This method causes the DeploymentManager to assume that all files are on a file system unavailable to the Administration Server.

  Throws:
    `IllegalStateException` - If not currently connected.

### redeploy

    ProgressObject redeploy(TargetModuleID[] modules,
                            File app,
                            String[] delta,
                            DeploymentOptions options)
                            throws IllegalStateException

  Redeploys named files in a staged application. This operation replaces or adds files specified in the delta, without guaranteeing uninterrupted operation of the staged application.

  All TargetModuleIDs must refer to the root module of the same application. A failed ProgressObject is returned if multiple applications are represented in the TargetModuleIDs. This method ignores duplicate TargetModuleIDs.

  Parameters:
    `modules` - A list of modules to redeploy. This parameter must not be null.
    `app` - Optional application source. Only required if the archive also requires uploading.
    `delta` - A list of file paths or names relative to the root of the staged application that are to be replaced or added. This parameter must not be null.
    `options` - Allows for overriding the deployment options. May be null.
  Returns:
    ProgressObject An object that tracks and reports the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### undeploy

    ProgressObject undeploy(TargetModuleID[] modules,
                            File app,
                            String[] delta,
                            DeploymentOptions options)
                            throws IllegalStateException

  Removes staged files from an existing deployment. There is no guarantee that session state will be preserved following this operation.

  All TargetModuleIDs must refer to the root module of the same application. A failed ProgressObject is returned when multiple applications are represented in the TargetModuleIDs. This method ignores any duplicate TargetModuleIDs.

  The application referenced by the TargetModuleIDs should already exist in the WebLogic Server configuration. The application need not be stopped. If the application is not configured at all, the undeploy operation completes successfully.

  Parameters:
    `modules` - A list of root modules to undeploy. This parameter must not be null. All modules must identify the same version of the application.
    `app` - The application source.
    `delta` - The file path or names relative to the root of the staged application that are to be removed from the distribution. This parameter must not be null.
    `options` - Allows for overriding the deployment options. May be null.
  Returns:
    ProgressObject An object that provides the state of the undeploy operation.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### filter

    TargetModuleID[] filter(TargetModuleID[] modules,
                            String appName,
                            String moduleName,
                            String versionId)

  Returns a subset of the input module list based on the specified application name, module name, and version identifier.

  Parameters:
    `modules` - The module list.
    `appName` - The name of application to match. This parameter may not be null.
    `moduleName` - The name of module in the application to match. A null value matches only the root module.
    `versionId` - The version to match. A null value matches all versions.
  Returns:
    A subset of the input module list.

### getModules

    TargetModuleID[] getModules(weblogic.management.configuration.ConfigurationMBean mbean)
                                throws IllegalStateException

  Returns TargetModuleID objects associated with application MBeans. For tools that work primarily with MBeans, this method provides a convenient mechansim for creating a set of TargetModuleID objects to use in subsequent deployment operations.

  If an AppDeploymentMBean is specified, then the returned module list consists of root modules wherever the application is configured. For SubDeploymentMBeans's, only the relevant non-root modules are returned. The selection of modules is based primarily on the name of the provided mbean.

  Parameters:
    `mbean` - An MBean for a configured module.
  Returns:
    A module list usable in subsequent deployment operations.
  Throws:
    `IllegalStateException` - If not currently connected.
    `IllegalArgumentException` - (unchecked) If argument is null or invalid.

### start

    ProgressObject start(TargetModuleID[] modules,
                         DeploymentOptions options)
                         throws IllegalStateException

  Starts an application, making it available to users. This opration is equivalent to `WebLogicDeploymentManager.start(TargetModuleID[])`, but allows for deployment option overrides.

  Parameters:
    `modules` - A list of root modules to start. Each module must identify the same version of the application.
    `options` - Allows for start option overrides. This parameter may be null.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### stop

    ProgressObject stop(TargetModuleID[] modules,
                        DeploymentOptions options)
                        throws IllegalStateException

  Stops an application, making it unavailable to users.

  All TargetModuleIDs must refer to the root module of the same application. A failed ProgressObject is returned if multiple applications are represented. This method ignores duplicate TargetModuleIDs.

  The application referenced by the TargetModuleIDs must already be in the WebLogic Server configuration. Any TargetModuleID that represents an application not already running on its target is a no-op; the stop is considered successful and is not tracked in the ProgressObject. Otherwise, the application is stopped on the target.

  Parameters:
    `modules` - A list of root modules to stop. Each module must identify the same version of the application.
    `options` - Allows for stop option overrides. This parameter may be null.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### undeploy

    ProgressObject undeploy(TargetModuleID[] modules,
                            DeploymentOptions options)
                            throws IllegalStateException

  Undeploys an application, removing it from the domain configuration.

  All TargetModuleIDs must refer to the root module of the same application. A failed ProgressObject is returned if multiple applications are represented. This method ignores duplicate TargetModuleIDs.

  The application referenced by the TargetModuleIDs should already exist in the WebLogic Server configuration in a stopped state. Any modules that are not currently configured are ignored. If the application is not configured at all, the undeploy operation completes successfully.

  Parameters:
    `modules` - A list of root modules to undeploy. Each module must identify the same version of the application.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### distribute

    ProgressObject distribute(Target[] targets,
                              File application,
                              File plan,
                              DeploymentOptions options)
                              throws IllegalStateException

  Distributes an application. This opration is equivalent to `WebLogicDeploymentManager.distribute(Target[],File,File)`, but allows for deployment option overrides.

  Parameters:
    `targets` - WebLogic Server targets to receive a copy of the application and deployment plan.
    `application` - A supported J2EE application or module archive, or a root directory.
    `plan` - A deployment plan for this application. The plan is a serialized version of a `DeploymentConfiguration` object.
    `options` - Allows for deployment option overrides. This parameter may be null.
  Returns:
    ProgressObject An object that provides the state of the distribution. All other errors are reported via the returned ProgressObject.
  Throws:
    `IllegalStateException` - If not currently connected.

### distribute

    ProgressObject distribute(TargetModuleID[] targets,
                              File application,
                              File plan,
                              DeploymentOptions options)
                              throws IllegalStateException,
                                     TargetException

  Distributes an application. This operation allows the application to have module level targeting. The application files are copied to the targeted servers and the domain configuration is updated accordingly.

  Parameters:
    `targets` - WebLogic Server targets to receive a copy of the application and deployment plan.
    `application` - A supported J2EE application or module archive, or a root directory.
    `plan` - A deployment plan for this application. The plan is a serialized version of a `DeploymentConfiguration` object.
    `options` - Allows for deployment option overrides. This parameter may be null.
  Returns:
    ProgressObject An object that provides the state of the distribution. All other errors are reported via the returned ProgressObject.
  Throws:
    `IllegalStateException` - If not currently connected.
    `TargetException`

### distribute

    ProgressObject distribute(Target[] targets,
                              InputStream application,
                              InputStream plan,
                              DeploymentOptions options)
                              throws IllegalStateException

  Distributes an application. This opration is equivalent to `WebLogicDeploymentManager.distribute(Target[],File,File)`, but allows for deployment option overrides.

  Parameters:
    `targets` - WebLogic Server targets to receive a copy of the application and deployment plan.
    `application` - A supported J2EE application or module archive, or root directory.
    `plan` - An optional deployment plan for this application. The deployment plan is a serialized version of a `DeploymentConfiguration` object.
    `options` - Allows for deploy option overrides. This parameter may be null.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### redeploy

    ProgressObject redeploy(TargetModuleID[] modules,
                            File application,
                            File plan,
                            DeploymentOptions options)
                            throws UnsupportedOperationException,
                                   IllegalStateException

  Redeploys an application and plan without affecting the session state. This operation is equivalent to `WebLogicDeploymentManager.redeploy(TargetModuleID[],File,File)`, but allows for overrides to the deployment options.

  Parameters:
    `modules` - A list of root modules to redeploy. Each module must identify the same version of the application.
    `application` - The archive or root directory of the application.
    `plan` - The deployment plan for this application. The deployment plan is a serialized version of a `DeploymentConfiguration` object.
    `options` - Allows for overrides to the deployment options. This parameter may be null.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - if not currently connected. All other errors are reported via the returned ProgressObject.
    `UnsupportedOperationException`

### redeploy

    ProgressObject redeploy(TargetModuleID[] modules,
                            InputStream application,
                            InputStream plan,
                            DeploymentOptions options)
                            throws UnsupportedOperationException,
                                   IllegalStateException

  Redeploys an application and deployment plan without affecting the session state. This operation is equivalent to `WebLogicDeploymentManager.redeploy(TargetModuleID[],InputStream,InputStream)`, but allows for overrides to deployment options.

  Parameters:
    `modules` - A list of root modules to redeploy. Each module must identify the same version of the application.
    `application` - The archive or root directory of the application.
    `plan` - The deployment plan for this deployment. The deployment plan is a serialized version of a `DeploymentConfiguration` object.
    `options` - Allows for overrides to deployment options. This parameter may be null.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.
    `UnsupportedOperationException`

### getTargets

    Target[] getTargets()
                        throws IllegalStateException

  Returns known targets in the currently-connected WebLogic Server domain.

  Specified by:
    `getTargets` in interface `DeploymentManager`
  Returns:
    Target objects representing WebLogic Server targets. These objects may be cast to `WebLogicTarget`.
  Throws:
    `IllegalStateException` - If not connected.

### getRunningModules

    TargetModuleID[] getRunningModules(ModuleType moduleType,
                                       Target[] targets)
                                       throws TargetException,
                                              IllegalStateException

  Retrieves a list of active modules of the specified type. An Enterprise Application is considered active if any of its modules are active on the target.

  Specified by:
    `getRunningModules` in interface `DeploymentManager`
  Parameters:
    `moduleType` - One of EAR, WAR, EJB or RAR.
    `targets` - A list of configured targets.
  Returns:
    current version of running modules of specified type.
  Throws:
    `TargetException` - If an invalid Target object is encountered.
    `IllegalStateException` - If not currently connected.
  See Also:
    `WebLogicDeploymentManager.isConnected()`, `WebLogicTargetType`

### getNonRunningModules

    TargetModuleID[] getNonRunningModules(ModuleType moduleType,
                                          Target[] targets)
                                          throws TargetException,
                                                 IllegalStateException

  Retrieves a list of configured, inactive modules of the specified type. An Enterprise Application is considered inactive if all of its modules are inactive on the target.

  Specified by:
    `getNonRunningModules` in interface `DeploymentManager`
  Parameters:
    `moduleType` - One of EAR, WAR, EJB or RAR.
    `targets` - A list of configured targets.
  Returns:
    current version of stopped modules of specified type.
  Throws:
    `TargetException` - If an invalid Target object is encountered.
    `IllegalStateException` - If not currently connected.
  See Also:
    `WebLogicDeploymentManager.isConnected()`, `WebLogicTargetType`

### getAvailableModules

    TargetModuleID[] getAvailableModules(ModuleType moduleType,
                                         Target[] targets)
                                         throws TargetException,
                                                IllegalStateException

  Retrieves a list of all configured modules of a specified type.

  Specified by:
    `getAvailableModules` in interface `DeploymentManager`
  Parameters:
    `moduleType` - One of EAR, WAR, EJB or RAR.
    `targets` - A list of configured targets.
  Returns:
    current version of all modules of specified type.
  Throws:
    `TargetException` - If an invalid Target object is encountered.
    `IllegalStateException` - If not currently connected.
  See Also:
    `WebLogicDeploymentManager.isConnected()`, `WebLogicTargetType`

### createConfiguration

    DeploymentConfiguration createConfiguration(DeployableObject deployableObject)
                                                throws InvalidModuleException

  Creates a DeploymentConfiguration object for the provided DeployableObject. The DeploymentConfiguration object will populate a deployment plan based on embedded configuration information. This includes WebLogic Server descriptors and/or an embedded deployment plan.

  Specified by:
    `createConfiguration` in interface `DeploymentManager`
  Parameters:
    `deployableObject` - The deployable module.
  Throws:
    `InvalidModuleException` - If the module type is unsupported.

### distribute

    ProgressObject distribute(Target[] targets,
                              File application,
                              File plan)
                              throws IllegalStateException

  Copies the complete deployment bundle, module, configuration data and any additional generated code to the target. The application may be an archive or the root directory of an exploded application.

  The files are local (on the same host) to the deployer tool in all cases. If the File objects represent relative abstract paths, they are relative to the current directory of the tool.

  By default all files are assumed to be local to the Administration Server for the target domain. This can be overridden using `WebLogicDeploymentManager.enableFileUploads()`.

  Actual copying of files from the Administration Server to the targeted Managed Servers is based on the staging attribute of the target servers.

  The name of the configured application is taken from the deployment plan, if present. Otherwise, the application file's name is used, without its extension. If an application of the same name is already configured, then it must have the same path as the path specified in the application's File object. If the path does not match, the distribution operation fails.

  If a deployment plan is not provided (null) then a previously-deployed plan is removed as part of the distribution.

  After the application files have been distributed they are validated on each target server. If the application is already running on a target the request will fail. Applications must be stopped before distributing

  Specified by:
    `distribute` in interface `DeploymentManager`
  Parameters:
    `targets` - WebLogic Server targets to receive a copy of the application and deployment plan.
    `application` - A supported J2EE application or module archive, or a root directory.
    `plan` - A deployment plan for this deployment. The plan is a serialized version of a `DeploymentConfiguration` object.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - if not currently connected. All other errors are reported via the returned ProgressObject.

### distribute

    ProgressObject distribute(Target[] targets,
                              InputStream application,
                              InputStream plan)
                              throws IllegalStateException

  Moves the complete deployment bundle, module, configuration data and any additional generated code to the target. The application must be a stream for a supported J2EE archived application.

  The application and deployment plan streams are written to temporary files and distributed as defined for `WebLogicDeploymentManager.distribute(Target[], File, File)`

  Specified by:
    `distribute` in interface `DeploymentManager`
  Parameters:
    `targets` - WebLogic Server targets to receive a copy of the application and deployment plan.
    `application` - A supported J2EE application or module archive stream.
    `plan` - An optional (may be null) deployment plan for this deployment. The plan is a serialized version of a `DeploymentConfiguration` object.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### start

    ProgressObject start(TargetModuleID[] modules)
                         throws IllegalStateException

  Starts an application, making it available to users.

  All TargetModuleIDs must refer to the root module of the same application. A failed ProgressObject is returned if multiple applications are represented. Any duplicate TargetModuleIDs are ignored.

  The application referenced by the TargetModuleIDs must already exist in the WebLogic Server configuration. Any TargetModuleID that represents an application already running on its target is a no-op, unless that application is running in test mode. If an application is running in test mode, this method brings the application fully online.

  Specified by:
    `start` in interface `DeploymentManager`
  Parameters:
    `modules` - A list of root modules to start. Each module must identify the same version of the application.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### stop

    ProgressObject stop(TargetModuleID[] modules)
                        throws IllegalStateException

  Stops an application, making it unavailable to users.

  All TargetModuleIDs must refer to the root module of the same application. A failed ProgressObject is returned if multiple applications are represented. This method ignores duplicate TargetModuleIDs.

  The application referenced by the TargetModuleIDs must already be in the WebLogic Server configuration. Any TargetModuleID that represents an application not already running on its target is a no-op; the stop is considered successful and is not tracked in the ProgressObject. Otherwise, the application is stopped on the target.

  Specified by:
    `stop` in interface `DeploymentManager`
  Parameters:
    `modules` - A list of root modules to stop. Each module must identify the same version of the application.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### undeploy

    ProgressObject undeploy(TargetModuleID[] modules)
                            throws IllegalStateException

  Undeploys an application, removing it from the domain configuration.

  All TargetModuleIDs must refer to the root module of the same application. A failed ProgressObject is returned if multiple applications are represented. This method ignores duplicate TargetModuleIDs.

  The application referenced by the TargetModuleIDs should already exist in the WebLogic Server configuration in a stopped state. Any modules that are not currently configured are ignored. If the application is not configured at all, the undeploy operation completes successfully.

  Specified by:
    `undeploy` in interface `DeploymentManager`
  Parameters:
    `modules` - A list of root modules to undeploy. Each module must identify the same version of the application.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.

### isRedeploySupported

    boolean isRedeploySupported()

  Indicates whether the `WebLogicDeploymentManager.redeploy(javax.enterprise.deploy.spi.TargetModuleID[], java.io.File, java.lang.String[], weblogic.deploy.api.spi.DeploymentOptions)` methods support transparent redeployment of an application. If supported, then transparent redeployment is dependent on application's configuration. Specifically, the application must specify a version in the archive manifest's `Weblogic-Application-Version` entry, and in the deployment plan.

  Specified by:
    `isRedeploySupported` in interface `DeploymentManager`

### redeploy

    ProgressObject redeploy(TargetModuleID[] modules,
                            File application,
                            File plan)
                            throws UnsupportedOperationException,
                                   IllegalStateException

  Redeploys an application and deployment plan without affecting the session state.

  All TargetModuleIDs must refer to root module of the same application. A failed ProgressObject is returned if multiple applications are represented. This method ignores duplicate TargetModuleIDs.

  The application archive and deployment plan are redistributed as described for the `WebLogicDeploymentManager.distribute(Target[],File,File)` operation. The application referenced by the TargetModuleIDs must already exist in the WebLogic Server configuration. If a TargetModuleID represents an application that is already running on its target, this operation redeploys the application. If the applications or modules are not currently running, this method starts them.

  Redeployment involves starting a new version of the application, based on the version information embedded in the application archive and/or deployment plan. Other running versions of the application are unaffected by the redeployment. The older version of the application is automatically undeployed only after it has become idle.

  Specified by:
    `redeploy` in interface `DeploymentManager`
  Parameters:
    `modules` - A list of root modules to redeploy. Each module must identify the same version of the application.
    `application` - The archive or root directory of the application.
    `plan` - The deployment plan for this application. The deployment plan is a serialized version of a `DeploymentConfiguration` object.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.
    `UnsupportedOperationException`

### redeploy

    ProgressObject redeploy(TargetModuleID[] modules,
                            InputStream application,
                            InputStream plan)
                            throws UnsupportedOperationException,
                                   IllegalStateException

  Redeploys an application, replacing the current application files and plan with an updated version. This method is equivalent to `WebLogicDeploymentManager.redeploy(TargetModuleID[], File , File)` with the exception that the application and deployment plan are provided as InputStreams. The streams are written to a temporary file and redeployed from there.

  Specified by:
    `redeploy` in interface `DeploymentManager`
  Parameters:
    `modules` - A list of root modules to redeploy. Each module must identify the same version of the application.
    `application` - An optional (may be null) archive or root directory of the application.
    `plan` - An optional (may be null) deployment plan for this application. The deployment plan is a serialized version of a `DeploymentConfiguration` object.
  Returns:
    ProgressObject An object that provides the state of the distribution.
  Throws:
    `IllegalStateException` - If not currently connected. All other errors are reported via the returned ProgressObject.
    `UnsupportedOperationException`

### release

    void release()

  Releases all server resources held by the DeploymentManager, and places it in a disconnected state.

  Specified by:
    `release` in interface `DeploymentManager`

### getDefaultLocale

    Locale getDefaultLocale()

  Returns the locale of the plugin that was established when the DeploymentManager was constructed

  Specified by:
    `getDefaultLocale` in interface `DeploymentManager`

### getCurrentLocale

    Locale getCurrentLocale()

  Returns the locale that the plugin is currently using.

  Specified by:
    `getCurrentLocale` in interface `DeploymentManager`

### setLocale

    void setLocale(Locale locale)
                   throws UnsupportedOperationException

  Establishes the locale for the deployment SPI plugin.

  Specified by:
    `setLocale` in interface `DeploymentManager`
  Throws:
    `UnsupportedOperationException` - If the locale is not supported by the JVM.
  See Also:
    `Locale.getAvailableLocales()`

### getSupportedLocales

    Locale[] getSupportedLocales()

  Returns the locales supported by the JVM.

  Specified by:
    `getSupportedLocales` in interface `DeploymentManager`
  See Also:
    `Locale.getAvailableLocales()`

### isLocaleSupported

    boolean isLocaleSupported(Locale locale)

  Indicates whether the specified locale is supported. (Supported locales are those supported by the JVM.)

  Specified by:
    `isLocaleSupported` in interface `DeploymentManager`
  See Also:
    `Locale.getAvailableLocales()`

### getDConfigBeanVersion

    DConfigBeanVersionType getDConfigBeanVersion()

  Indicates the J2EE platform version being used to generate server configuration information.

  Specified by:
    `getDConfigBeanVersion` in interface `DeploymentManager`

### isDConfigBeanVersionSupported

    boolean isDConfigBeanVersionSupported(DConfigBeanVersionType version)

  Indicates support for a specific J2EE platform version for generating server configuration information.

  Specified by:
    `isDConfigBeanVersionSupported` in interface `DeploymentManager`

### setDConfigBeanVersion

    void setDConfigBeanVersion(DConfigBeanVersionType version)
                               throws DConfigBeanVersionUnsupportedException

  Changes the J2EE platform version used for generating server configuration information.

  Specified by:
    `setDConfigBeanVersion` in interface `DeploymentManager`
  Throws:
    `DConfigBeanVersionUnsupportedException` - If the platform is not supported.

### activate

    ProgressObject activate(TargetModuleID[] tmids,
                            File application,
                            File plan,
                            DeploymentOptions options)
                            throws TargetException,
                                   IllegalStateException

  Deprecated.

  Same as {#link #deploy(TargetModuleID[], File, File, DeploymentOptions)}

  Throws:
    `TargetException`
    `IllegalStateException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Documentation is available at http://e-docs.bea.com/wls/docs92 Copyright 2006 BEA Systems Inc.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD