Edit an asset using programming

Edit an asset using programming

We can edit the information of an asset such as its destination location, its relationship with other assets, and so on. An asset represents at least one binary file that implements business logic.

This task assumes a basic familiarity with command framework programming. Read about command framework programming in the APIs documentation.
Before we can edit an asset, you must have imported an asset.
We can edit an asset of a business-level application using programming, the console, or wsadmin.sh.

We can edit an asset of a business-level application using programming, the console, or wsadmin.sh. The steps describe how to edit an asset of a business-level application using programming.
Provide the assetID parameter to specify the asset that you are editing.
Perform the following tasks to edit an asset of 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 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 we 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 edits an asset.
The command name is editAsset. The assetID parameter is a required parameter to specify the asset that you are editing.

Call the asynchronous command client to process the command parameters.

Set up the command step parameters.
The AssetOptions step contains data about the asset such as its description, file permission, and relationship with other assets. We can edit various parameters in the AssetOptions step.

Call the asynchronous command client to run the command that edits an asset of a business-level application.
We might have created an asynchronous command handler to implement the AsyncCommandHandlerIF interface class in a previous step. If we 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 asset of a business-level application is edited.

Example

The following example shows how to edit an asset of 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 EditAsset {

    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 get the 
            // soapClient soap client 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 the 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 async 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 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 that edits the asset.
            String cmdName = "editAsset";
            AdminCommand cmd = cmdMgr.createCommand(cmdName);
            cmd.setConfigSession(session); // Edit an imported asset
                                           // using the session created.
            System.out.println("\nCreated " + cmdName);
        
            // Set the assetID parameter 
            // Examples of valid formats for the assetID parameter are:   
            // - aName
            // - assetname=aName 
            // - WebSphere:assetname=aName
            // This parameter accepts an incomplete ID as long as            // the incomplete ID can resolve to a unique asset.
            String assetID = "asset1.zip";
            cmd.setParameter("assetID", assetID);
        
            System.out.println("\nSet assetID parameter to "
                                + cmd.getParameter("assetID"));
        
            // 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);
            }
        
            // Set up the step parameters for the AssetOptions step.
            String stepName = "AssetOptions";
            CommandStep step = ((TaskCommand) cmd).gotoStep(stepName);
        
            // Asset description:
            String description = "asset for testing";
        
            // destination of deployed asset 
String destinationUrl = "c:\myInstalledAssets\asset1.zip";
(zos)(iseries)
String destinationUrl = "/myInstalledAssets/asset1.zip";
            // Asset type aspect:
            String typeAspect = "spec=sharedlib";

            // Asset validation:
            String validate = "yes";

            // Permission of files: 
            String filePermission = ".*\\.dll=755";

            // Asset relationship:
            String relationship = "";
        
            for (int i = 0; i < step.getNumberOfRows(); i++) {
                // The following lines set the description and typeAspect
                // step parameters. There are other step parameters 
                // in the AssetOptions step in the following comments. Change the set                 // of step parameters as required by the scenario.

                // For example, set description                 step.setParameter("description", description, i);
                System.out.println("\nSet description parameter to " +
                      step.getParameter("description", i));
                
                // For example, set the typeAspect parameter.
                // Format of a typeAspect is: 
                // WebSphere:spec=xxx,version=n.n+
                // WebSphere:spec=xxx,version=n.n
                step.setParameter("typeAspect", typeAspect, i);
                System.out.println("\nGet typeAspect: " +
                      step.getParameter("typeAspect", i));

                // For example, set the destination parameter.
                step.setParameter("destination", destination, i);
                System.out.println("\nSet destination parameter to " +
                         step.getParameter("destination", i)); 
                 
                // For example, set the validate parameter.
                step.setParameter("validate", validate, i);
                System.out.println("\nSet validate parameter to " +
                        step.getParameter("validate", i));
                
                // For example, set the filePermission perameter.
                step.setParameter("filePermission", filePermission, i);
                System.out.println("\nSet filePermission parameter to " + 
                      step.getParameter("filePermission", i));
                
                // For example, set relationship.
                step.setParameter("relationship", relationship, i);
                System.out.println("\nSet relationship paramter to " +
                        step.getParameter("relationship", i));
            }
        
            // Run the command to edit the asset.
            asyncCmdClientHelper.execute(cmd);
            System.out.println("\nCompleted running of 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);
    }
}
What to do next

After you edit the asset, we can add the asset as a composition unit to a business-level application, or export the asset.

Related concepts

Additional APIs

Related tasks

Deploy and administering business-level applications
Administer business-level applications using programming
Import an asset using programming
Delete an asset using programming
Export an asset using programming
Listing assets using programming
View an asset using programming
Manage assets

BLAManagement (AdminTask)