Getting Started

This article will provide overviews of the related technologies; however, in order to exercise the steps outlined here, you will need the following:

• WebSphere Studio Application Developer Integration Edition version 5.0 or later.
• Tivoli Intelligent Orchestrator version 1.1
• A general understanding of the following:
• Java, Web Services, and XML technologies

Back to top

Understanding Business Process

Traditionally, Information Technology has focused on specific IT component monitoring. The new revolution in IT is Business Process Integration (BPI) - or putting a business context around the components. While it is interesting to the IT community that "server XYZ" is having an outage, it is more interesting to know that the ATM Machine at 6th Street and Broadway is no longer dispensing cash and earning money for "Bob's ATM company". Even more interesting, is more complex business processes, such as a supply chain system involving multiple smaller business process systems. BPI products will typically orchestrate the movement of data in a consistent and repeatable fashion in the business process itself and will allow for the consistent and repeatable implementation of a business process.

Back to top

Overview of IBM Tivoli Intelligent ThinkDynamics Orchestrator

The IBM Tivoli Intelligent ThinkDynamics Orchestrator, or ITITO, is a resource management solution that adds a level of automation to the management of data centers. Essentially this means that if a system component of a "supply chain process" was under duress, a new system resource could be dynamically deployed to alleviate the system stress. This plays directly to business specific service level obligations and the ability to balance your computing resources that are needed to achieve these commitments. Using an automated and policy-based management framework, ITITO can dynamically reallocate and configure data center resources within the environment to respond to traffic demands for specified applications. The management of the environment is focused around three key data center processes: infrastructure provisioning, capacity management, and service level management.

IBM Tivoli Intelligent ThinkDynamics Orchestrator senses why to react to the environment by leveraging specifications such as Simple Network Management Protocol (SNMP), Java Management Extensions (JMX), and integration with several core monitoring applications. The judgment of where to respond is prioritized by specified service level objectives. This allows business needs to dictate the movement of computing resources within the environment. The assessment of when to begin provisioning or de-provisioning is managed by an internal capacity planning engine that ensures the timely movement of resources. Finally, the how of provisioning is dictated by the ability to create, customize, manage, deploy, and orchestrate an assortment of workflows that automate data center activities.

Workflows are a core component of IBM Tivoli Intelligent ThinkDynamics Orchestrator in that they represent your data center's "business processes" or "best practices" as it relates to running your data center. These workflows can range in function from allocating and configuring servers, to installation of software and patches, and may be either large and complex or as simple as a single command. ITITO provides a web-based GUI for drag-and-drop workflow composition and flexibility over the sequencing of events.

Back to top

IBM Tivoli Intelligent ThinkDynamics Orchestrator and Web Services

Providing the ability to initiate your data center's "best practices" stored within IBM Tivoli Intelligent ThinkDynamics Orchestrator from an external source is essential to achieving an optimized level of enterprise wide automation. Therefore, ITITO exposes many of its functions, including the ability to initiate workflows, by means of a SOAP interface (Simple Object Access Protocol). This is a very important consideration when applying automation and integration into an enterprise level Services Oriented Architecture (SOA).

Many SOAP artifacts ship with ITITO to facilitate initiating various functions. These artifacts include a set of WSDL (Web Services Description Language) files that describe the service interfaces for all the exposed functions. For a full list of SOAP commands supported by ITITO, please refer to the product's "Operators Guide" documentation. Additionally, you are provided with a SOAP proxy client, called "Invoker", that accepts parameters such as user credentials, WSDL file pointer, and other information about the function you are invoking. This client allows you to easily make ITITO SOAP calls from the command line. We will reuse this "invoker" client later in this article to remotely call an ITITO function.

By default, the SOAP client and associated artifacts are configured to be executed on the command line local to the ITITO server. In order to remotely initiate SOAP calls, the following steps must be performed:

1. Access your ITITO server as user thinkcontrol
2. Within the /tools/soap/lib directory you will find a series of Java libraries that need to copied and added to the classpath of the remote machine that will initiate the SOAP call. These libraries are:
• /j2ee.jar
• /mail.jar
• /qname.jar
• /soap.jar
• /wsdl4j.jar
• /wsif.jar
• /xerces.jar
• /tccommandline.jar
• /commons-logging-api.jar

