Nowadays, content distributors deliver all content, including news and site updates, as feeds. Most enterprise applications use feeds for various purposes, including to monitor an application and check the status of a project. Content providers publish a feed link on their site that users register with a feed reader. The feed reader checks for updates to the registered feeds at regular intervals. When it detects an update in the content, the feed reader requests the updated content from the content provider. The feeds contain only a summary of the content, but they provide a link to the detailed content. Atom Syndication Format and RSS are the most common specifications of feeds. We're using Atom feeds in this article, but you can change easily to RSS feeds with a little modification.

Most Fortune 500 companies have many applications and data hosted in mainframes. Delivering the content in mainframes as feeds can be a challenge, but it's critical to the successful adoption of Web 2.0 in the enterprise.

To meet this challenge, a tool or programming methodology must be able to deliver identified content in mainframes as Atom/RSS feeds. This article leverages a product called IBM WebSphere Host Access Transformation Services (HATS), which converts any given green-screen, character-based 3270 or 5250 host application into a Web application (HTML) or rich-client application. HATS also allows programmatic interfaces to convert the identified content in these host applications into any other format. We'll take a step-by-step approach to show you how to write a HATS program that converts the host application content into Atom feeds. Figure 1 shows a bird's-eye view of this solution.

To create this solution, you need the following products:

• IBM Rational® Software Delivery Platform: This middleware can help you automate the development process.
• HATS: Use HATS to create Web and rich-client applications that provide a GUI for character-based 3270 and 5250 host applications.
• Apache Abdera (optional): Abdera is an implementation of the Internet Engineering Task Force (IETF) Atom Syndication Format and Atom Publishing Protocol specifications.

Overview of the solution

The HATS runtime code runs inside one or more HATS applications deployed on IBM® WebSphere® Application Server and sends data back and forth between the user and an application on the host. Feed readers interact with the HATS application. After you develop a HATS application that can deliver feeds, you deploy it on WebSphere Application Server the same way you would deploy any other application.

When the feed reader checks the feed-enabled HATS application, the HATS application triggers the backend host application from which it collects the content. A configuration file (called a HATS macro) defines the data that is required from the screens of the host application. The HATS application collects the required data from the screens and makes it available through a variable (called a HATS global variable). It then triggers the program (called HATS business logic) and hands over the collected data. You construct the feed using the Atom feed library from the collected data, and the same is delivered to the feed reader.

With the HATS macro configuration file, you can provide programmed navigation through multiple host screens. For example, it can navigate the screens of a host application to display the first screen the user needs to see, bypassing all the screens in between. The HATS runtime collects and stores the data in the global variable. It extracts data from host screens and enters the data on other screens. The HATS business logic program constructs the feed using the Atom feed library. Figure 2 can help you understand the flow of the solution.

Identifying a business process and recording a macro

First, you need to create a HATS project for an identified business process and record a macro. You can find a detailed procedure about working with HATS macros in the online HATS help documentation.

We use an application called Echo on a mainframe that echoes back the input text entered in the first screen. For demonstration purposes, we use the text "Hello World" as an input that is echoed back in the next screen.

Figure 3 shows Echo's main screen, where the user inputs the data under the heading "ENTER DATA TO ECHO BELOW." The user inputs the string "Hello World!!!" You can change this input to any application-specific string by setting this value in a HATS global variable.

Figure 4 displays the data that the user inputs. "Hello World!!!" is shown as the displayed output, which corresponds to the input in Figure 3. You extract this output and expose it as Atom feeds.

You can consider the Echo program as a business process, and you can record a macro. This macro runs automatically and collects relevant data from the mainframe application without any user intervention. Use the screen customization feature of HATS, where you can configure HATS to run the macro when the first screen of the application is detected. Figure 5 shows how the macro is linked to the application-entry screen.

Click New Screen Customization to bring up the Screen Customization wizard, where the recorded macro is linked to the screen shown in Figure 5 and plays automatically when HATS detects the entry screen during runtime.

Figure 6 shows that the echoFeeds macro is triggered and played back when the application entry screen in Figure 5 matches during runtime.

Adding business logic

You need to create business logic that contains the code to expose the output of the business process as Atom feeds. The business logic creates an Atom feed using regular XML libraries as noted in the Atom feed specification. Alternatively, you can also use Atom feed libraries, such as Apache Abdera, which require you to write less code than you might with XML libraries. However, the IBM Rational Software Delivery Platform doesn't bundle these libraries or the dependent libraries that they require.

Start by creating the business logic that gets triggered when you collect all the necessary data from the mainframe application through macros. To begin, go to HATS Studio and click File > New > HATS Business Logic, as shown in Figure 7.

Figure 8 shows the Create Business Logic wizard, where you can see that AtomFeeds is the name of the Java™ file that contains the business logic. It can belong to a certain package, but for simplicity, here AtomFeeds belongs to the default package.

