Delete a composition unit using programming

WAS v8.5 > Administer applications and their environment > Administer business-level applications using programming
Delete a composition unit using programming

We can delete a composition unit from a business-level application if the composition unit is not functioning correctly, the composition unit is no longer needed, and so on. A composition unit is typically created from a business-level application or an asset and contains configuration information that makes the asset runnable.

This task assumes a basic familiarity with command framework programming. Read about command framework programming in the application programming interfaces documentation.
Before we can delete a composition unit, you must have created an empty business-level application, imported an asset, and added a composition unit to the business-level application. If other composition units depend on the composition unit that you are deleting and we do not use the force option, the deletion fails. We can delete a composition unit using programming, the dmgr console, or wsadmin. This topic describes how to delete a composition unit using programming.
Provide the blaID and cuID parameters to specify the composition unit that you are deleting from the business-level application.
Perform the following tasks to delete a composition unit using programming.

Connect to the application server.
The command framework allows the administrative command to be created and run with or without being connected to the application server. This step is optional if the application server is not running.
Create the command manager.
The command manager provides the functionality to create a new administrative command or query existing administrative commands.
Optionally create the asynchronous command handler for listening to command notifications.
Business-level application commands are implemented as asynchronous commands. To monitor the progress of the running command, we have to create an asynchronous command handler to receive notifications the command generates.
Create the asynchronous command client.
An asynchronous command client provides a higher level interface to work with an asynchronous command. If you created an asynchronous command handler in the previous step, the handler is passed to the asynchronous command client. The asynchronous command client forwards the command notification to the handler and helps to control running of the command.

Use the command manager created in a previous step to create and set up the command that deletes a composition unit.
The command name is deleteCompUnit. The blaID and cuID parameters are required parameters. The cuID parameter is used to specify the composition unit to delete from the business-level application, which is specified with the blaID. We can optionally provide the force parameter to force the deletion if other composition units depend on this composition unit.
Call the processCommandParameters method in the asynchronous command client to process the command parameters.
The command framework asynchronous command model requires this call.
Call the asynchronous command client to run the command that deletes a composition unit.
You might have created an asynchronous command handler to implement the AsyncCommandHandlerIF interface class in a previous step. If you did, the asynchronous command client listens to command notifications and forwards the notifications to the handler. The handler performs any necessary actions while waiting for the command to complete.
Check the command result when the command completes.
When the command finishes running, control is returned to the caller. We can then check the result by calling the command.getCommandResult method.

Results

After you successfully run the code, the composition unit is deleted.

Example

The following example shows how to delete a composition unit from a business-level application based on the previous steps. Some statements are split on multiple lines for printing purposes.
package com.ibm.ws.management.application.task;

import java.util.Properties;

import com.ibm.websphere.management.AdminClient;
import com.ibm.websphere.management.AdminClientFactory;
import com.ibm.websphere.management.Session;
import com.ibm.websphere.management.cmdframework.AdminCommand;
import com.ibm.websphere.management.cmdframework.CommandMgr;
import com.ibm.websphere.management.cmdframework.CommandResult;
import com.ibm.websphere.management.cmdframework.CommandStep;
import com.ibm.websphere.management.cmdframework.TaskCommand;
import com.ibm.websphere.management.async.client.AsyncCommandClient;

public class DeleteCompUnit {