The "invoker" client class may be found in the tccommandline.jar file (com.ibm.tc.proxy.soap.Invoker)

3. Next, we need to obtain the WSDL files that describe the commands we are interested in. ITITO stores its WSDL files at the following URL: http://[host]:[port]/tcSoap/wsdl where [host] and [port] are the host name and assigned port of your ITITO server. For the example in this article, we are interested in the Operations Mode Service. From the remote machine that will initiate the SOAP call, download and save the following WSDL files:
   • OperationsModeService.wsdl
   • OperationsModeBinding.wsdl
   • OperationsMode.wsdl
   I have included these WSDL files in the source zip file located in the resources section of this article.
4. Modify these downloaded WSDL files to point to your remote ITITO server:
   • Edit the OperationsModeService.wsdl, change the line that points to your SOAP router from "localhost:9080" to the host name and port number of your ITITO server.

You are now prepared to initiate a SOAP call to your ITITO server from a remote machine. To test this, execute the following command from the remote machine:

java com.ibm.tc.proxy.soap.Invoker [user ID] [password] [path to OperationsModeService.wsdl] getGlobalMode

Where [user ID] and [password] are valid user credentials for your ITITO server, and [path to OperationsModeService.wsdl] is a full accessible path to the OperationsModeService.wsdl file. Ensure that both OperationsModeBinding.wsdl and OperationsMode.wsdl are in the same directory as OperationsModeService.wsdl and that your classpath includes are the jar files from step #2 above. You should see a response similar to that of figure 1 below:

The getGlobalMode command is a method that returns the current global operating mode that your ITITO server is running under (for example: manual). We will use the "getGlobalMode" example as we progress further into this article. We are now ready to advance into understanding how WebSphere Process Choreographer may be leveraged to initiate ITITO functions.

Back to top

Overview of WebSphere Process Choreographer

Support for business process technology was incorporated with the release of WebSphere Enterprise Edition version 5.0. This support came with the ability to graphically model business process execution using technologies such as Enterprise Java Beans (EJB), Java methods, and connectors, in addition to incorporating "staff" or "people" into the process.

Requirements for process technology may be found in several key areas, such as:

• Application Sequencing: creating a business process that choreographs a sequence of function calls to multiple applications to perform a business process. (For example: interfacing a change management system prior to interfacing ITITO to provision a server)
• Business-to-Business Integration: creating a business process that manages interaction with one or more sub-processes. (For example: a travel agency booking airline reservations).
• Message Processing: the gathering and correlation of asynchronous messages. (For example: a banking transaction process)
• Exception Handling with Human Interaction: creating a business process that involves human interaction to manage an exception or fault.

Using WebSphere Studio Application Developer Integration Edition (WSAD IE) you can graphically model business processes from within the "Business Integration" perspective. These modeled business processes may then be deployed on your WebSphere application server and initiated. From within the WSAD IE toolset you have access to a variety of "activities" that make up the atomic steps of a business process. These activities include:

• Java Snippet: recommended for data mapping between elements; however, you are not restricted in what can implemented within a Java snippet.
• Service: enables the invocation of any service operation described by a WSDL document (for example: SOAP, EJB, JMS, etc).
• Java: enables you to invoke a method on a Java object directly.
• Enterprise Java Bean: enables you to invoke a method on an EJB.
• Process: enables you to invoke another business process outside of the current process. This activity enforces object reuse and allows you to choreograph over-arching processes.
• Staff: enables you to insert human interaction inside of your modeled business process.

There are several other "activities" that you have access to when modeling a business process, please consult the WebSphere Studio Application Developer Integration Edition documentation for more details.

Back to top

Calling IBM Tivoli Intelligent ThinkDynamics Orchestrator using WebSphere Process Choreographer

This portion of the article will focus on leveraging WebSphere Process Choreographer (WPC) to initiate the "getGlobalMode" ITITO SOAP service call that was exercised earlier. Using the WebSphere Studio Application Developer Integration Edition we are going to create a very basic business process wrapped around the ITITO "invoke" client that was extracted earlier. Our process will accept a user ID, password, WSDL file location pointer, and the command "getGlobalMode" as parameters, which will simply call the external ITITO SOAP service and return the response. Finally, we will deploy and test the process to the WebSphere test environment which is shipped with the WebSphere Studio product.