Next, you create a Java file named AtomFeeds.java under the Java Source folder of the HATS project. HATS generates the code automatically. You add the code required to perform the business logic to the execute method. Next, as shown in Listing 1, you add the code to deliver the Atom feeds in this execute() method of the generated business logic.

   IResponse response = blInfo.getResponse();
   String outputValue=blInfo.getGlobalVariable("output").getString("outputValue");
   try
   {
   OutputStreamWriter responseStream = new OutputStreamWriter(response.getOutputStream());
   try
   {
   DocumentBuilderFactory feedFactory = DocumentBuilderFactory.newInstance();
   DocumentBuilder feedBuilder = feedFactory.newDocumentBuilder();
   Document doc = feedBuilder.newDocument();

   Element root = doc.createElementNS("http://www.w3.org/2005/Atom",feed);
   doc.appendChild(root);

   Element title = doc.createElement("title");
   root.appendChild(title);
   Text titleText = doc.createTextNode("Sample Feed from HATS");
   title.appendChild(titleText);

   //in similar lines add updated and summary element

   Element updated = doc.createElement("updated");
   root.appendChild(updated);
   Text updateText = doc.createTextNode(new Date().toString());
   updated.appendChild(updateText);

   Element summary = doc.createElement("summary");
   root.appendChild(summary);
   Text summaryText = doc.createTextNode("This has the feeds from zSeries");
   summary.appendChild(summaryText);

   Element entry = doc.createElement("entry");
   root.appendChild(entry);

   Element titleEntry =doc.createElement("title");
   titleEntry.setTextContent("I am first Entry");
   entry.appendChild(titleEntry);

   Element link=doc.createElement("link");
   link.setAttribute("href", "http://www.ibm.com");
   entry.appendChild(link);

   Element id=doc.createElement("id");
   id.setTextContent("urn:test-test");
   entry.appendChild(id);

   Element updatedEntry = doc.createElement("updated");
   entry.appendChild(updatedEntry);
   Text updateEntryText = doc.createTextNode(new Date().toString());
   updatedEntry.appendChild(updateEntryText);

   Element summaryEntry = doc.createElement("summary");
   
   //The next line sets the output from mainframe as summary in Atom Feed
   
   summaryEntry.setTextContent(outputValue);
   entry.appendChild(summaryEntry);

   TransformerFactory feedTransformerFactory = TransformerFactory.newInstance();
   Transformer feedTransformer = feedTransformerFactory.newTransformer();
   feedTransformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,"yes");
   feedTransformer.setOutputProperty(OutputKeys.INDENT,"yes");

   StringWriter sw = new StringWriter(); StreamResult
   result = new StreamResult(sw);
   DOMSource source = new DOMSource(doc);
   feedTransformer.transform(source,result);
   String xmlString = sw.toString();
   
   //The next line delivers the constructed Atom feed to feed reader
   
   responseStream.write(xmlString);

   } catch (Exception e) { System.out.println(e); }

   responseStream.close();

   } catch (IOException e) { e.printStackTrace();

   }

Finally, you create a DOM structure using XML according to the Atom feed specification and add it to the execute() method of the business logic Java file AtomFeeds. This forms the crux of the business logic for this objective.

Back to top

Customizing the screen to trigger the business logic

Now you need to trigger the business logic after the macro ends. Use the Screen Customization wizard to customize the screen from Figure 4 and trigger the business logic AtomFeeds to execute. Figure 9 shows the Screen Customization wizard, which adds triggerBusinessLogic under the Screen Customizations folder of the HATS project.

Check Add advanced actions as Figure 10 shows, so that the next screen in this wizard provides a way for you to trigger the business logic AtomFeeds.java.

Select the radio button for Execute business logic in the Add Action wizard, as in Figure 11.

Specify AtomFeeds as the name of the class that contains the business logic, as in Figure 12. This is the same name that you gave when you created new business logic, as in Figure 8.

This completes the step-by-step procedure that uses HATS to deliver the Atom feeds of mainframe applications. You then deploy the HATS project to the WebSphere Application Server. To test this project, deploy it in Integrated Test Environment, which comes bundled with the IBM Software Development Platform. The URL in which this application is deployed will be the URL for the feed reader. By default, the URL is typically in the format http://servername/<HATSProjectName>.

Back to top

Using a feed reader to test the output

Give the URL where the HATS application is deployed in the Application Server (see

).

You collect the output "Hello World" from the mainframe application (see Figure 4) and make it into a summary of the Atom feed, as in Figure 14.

Back to top

Conclusion

