WAS v8.5 > Administer applications and their environment

Extend application management operations through programming

We can use the common deployment framework to add additional logic to application management operations. The additional logic can do such tasks as code generation, configuration operations, additional validation, and so on. This topic demonstrates, through programming, how to plug into the common deployment framework to extend application management operations.

This task assumes a basic familiarity with Java APIs. Read about the Java APIs in the application programming interfaces documentation.

Before we can extend application management operations, first install WebSphere Application Server. Use this example to extend application management through programming. The tasks the extensions provide are available through all the administrative clients, such as wsadmin, the dmgr console, or through programmatic APIs the AppManagement MBean provides.

1. Define your extension as an Eclipse plug-in and add a plugin.xml file to register your extension provider with the deployment framework.
   1. In the plugin.xml file, provide an extension provider implementation class for the common-deployment-framework-extensionprovider extension point.
   2. Put the plug-in JAR file in the plugins directory of your WAS installation.

   <?xml version="1.0" encoding="UTF-8"?> <plugin
      id=“com.ibm.myproduct.MyExtensionProvider”
      name=“My Extension"
      version="1.0.0"> 
      <extension point=“common-deployment-framework-extensionprovider”>       <action class=“com.acme.MyExtendProviderImpl“/>    </extension> </plugin>

2. Provide an extension provider.

   An extension provider class provides steps for a given operation on an application Enterprise archive (EAR) file. Before an operation runs, the deployment framework queries all the registered extension providers for additional steps. A single list of steps is passed to each provider. Each provider can add steps to the list. The default provider the deployment framework provides is called first to populate the list with default steps. Other extension providers are called next.

   Various operations that we can extend through the common deployment framework are defined as constants in the DeploymentConstants class. These operations are described in the following table. Some operations are split on multiple lines for printing purposes.

   Extensible DeploymentConstants operations. Select an operation to extend..

   Operation	Description
   DeploymentConstants.CDF_OP_INSTALLJ2EE	Installs a Java EE EAR file
   DeploymentConstants.CDF_OP_EDITJ2EE	Edits a deployment application configuration
   DeploymentConstants.CDF_OP_UPDATEJ2EE	Applies a fine-grained update to an application such as addition, removal, or update of a file or a module; or partial update of an application
   DeploymentConstants.CDF_OP_UNINSTALLJ2EE	Uninstalls a Java EE application
   DeploymentConstants. CDF_OP_CREATE_EAR_WRAPPERJ2EE	Wraps the contents input to the application installation into an EAR file

   The AppManagement MBean, which is responsible for deploying and managing Java EE applications on WAS, runs all the operations except the CDF_OP_CREATE_EAR_WRAPPERJ2EE operation. Deploy the extensions that extend these operations in the plugins directory of the stand-alone Application Server .

   Either the wsadmin utlity or the dmgr console runs the CDF_OP_CREATE_EAR_WRAPPERJ2EE operation when the input contents that are supplied to the CDF_OP_INSTALLJ2EE operation are not packaged as an EAR file. Deploy an extension that extends the CDF_OP_CREATE_EAR_WRAPPERJ2EE operation in the plugins directory of the wsadmin installation.

   The following example provides an extension provider that does the following tasks:

   1. Adds two additional steps for the application installation operation

   2. Adds one step for wrapping input contents into an EAR file

   package com.acme;
   
   import com.ibm.websphere.management.deployment.registry.ExtensionProvider;
   import com.ibm.websphere.management.deployment.core.DeploymentConstants;
   
   public class MyExtensionProviderImpl extends ExtensionProvider {
     public void addSteps (String type, String op, String phase, 
      List steps)
     {
      if (op.equals (DeploymentConstants.CDF_OP_INSTALLJ2EE))
      {
       // Add a code generation step.
       steps.add (0, new com.acme.CodeGenStep());
       // Add a configuration step.
       steps.add (new com.acme.ConfigStep());
      }
      else if (op.equals (DeploymentConstants.CDF_OP_CREATE_EAR_WRAPPERJ2EE))
      {
       // Add an ear-wrapper step.
       steps.add (new com.acme.EarWrapperStep());
      }
     }}

3. Provide the deployment step implementation.

   An extension provider adds a deployment step. The step contains logic that performs additional processing in an application management operation. The logic provides the step access to the deployment context and the deployable object. The deployment context provides information, such as the name of the operation, the configuration session ID, a temporary location for creating temporary files, operation parameters, and so on. The deployable object wraps the deployment content input to the operation. For example, the deployable object wraps the Java EE EAR file for the installation operation or a file, a module, or a partial application for the update operation.

   • The following example illustrates how an extension during installation entirely changes an EAR file that is input to the installation operation. The example provides a deployment step during the installation operation that does the following tasks:

     1. Runs code generation to generate a new EAR file.
     2. Calls the setContentPath method in the DeployableObject class to set the new EAR file path. The default installation logic, such as steps the default installation logic adds, uses this new EAR file for installation in the configuration repository.

     package com.acme;
     
     import com.ibm.websphere.management.deployment.core.DeploymentStep;
     import com.ibm.websphere.management.deployment.core.DeployableObject;
     
     public class CodeGenStep extends DeploymentStep
     {
       public void execute (DeployableObject dObject)
       {
        EARFile earFile = (EARFile)dObject.getHandle();
        String newEARPath = null;
        // Use step specific logic to create another EAR file after code generation.
        …
        newEARPath = _context.getTempDir() + "new.ear";
     
        dObject.setContentPath (newEARPath);
       }  }

   • The following example provides a deployment step that:

     1. Reads the contents of the input EAR file.
     2. Manipulates the configuration session accessed through the context instance, _context.

     package com.acme;
     
     public class ConfigStep extends DeploymentStep
     {
       public void execute (DeployableObject dObject)
       {
        EARFile earFile = (EARFile) dObject.getHandle();
     
        // Use the following example code to perform the configuration.
        String sessionID = _context.getSessionID();
        com.ibm.websphere.management.Session session = new     com.ibm.websphere.management.Session (sessionID, true);
        // Use the configuration service to perform the configuration steps.
        …
     
        // Read the application configuration.
        Application appDD = earFile.getDeploymentDescriptor();
        …
     
        String newEARPath = null;
       }  }

   • The following example provides a deployment step to wrap arbitrary content around an EAR file. Application management logic accepts only the EAR file for deployment. An extension is required to input anything other than an EAR file to the deployment process.

     package com.acme;
     
     import com.ibm.websphere.management.deployment.core.DeploymentStep;
     import com.ibm.websphere.management.deployment.core.DeployableObject;
     
     public class EarWrapperStep extends DeploymentStep
     {
       public void execute (DeployableObject dObject)
       {
        Archive archive = (Archive) dObject.getHandle();
        String newEARPath = null;
        // provide the logic to wrap the jar with the ear
        …
        newEARPath = //;
        // Set the new ear path back into DeploymentContext
        this.getContext().getContextData()
          .put(DeploymentContext.RETURN_Object_key, newEARPath);
       }  }

Results

Through programming, we have plugged into the common deployment framework to extend application management operations.

We can extend other application management operations, or do any other administrative operations you choose.

Related concepts:

Common deployment framework
Additional Application Programming Interfaces (APIs)

Related

Manage applications through programming

+

Search Tips   |   Advanced Search