    public static void main(String [] args) {

        try {


            // Connect to the application server.   
            // This step is optional if we use the local    
            // command manager. Comment out the lines to and including             // CommandMgr cmdMgr = CommandMgr.getClientCommandMgr(soapClient);
            // to get the soapClient soap client if   
            // we use the local command manager.   


            String host = "localhost";
            String port = "8880";   // Change to your port number if it is 
                                    // not 8880.
  
            Properties config = new Properties();
            config.put(AdminClient.CONNECTOR_HOST, host);
            config.put(AdminClient.CONNECTOR_PORT, port);
            config.put(AdminClient.CONNECTOR_TYPE,           
                       AdminClient.CONNECTOR_TYPE_SOAP);
            System.out.println("Config: " + config);
            AdminClient soapClient =  
                              AdminClientFactory.createAdminClient(config);
  
            // Create the command manager.
            CommandMgr cmdMgr = CommandMgr.getClientCommandMgr(soapClient);
  
            // Comment out the previous lines to create a client command             // manager if you are using a local command manager.
            // Uncomment the following line to create a local command             // manager:
            //
            // CommandMgr cmdMgr = CommandMgr.getCommandMgr();
            System.out.println("\nCreated command manager");
  
            // Optionally create an asynchronous command handler.
            // Comment out the following line if no further handling             // of command notification is required:
            AsyncCmdTaskHandler listener = new AsyncCmdTaskHandler();
  
            // Create an asynchronous command client.
  
            // Set up the session.
            String id = Long.toHexString(System.currentTimeMillis());
            String user = "content" + id;
            Session session = new Session(user, true);
             
            // If no command handler is used, replace listener with             // null for the following AsyncCommandClient object:
            AsyncCommandClient asyncCmdClientHelper = new  
            AsyncCommandClient(session, listener);
            System.out.println("\nCreated async command client");
  
            // Create the command that deletes the composition unit.
            String cmdName = "deleteCompUnit";
            AdminCommand cmd = cmdMgr.createCommand(cmdName);
            cmd.setConfigSession(session); // Delete the composition unit from                                            // the business-level application                                            // using the session created.
            System.out.println("\nCreated " + cmdName);

            // Set the blaID parameter to the business-level application with             // the composition unit to delete.
            // Examples of valid formats for the blaID parameter are:    
            // - bName             
            // - blaname=bName             
            // - WebSphere:blaname=bName
            // This parameter accepts an incomplete ID as long as             // the incomplete ID can resolve to a unique             // business-level application.
            String blaID = "bla1";
            cmd.setParameter("blaID", blaID);
            
            System.out.println("\nSet blaID parameter to "
                                + cmd.getParameter("blaID"));
            
            // Set the cuID parameter to the composition unit that is to be 
            // deleted.
            // Examples of valid formats for the cuID parameter are:
            // - name             // - cuname=name
            // - WebSphere:cuname=name
            // This parameter accepts an incomplete ID as long as the 
            // incomplete ID can resolve to a unique composition unit
            // within the business-level application.
            String cuID = "cu1";
            cmd.setParameter("cuID", cuID);
            
            System.out.println("\nSet cuID parameter to "
                                + cmd.getParameter("cuID"));
            // Uncomment the following line of code to set the force parameter 
            // to force the deletion even if other composition units depend
            // on this composition unit. 
            // 
            // cmd.setParameter("force", "true"); 

        
            // Call the asynchronous client helper to process parameters.
            try {             
                asyncCmdClientHelper.processCommandParameters(cmd);
                System.out.println("\nCompleted process command " + 
                                           "parameters");
            } catch (Throwable th) {
                System.out.println("Failed from " +   
                    "asyncCmdClientHelper.processCommandParameters(cmd).");
                th.printStackTrace();
                System.exit(-1);
            }
        
            // Call the asynchronous command client to run the command.
            asyncCmdClientHelper.execute(cmd);
            System.out.println("\nCompleted running of the command");
  
            // Check the command result.
            CommandResult result = cmd.getCommandResult();
            if (result != null) {
                if (result.isSuccessful()) {
                    System.out.println("\nCommand ran successfully "
                                   + "with result\n" + result.getResult());
                 } 
                 else {
                    System.out.println("\nCommand ran with " + 
                                               "Exception");
                    result.getException().printStackTrace();
                }
           }
       } catch (Exception e) {
            e.printStackTrace();
       }
    }}


package com.ibm.ws.management.application.task;

import com.ibm.websphere.management.cmdframework.provider.CommandNotification;
import com.ibm.websphere.management.async.client.AsyncCommandHandlerIF;

public class AsyncCmdTaskHandler implements AsyncCommandHandlerIF {

    public void handleNotification(CommandNotification notification) {
        // Add our own code here to handle the received notification
        System.out.println("\nEXAMPLE: notification received: " +   
                            notification);
    }}
We can complete other tasks associated with the business-level application, such as adding or deleting other composition units, listing composition units, and so on.

Related concepts:

Additional Application Programming Interfaces (APIs)

Related

Deploy business-level applications
Administer business-level applications using programming
List composition units using programming
View a composition unit using programming
Add a composition unit using programming
Edit a composition unit using programming
Manage composition units using wsadmin.sh

+
Search Tips | Advanced Search