Delivering data as Atom feeds in mainframes opens a new world of possibilities for enterprise applications. Organizations can use mashup editors to extract data from companies with external or internal feeds and create new applications or information. For example, call centers can take advantage of mashups by passing a calling customer's ZIP code information to Google Maps to identify the location of the customer. This can help the call center employees personalize the conversation by enquiring about the weather from the customer's location, and so on. The delivery of data as Atom feeds in mainframe servers is one of the fundamental building blocks that enables an organization to embrace Web 2.0.

Resources

Learn

• Web feeds: Check out the Wikipedia overview and discussion of the benefits.
  
  
• The Atom Syndication Format: Read the Internet Engineering Task Force's (IETF's) Request for Comments (RFC) for the Atom Syndication Format.
  
  
• Getting to know the Atom Publishing Protocol (James Snell, developerWorks, October 2006): Start with the introductory article of a multi-part series on the Atom Publishing Protocol.
  
  
• HATS Help Documentation: Read a complete overview of HATS.
  
  
• What Is Web 2.0 (Tim O'Reilly, O'Reilly, September 2005): Learn the basics of Web 2.0.
  
  
• Go2Web20.net: Explore this complete Web 2.0 directory contains a listing of the latest Web 2.0 applications and services.
  
  
• Mashups: Check out this Wikipedia article to learn more about mashups.
  
  
• Mashboards: Read more about the concept of mashups.
  
  
• Web 2.0 Goes to Work: Learn more about the IBM Web 2.0 initiatives.
  
  
• IBM XML certification: Find out how you can become an IBM-Certified Developer in XML and related technologies.
  
  
• XML technical library: See the developerWorks XML Zone for a wide range of technical articles and tips, tutorials, standards, and IBM Redbooks.
  
  
• developerWorks technical events and webcasts: Stay current with technology in these sessions.
  
  
• The technology bookstore: Browse for books on these and other technical topics.
  
  

Get products and technologies

• Rational Application Developer for WebSphere v7.0: Get your hands on the evaluation version.
  
  
• WebSphere Host Access Transformation Services Toolkit V7.0: Download and try the evaluation version.
  
  
• Apache Abdera: Download the Apache Abdera libraries and read an overview of its implementation.
  
  
• IBM Mashup Starter Kit: Find an easy-to-use Web 2.0 mashup platform for enterprises and small businesses.
  
  
• IBM trial software: Build your next development project with trial software available for download directly from developerWorks.
  
  

Discuss

• Participate in the discussion forum.
  
  
• XML zone discussion forums: Participate in any of several XML-related discussions.
  
  
• developerWorks XML zone: Share your thoughts: After you read this article, post your comments and thoughts in this forum. The XML zone editors moderate the forum and welcome your input.
  
  
• developerWorks blogs: Check out these blogs and get involved in the developerWorks community.
  
  

About the authors

Ramakrishnan Kannan works on host integration at IBM India Software Labs in Bangalore, India. He has been a developer for IBM personal communications and communication servers products. In addition to his development work, he works with customers in the IBM Asia-Pacific region for the Web service enablement of host applications. He has conducted Web services awareness sessions to business partners such as Infosys. He is an IBM Certified Solution Developer for XML and a Sun Certified Java Professional. His interests are host integration, distributed computing, service-oriented architecture (SOA), and networking. For more information, visit his home page.

Prasad K. Nagaraj works on host integration at IBM India Software Labs in Bangalore, India. He is a developer for IBM WebSphere Host On-Demand. Apart from his regular work, he works with customers for WebSphere Host Access Transformation Services. He's an expert in Java, Unified Modeling Language (UML), Java Platform, Enterprise Edition (Java EE), and Web services. His interests are in Web 2.0 technologies and solving puzzles. He has great passion for international films, travel, and music.

Saikrishna Vaidyanathan has worked with IBM India Software Labs since January 2005. He worked with Polaris Software Lab Ltd. before joining IBM. He holds an MCA degree from Bharathidasan University. Currently he is working on WebSphere Host On-Demand, a Java-based terminal emulator for hosts from IBM. He has wide engineering experience from design to development and deployment. He has assisted many customers by developing proofs of concept to demonstrate technologies and has been actively involved during the deployment of his products. Apart from his regular work, he is interested in contributing to SOA and Web 2.0 technologies. His focus also lies in the engineering aspects of life sciences. He has a great interest in teaching.

Rate this article

Comments

Back to top

Table of contents

• Overview of the solution
• Identifying a business process and recording a macro
• Customizing the screen to trigger the business logic
• Using a feed reader to test the output
• Conclusion
• Resources
• About the authors
• Comments

Next steps from IBM

• Try: Host Access Transformation Services Toolkit
• Briefing: Building SOA solutions and managing the service lifecycle
• Buy: Host Access Transformation Services Toolkit

Dig deeper into XML on developerWorks

Try IBM PureSystems. No charge.

Experience today!

---

Get started with the cloud-based trial and pattern development kit.

Special offers