You 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 you 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 you do not use the force option, the deletion fails.
You can delete a composition unit using programming, the administrative console, or the wsadmin tool. The steps describe how to delete a composition unit using programming.
You must 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.
After you successfully run the code, the composition unit is deleted.
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 you use the local
// command manager. Comment out the lines to and including
// CommandMgr cmdMgr = CommandMgr.getClientCommandMgr(soapClient);
// to get the soapClient soap client if
// you 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 your own code here to handle the received notification
System.out.println("\nEXAMPLE: notification received: " +
notification);
}
}
You can complete other tasks associated with the business-level application, such as adding or deleting other composition units, listing composition units, and so on.