Create an empty business-level application using programming

Network Deployment (Distributed operating systems), v8.0 > Administer applications and their environment > Administer business-level applications using programming

Create an empty business-level application using programming

You can create an empty business-level application, and then add assets or business-level applications as composition units to the empty business-level application.
This task assumes a basic familiarity with command framework programming. Read about command framework programming in the application programming interfaces documentation.
We can create an empty business-level application using programming, the admin console, or wsadmin.sh.
Create an empty business-level application using programming. In your code that creates the empty business-level application, provide the name parameter. The name parameter specifies the name of the business-level application that you create.

Procedure

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 that 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 that you created in a previous step to create and set up the command that creates an empty business-level application.
The command name is createEmptyBLA. The name parameter is a required parameter that you use to specify the name of the business-level application. We can optionally provide the description parameter to provide a description of the newly created business-level application.
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 execute method in the asynchronous command client to run the command that creates an empty business-level application.
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. You can then check the result by calling the command.getCommandResult method.

Results

After you successfully run the code, the empty business-level application is created.

Example

The following example shows how to create an empty 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.exception.AdminException;
import com.ibm.websphere.management.async.client.AsyncCommandClient;

public class CreateEmptyBLA {

    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);
        .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();
        .println("\nCreated command manager");

        // Optionally create an asynchronous command handler
        // for listening to command notifications.
        // 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 the listener with
// null for the AsyncCommandClient object that follows.

        AsyncCommandClient asyncCmdClientHelper = new
                     AsyncCommandClient(session, listener);
        .println("\nCreated async command client");

        // Create the command that creates an empty
        // business-level application.
        String cmdName = "createEmptyBLA";

        AdminCommand cmd = cmdMgr.createCommand(cmdName);
        cmd.setConfigSession(session); // Create an empty
                      // business-level application using
                      // the session created.
        .println("\nCreated " + cmdName);

        // Set the name command parameter.
        String blaName = "bla1";
        cmd.setParameter("name", blaName);

        .println("\nSet name parameter to "
                            + cmd.getParameter("name"));

        // Uncomment the following lines to set the description of // the business-level application being created:
        //
        // String blaDescription = "description for bla1";
        // cmd.setParameter("description", blaDescription);
        // .println("\nSet description parameter to " +
        //                    cmd.getParameter("description"));

        // Call the asynchronous command client to
        // process the command parameters.
        try {      
             asyncCmdClientHelper.processCommandParameters(cmd);
             .println("\nCompleted process command " +
                                "parameters");
        } catch (Throwable th) {
            .println("Failed from " +
                "asyncCmdClientHelper.processCommandParameters(cmd).");
            th.printStackTrace();
            System.exit(-1);
        }

        // Call the asynchronous command client to run the command.
        asyncCmdClientHelper.execute(cmd);
        .println("\nCompleted command execution");

        // Check the command result.
        CommandResult result = cmd.getCommandResult();
        if (result != null) {
             if (result.isSuccessful()) {
                .println("\nCommand ran successfully "
                       + "with result\n" + result.getResult());
             } else {
                .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.
        .println("\nEXAMPLE: notification received: " +
                            notification);
    }
}
What to do next

We can add business-level applications or assets as composition units into the newly created business-level application. Alternatively, you can add the newly created business-level application to other business-level applications.
Additional Application Programming Interfaces (APIs)
Administer business-level applications using programming
Deploy and administering business-level applications
Add a composition unit using programming
Start a business-level application using programming
Stop a business-level application using programming
Delete a business-level application using programming
List business-level applications using programming
Set up business-level applications using wsadmin.sh

Related

BLAManagement command group using wsadmin.sh

+
Search Tips | Advanced Search