View a business-level application using programming

WAS v8.5 > Administer applications and their environment > Administer business-level applications using programming
View a business-level application using programming

We can view business-level application information such as the description so that we can do other tasks associated with the business-level application, such as editing the business-level application. A business-level application is an administrative model that captures the entire definition of an enterprise-level application.

This task assumes a basic familiarity with command framework programming. Read about command framework programming in the application programming interface documentation.
Before we can view a business-level application, you must have created the business-level application.
We can view a business-level application using programming, the dmgr console, or wsadmin. Provide the blaID parameter to specify the business-level application that you are viewing.
Perform the following tasks to view a business-level application 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 to view a business-level application.
The command name is viewBLA. Use the required blaID parameter to specify the business-level application that you are viewing.
Call the processCommandParameters method in the asynchronous command client to process the command parameters.
The command framework asynchronous command model requires this call.

Display the command step.
Call the asynchronous command client to run the command to view a business-level application.
You could 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, we can view a business-level application.

Example

The following example shows how to view 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 EditBLA {

    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 following lines to get the soapClient soap client if             // you are going to use the local command manager. You would             // comment out the lines to and including             // CommandMgr cmdMgr = 
            // CommandMgr.getClientCommandMgr(soapClient);

            String host = "localhost"; // Change to your host if it is not 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.
            // This example creates a new session. We can replace the             // code below to use an existing session that has been 
            // created.
            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 following AsyncCommandClient object.
            AsyncCommandClient asyncCmdClientHelper = new                             AsyncCommandClient(session, listener);
            System.out.println("\nCreated async command client");

            // Create the command.
            String cmdName = "viewBLA";
            AdminCommand cmd = cmdMgr.createCommand(cmdName);
            cmd.setConfigSession(session); // View an existing                                            // business-level application                                            // using the session created.
            System.out.println("\nCreated " + cmdName);


            // Set the required blaID parameter.
            // 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";  // Replace the bla1 value with your value.
            cmd.setParameter("blaID", blaID);

            System.out.println("\nSet blaID parameter to "
                    + cmd.getParameter("blaID"));

            // 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("Throwing an exception from " +
                    "asyncCmdClientHelper.processCommandParameters(cmd).");
                th.printStackTrace();
                System.exit(-1);
            }

            // Display step data.
            String[] stepNames = ((TaskCommand) cmd).listCommandSteps();
            for (int i = 0; i < stepNames.length; i++) {

                // Get the step.
                CommandStep step =
                           ((TaskCommand)cmd).gotoStep(stepNames[i]);

                List paramNames = step.listParameterName();

                System.out.println("----------- Step: " + step.getName() + 
                                   " ----------");
                // Get the parameter values for each row.
                for (int j = 0; j < step.getNumberOfRows(); j++) {
                    System.out.println("  Row " + j);

                    for (int k = 0; k < paramNames.size(); k++)
                        System.out.println("      " + paramNames.get(k) +
                               ": " + step.getParameter(
                                       (String) paramNames.get(k), j));

                }

            }

            // Run the command to view the business-level application.
            asyncCmdClientHelper.execute(cmd);
            System.out.println("\nCompleted command execution");

            CommandResult result = cmd.getCommandResult();
            if (result != null) {
                if (result.isSuccessful()) {
                    System.out.println("\nCommand executed successfully "
                           + "with result\n" + result.getResult());
                }
                else {
                    System.out.println("\nCommand executed 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 use the information that you viewed about the business-level application to perform other tasks. You might edit the business-level application to make improvements to it. You might start and stop a business-level application, delete a business-level application, add a composition unit to a business-level application, and so on.

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
List business-level applications using programming
Edit a business-level application using programming

+
Search Tips | Advanced Search