Why use ITITO's "Invoker" Class?

You are probably wondering why I am using the "Invoker" class provided by ITITO and not just interfacing WPC directly to ITITO's WSDL files. The SOAP interface provided by ITITO uses the HTTP transport and is guarded by "Basic Authentication". This means that your SOAP headers must include Basic Authentication credential data. As of the authoring of this article, the WPC "Invoke Serivce" activity does not have the ability to include Basic Authentication headers. Therefore, we will expose ITITO's "Invoker" utility to the WPC Process, which handles the needed headers for us. This is outlined in Figure 2 below.

Let's Begin

1. Download the source zip file to this project and unzip to an accessible directory.
2. Launch your WebSphere Studio Application Developer Integration Edition.
3. Using the Business Integration Perspective, create a new business integration "service project" called "SimpleTIOCall".
4. From within the properties of the "SimpleTIOCall" project, put the following JARs on the build path (these are the JAR files we copied from the ITITO server):
• /j2ee.jar
• /mail.jar
• /qname.jar
• /soap.jar
• /wsdl4j.jar
• /wsif.jar
• /xerces.jar
• /tccommandline.jar
• /commons-logging-api.jar
5. Select the SimpleTIOCall project and click the "create a java package" icon
6. Enter tioCall.process for the package name and click "finish"
7. Import the InvokeTIO.java class from the source code zip file. Remember, the InvokeTIO class simply "wraps" the original ITITO "Invoker" class. I decided to wrap this class so that I could add other features later, such as: enhanced logging, or other processing logic. Please see the "Why use ITITO's "Invoker" Class?" (above) for more information about why I wrapped this class.

Generate an enterprise service for the InvokeTIO class:

1. Right-click InvokeTIO.java and select New then Other
2. In the New wizard, select Business Integration on the left, Service built from on the right, and click Next.
3. In the New Service window, select Java and click Next. The New Java Service wizard opens.
4. Select the makeTIOCall class method, and click Next.
5. Accept the defaults and click Finish.
6. All the needed WSDL definition files are generated for you. Your Package Explorer should look something like Figure 3:

Create an interface file for our Process:

1. Right-click on the tioCall.process package and click New then Empty Service.
2. In the Empty Service page, enter simpleTIOprocess as the file name and click Finish.

Define Port Types and Operations:

1. In the WSDL Editor, click the Port Types tab.
2. Under the Port Types heading, click Add in and change the name to SimpleTIOProcessPortType.
3. Under the Operations heading, click Add and change the name to getGlobalOperatingMode.
4. Enter getGlobalOperatingModeRequest and getGlobalOperatingModeResponse in Input and Output fields Respectively.

Define Messages:

1. Now, let's define the messages. In the WSDL Editor, click the Messages tab.
2. Under the Messages heading, click Add, and enter getGlobalOperatingModeRequest.
3. Under the Parts Pane, click Add and enter userID.
4. Under the Part Details heading, choose built-in type and select xsd:string type.
5. Repeat these steps for parameters: password, wsdlFile, and operation make them all built-in type of xsd:string.
6. Add one more part called parameters, only this time set the built-in type to soapapache:Vector - this is because the last parameter of the InvokeTIO class is of type "list". This is simply a placeholder as we will not use the parameter in our example.
7. Under the Messages heading, click Add and enter getGlobalOperatingModeResponse.
8. Under the Parts Pane, click Add and enter result.
9. Under the Part Details heading, choose built-in type and select xsd:string type.

Link the Messages to the Operation:

1. Click the Port Types tab.
2. Under the input message, browse to SimpleTIOCall/tioCall/process/simpleTIOprocess.wsdl, choose getGlobalOperatingModeRequest, and click OK.
3. Under the output message, browse to simpleTIOprocess.wsdl, choose getGlobalOperatingModeResponse, and click OK.
4. Exit and save your changes.

Create the actual Process:

1. Select simpleTIOprocess.wsdl and click File, then New, then, Business Process.
2. In the New window, enter simpleTIOprocess as the File name and click Finish.
3. Your Package Explorer should look something like figure 4:

Construct the Process with Activities:

