List business-level applications using programming

WAS v8.5 > Administer applications and their environment > Administer business-level applications using programming
List business-level applications using programming

We can list the business-level applications of a session so that we can complete further business-level application administration such as deleting a business-level application. A business-level application is an administrative model that captures the definition of an enterprise-level application so that we can perform specific business functions, such as accounting.

Before we can list business-level applications of a session, you must have created an empty business-level application. We can list business-level applications of a session using programming, the dmgr console, or wsadmin. This topic describes how to list business-level applications using programming.
List all the business-level applications of a session unless you set the blatID parameter to specify the business-level application to list. We can optionally list the business-level applications with a description for those that have a description if you set the includeDescription parameter to true. After you list the business-level applications, we can use the information to do further administration, such as starting or deleting business-level applications.
Perform the following tasks to list business-level applications of a session 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 lists business-level applications of a session.
The command name is listBLAs. We can optionally set the blaID parameter to query for business-level applications that match the ID. We can optionally set the includeDescription parameter to display the business-level application descriptions.
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 list the business-level applications of a session.
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, a list of business-level applications for a session is displayed.

Example

The following example shows how to list the business-level applications of a session 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.async.client.AsyncCommandClient;

public class ListBLAs {

        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 AsyncCommandClient object.
                AsyncCommandClient asyncCmdClientHelper = new  
                AsyncCommandClient(session, listener);
                System.out.println("\nCreated async command client");
  
                // Create the command that lists the business-level applications.
                String cmdName = "listBLAs";
                AdminCommand cmd = cmdMgr.createCommand(cmdName);
                cmd.setConfigSession(session); // list all the business-level applications                                               // using the session created. 
                                     
                System.out.println("\nCreated " + cmdName);
    
                // Optionally set the blaID parameter.
                // Uncomment the following code to set the blaID parameter to 
                // only list the business-level applications with the ID specified. Otherwise all 
                // business-level applications are listed. Change the blaID parameter according
                // to your scenario.   
                // Examples of valid formats for the blaID parameter are:    
                // - bName 
                // - blaname=bName  
                // - WebSphere:blaname=bName
                // All business-level applications that match the ID specification                 // are listed. The ID must include at least the business-level
                // application name.                
                // String blaID = "bla1";
                // cmd.setParameter("blaID", blaID);
        
                //System.out.println("\nSet blaID parameter to "
                //                    + cmd.getParameter("blaID"));
        
                // Optionally include a description by setting                 // the includeDescription parameter to true instead of false.
                String includeDescription = "true";
                cmd.setParameter("includeDescription", includeDescription);
        
                System.out.println("\nSet includeDescription parameter to "
                                    + cmd.getParameter("includeDescription"));
        
        
                // 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);
                }
        
                // Run the command to list business-level applications.
                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 business-level applications, such as deleting, starting, or stopping business-level applications.

Related concepts:

Additional Application Programming Interfaces (APIs)

Related

Deploy business-level applications
Administer business-level applications using programming
Start a business-level application using programming
Stopping a business-level application using programming
Delete a business-level application using programming
Create an empty business-level application using programming

+
Search Tips | Advanced Search