Network Deployment (Distributed operating systems), v8.0 > Administer applications and their environment > Administer business-level applications using programming
Export an asset using programming
We can export an asset from the current session so that you can back up the asset, import the asset to another session, 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 application programming interfaces documentation.
This task assumes that we have already imported an asset.
We can export an asset using programming, the administrative console, or wsadmin.sh. This topic describes how to export an asset using programming.
We must provide an assetID parameter value and a file name parameter value to export an asset. The assetID parameter identifies the asset to export. An asset ID can take a number of forms. The list below shows various forms for an asset named asset1.jar.
- asset1.jar
- assetname=asset1.jar
- WebSphere:assetname=asset1.jar
The filename parameter specifies a file system file name and location for the exported asset. Specify a fully qualified file path for the file name parameter because the results with relative path names are unpredictable. If you specify a file name parameter of a file that already exists, the file is overwritten with the exported asset.
Perform the following tasks to export an asset from a business-level application using programming.
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 exports an asset.
The command name is exportAsset. The assetID and filename parameters are required parameters to specify the asset to export and the file name and directory where the asset is exported.
- 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 run the command that exports
an asset.
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 asset is exported.
Example
The following example shows how to export an asset 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.TaskCommand;
import com.ibm.websphere.management.async.client.AsyncCommandClient;
public class ExportAsset {
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.
// 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 following listener with
// null for the AsyncCommandClient object.
AsyncCommandClient asyncCmdClientHelper = new
AsyncCommandClient(session, listener);
.println("\nCreated async command client");
// Create command that exports the asset.
String cmdName = "exportAsset";
AdminCommand cmd = cmdMgr.createCommand(cmdName);
cmd.setConfigSession(session); // Export as asset
// using the session created.
.println("\nCreated " + cmdName);
// (required) Set the assetID parameter to the composition
// unit that you are exporting.
// 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
// within the business-level application.
String assetID = "test5.zip";
cmd.setParameter("assetID", assetID);
.println("\nSet assetID parameter to "
+ cmd.getParameter("assetID"));
// Set the file name for the asset to be exported. Use a
// fully qualified path name. An existing file with the specified // name will be overwritten.
(Windows)
DownloadFile filename = new DownloadFile("c:\assets\asset1.zip");
(Solaris) (AIX)
DownloadFile filename = new DownloadFile("/assets/asset1.zip");
cmd.setParameter("filename", filename);
.println("\nSet filename parameter to "
+ cmd.getParameter("filename"));
// Call the asynchronous client helper to process 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 running of the command");
// 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 import the asset to another session. We can complete other tasks associated with assets, such as listing assets, and editing
assets.
Additional Application Programming Interfaces (APIs)
Deploy and administering business-level applications
Administer business-level applications using programming
Import an asset using programming
Delete an asset using programming
List assets using programming
Edit an asset using programming
View an asset using programming
Manage assets using wsadmin.sh
Related
BLAManagement command group using wsadmin.sh