1. Right-click on the link between the Input and Output activity and click Delete.
2. From SimpleTIOCall/tioCall.process, click InvokeTIOJavaService.wsdl and drag it to the editor window.
3. In the Service selection window, chose makeTIOCall from the Operation drop-down list and click OK.
4. From the palette, drop two Java snippet activities onto the process.
5. Using control links, link the activities as shown in the figure 5 below:
6. Right-click the makeTIOCall activity.
7. Choose Properties and then Implementation.
8. Select the input terminal and click New Variable... and then click OK.
9. Select the output terminal and click New Variable... and then click OK.
10. Click OK.

Map Data for the Java Snippets:

1. Select the Java snippet between the Input activity and the makeTIOCall activity.
2. Click Show Java.
3. Add the following code in the user section:

String userID = getInput().getUserID();
String password = getInput().getPassword();
String operation = getInput().getOperation();
String wsdlFile = getInput().getWsdlFile();
List parameters = getInput().getParameters();
// now, create the new message...
tioCall.process.InvokeTIO_msg.MakeTIOCallRequestMessage msg = 
	getMakeTIOCallRequest();
// now, set the msg content..
msg.setUserid( userID );
msg.setPassword( password );
msg.setOperation( operation );
msg.setWsdlLocation( wsdlFile );
msg.setParams( parameters );
setMakeTIOCallRequest( msg );

Don't worry about any errors that appear here, we will fix them in a later step.

4. Now, select the Java snippet between the makeTIOCall activity and the Output activity.
5. Click Show Java.
6. Add the following code in the user section:

// reverse mapping...
tioCall.process.simpleTIOprocess_msg.GetGlobalOperatingModeResponseMessage msg =
	getOutput();

// now, get the response...
tioCall.process.InvokeTIO_msg.MakeTIOCallResponseMessage outMsg = 
	getMakeTIOCallResponse();

// this is coming from the output message of MakeTIOCallResponseMessage
String callResult = getMakeTIOCallResponse().getResult();
	
msg.setResult( "the result:: " + callResult );
setOutput(msg);

7. Save your work.
8. From the Package Explorer double-click simpleTIOprocess.java
9. Under the last import statement, add the following line: import java.util.*; (adding this line should fix any errors in the file)
10. save then close this file.

Testing your Process:

If you have not done so already, complete the steps to configure a "server" for use within the WebSphere Unit Test Environment. Ensure that the configuration is for an "EE Test Environment". For our test to be successful, we need to add a few core libraries to our test server's path.

1. Open your server's configuration within the WSAD editor
2. Select the "Paths" tab
3. Under "Class Path" add the following JARs:
• tccommandline.jar
• wsdl4j.jar
• wsif.jar
• soap.jar
• commons-logging-api.jar
• jrom.jar (located in WSAD_installDir/runtimes/ee_v5/lib/jrom.jar)

Generate a Session Bean:

1. Return to the business integration perspective.
2. Select the simpleTIOprocess.process file.
3. From the toolbar, click the Generate deploy code for a service icon. The Generate Deploy Code wizard opens.
4. On the Deployment page, accept the defaults and click Next.
5. On the Inbound Service Files page, accept the default values in the next few pages, and click Finish.

Deploy our application to the server:

1. Switch to the Server perspective.
2. In the Server Configuration view, expand Servers.
3. Right-click on the Server you plan to use for testing, and select Add then SimpleTIOCallEAR from the drop-down list.
4. In the Servers view, right-click on your server and select Deploy Process.

Test our Session Bean:

1. In the Servers view, right-click your server, and click Start.
2. Once the console view reports that the server is open for e-business, click the Servers tab.
3. Right-click your server and select Run universal test client.
4. In the IBM EJB Test Client view, click JNDI Explorer.
5. In the JNDI Explorer panel, expand tioCall then process and click SimpleTIOProcessPortTypeServiceHome.
6. Under the EJB References heading, expand SimpleTIOProcessPortTypeService then SimpleTIOProcessPortTypeServiceHome and click SimpleTIOProcessPortTypeService_create().
7. In the Parameters pane, click Invoke, and click Work with Object.
8. Under the EJB References heading, expand the newly created SimpleTIOProcessPortTypeService 1 and click String getGlobalOperatingMode(String, String, String, String, List).
9. In the Parameters view, enter the following in the ParameterValue fields and click Invoke:
• [user ID] : a valid user ID for your ITITO server
• [password] : a valid password for your user ID on the ITITO server
• [path to OperationsModeService.wsdl] : the full path that points to your OperationsModeService.wsdl file (remember, this is the edited WSDL file that points to the external address of your ITITO server)
• getGlobalMode : this is the actual command we are executing on the ITITO server
• For the List, set this to null using the drop-down box. We will not use this for our example.

Your test client should look similar to Figure 6:

10. After clicking the "Invoke" button, the result will appear below the "Results from" heading (Figure 7). You will see that my ITITO server responded with "Manual" (note the red box in figure 7 below)

Congratulations, you have just created a process that calls a IBM Tivoli Intelligent ThinkDynamics Orchestrator function. Figure 8 shows the high-level overview of what is actually happening:

1. As our process executes, it sends a SOAP message to call the InvokeTIO class (which we generated description files for and exposed during this exercise)
2. The InvokeTIO class calls the Invoker utility which leverages WSIF to organize our Basic Authentication headers and read our specified WSDL file.
3. The ITITO WSDL file is parsed to get the location of ITITO's SOAP router, input / output messages, and other service information.
4. The Invoker utility issues a SOAP request to ITITO using our passed in parameters.
5. ITITO responds to the Invoker
6. The response is sent back to our running process

Due to the way we configured this business process, we could execute almost any SOAP supported ITITO command provided we had a valid WSDL file for it! Now, imagine expanding this process to perhaps include other essential business process steps, such as "initiating an order" in a remote system, then initiating a "provisioning workflow" on ITITO, or adding a "staff activity" to the process. This type of architecture allows you to encapsulate your data center processes within ITITO and manage "over-arching" macro-workflows that cover end-to-end business processes within WPC. The possibilities are unbounded.

Back to top

Conclusion

Tying together the strength and automation of data center management from IBM Tivoli Intelligent ThinkDynamics Orchestrator with the power of process execution from WebSphere offers a services-based enterprise level architecture for process optimization. This method will integrate Business Processes with traditional IT components and will allow the two systems to interact with each other when necessary. By doing so businesses can now reap all the benefits of micro and macro level workflow processes to control costs, reduce risk, become more responsive to the needs of their business and create consistent business processes.

Back to top

Download

Information about download methods

Resources

• Download the source code used in this article.
  
  
• Tivoli Knowledge Center Online is a repository of education, videos, product information, and other useful resources to aid you in workflow development.
  
  
• IBM Orchestration and Provisioning Automation Library delivers the tools and community you need to build your business around on demand automation.
  
  
• IBM Tivoli Intelligent Orchestrator Operator's Guide
  
  
• WebSphere Business Integration Zone provides articles, Redbooks, and other resources relative to Business Integration.
  
  

About the author

Comments

Back to top

Trademarks  |  My developerWorks terms and conditions

Table of contents

• Getting Started
• Understanding Business Process
• Overview of IBM Tivoli Intelligent ThinkDynamics Orchestrator
• IBM Tivoli Intelligent ThinkDynamics Orchestrator and Web Services
• Overview of WebSphere Process Choreographer
• Calling IBM Tivoli Intelligent ThinkDynamics Orchestrator using WebSphere Process Choreographer
• Conclusion
• Download
• Resources
• About the author
• Comments

Next steps from IBM

Rational Tester for SOA Quality is an automated web services testing and SOA testing tool that supports Web services SOAP, HTTP(S), JMS, WS-Security, UDDI, and RESTful standards.

---

• Try: The no-charge Rational Service Tester for SOA Quality helps quality assurance professionals validate web service based SOA application..
• Article: See the whats new with Rational Service Tester for SOA Quality, and its Generic Service Client, which provides a single client to interact with any SOA service type.
• Tutorial: Get hands-on experience with this Transport for SOAP feature tutorial using Rational Tester for SOA Quality.
• Buy: Rational Service Tester for SOA Quality

My developerWorks community

Dig deeper into Tivoli on developerWorks

Cloud computing for developers

Virtual workshop: Learn how to build a cloud infrastructure and develop/deploy cloud-based applications. (6-8 Apr 2010)

Special offers