Instant 6530 Host Access from a Browser over HTTP(s)

The design and implementation of CAIL Studio is layered, logical, and very visual. It leverages existing Telnet Scobol Software (and Guardian Server Classes) and forwards the benefits of all that software to world of Browsers and Web Services.

CAIL Studio provides very fast 6530 web based access through the Tandem6530HTMLSvlt.war (a.k.a. the CAIL Studio Servlet) - Anyone with a Tomcat or NSJSP manager account can install this War File in seconds and can securely and immediately use the software for NonStop Telnet access from any browser anywhere in the network to access Nonstop 6530 sessions using just a Browser.

Not only is this facility instantly available, but it brings the users of it one huge step closer to compliance with fantastic logging of all sessions in human readable HTML log files.

This facility does not impact the NonStop Host in any way, and may be installed on Tomcat in a secured intermediary computer if desired. (note: the files in the .war can be repackaged for use in WebSphere-IBM or WebLogic-BEA if those environments are preferable to the implementation of CAIL Studio.)

For Block Mode 6530 access, this facility provides the whole interactive screen identically to a terminal emulator (some unusual Block mode programs with continuous field updates are not applicable such as Viewsys).

99.9% of all host software will be easily accessed through this instant implementation of unmodified CAIL Studio, and the HTTP access method can be secure if Tomcat is set up with SSL and if the CAIL Studio Servlet is accessed on a secure port.

The Browser session pages have been created so that Function Keys operate as they would in a regular emulator even though it is operating in a browser without any downloaded controls. In this way, users familiar with existing systems need very little acclimatization to get going right away. In most cases it will make sense to switch to using this mode of access altogether, since it alleviates the need of securing Telnet.

For each session of each user (and a single user may have multiple simultaneous sessions) a separate HTML log is kept in the Tomcat/NSJSP Log directory for later examination by the Manager or Auditor.

The HTML logs are useful for many purposes, not least of which is Audit trail of all transactions through this software. When A Manager or Auditor looks at one of these log files using a browser (the log files are not publicly available on the network - manager access is required) they can see every screen that a user received as well as every field value they sent to the Application on the Host.

The Log is also indispensable for development of custom applications, and Mashups as well as Axis2 Web Services, since it holds the record of all fields in all screens and it carries the full complement of essential field values to change from screen to screen.

The beauty of CAIL Studio is that the modular pieces of it are flexibly available to the system administrator, and the facility without any modification can be used by operators who have used 6530 access software without any training and without any software downloads. Since it fits within the HTTP layer, secure communication can be provided on a safely encrypted port, keeping the system secure from spoofing or sniffing.

Note: since it is extensively based upon HTML, clever administrators can create portals to guide access by modifying the login page and hiding or adding fields to it.

How to Install CAIL Studio on your Web Server

The following steps are taken to install CAIL Studio on NonStop, and on Regular Tomcat.

To load or manage an existing web application it is necessary to launch the Tomcat Manager

Of Course you need a password to get in

On NSJSP, this page is nearly identical, and all steps for installation are identical with both variations of Tomcat.

Use the Browse function in the manager web page to select the appropriate War file on your PC to upload and deploy as the new application

After Deploying the Application you will see it listed among your web applications, and you can click that with your browser to launch the application

The address highlighted in the browser below can be published in a
generally available web page or it can be emailed to people and favorited in order
to have 6530 access using an ordinary browser. At this point your software is installed
and it should be fully operational.

(note: in the case below, localhost was used, 127.0.0.1 - that is actually not one to publish, but the external address of the server is publishable)

The next few screens are just to check that everything is operating normally.
First the user types in the IP address or web name of the Host.
(note: if the NSJSP or Tomcat server is Secured all HTML will be encrypted)
This page can be easily modified by the manager of the website.

Conversational Screens are OK

Block Mode screens are OK

Now the Browser based session can be used to operate any Host based SCOBOL software over HTTP(s) normally as if using an emulator.

---

Special Considerations

Two varieties of the CAIL Studio Access Servlet are provided, the Faster one (the Tandem6530HTMLSvlt.war) has a lot of the HTML hard coded in it, and it saves time by not going through an XSLT transform, It can realistically be deployed as an alternate to Telnet access to most 6530 applications.

The slower one, (Tandem6530Svlt.war) uses "screen.xsl" as a guide to the creation of web page screens which virtualizes button display and script etc. for Internationalization and special applications. CAIL can work with the customer to refine their needs at this level and then prepare a dedicated Servlet for higher speed generic 6530 access in localized language environments if required such as for BIDI environments.

Both versions now use script to implement normal Function Key behavior in all screens, and to prevent software errors that could occurr from double striking a key at a critical point.

---

Using the Logs in Development of new applications

People can begin to use CAIL Studio for simple NonStop Host Access over HTTP, and developers can start to develop new web applications derived from mashups of 6530 screens and other requirements. For this the developer needs to access the Log files from the Tomcat log directory of sessions that visit the essential screens in a natural fashion. The CAIL Studio Wizard is used to analyse logs files as depicted below.

Using this Tool it is easy to determine what kinds of Ajax Calls to embed in your script when creating CAIL Studio HTML GUI Applications.

---

New Web Applications on the Server

In CAIL Studio The HTML GUI Application is literally a named directory containing a series of web pages which your users can access through a browser. Typically they are Frames based with one of the frames encompassing Javascript logic and using Ajax to supplant direct browser communication with the CAIL Studio Servlet.

You can see that all of the files are situated in a directory that is subtended from the servlet home directory. Realistically they could be placed anywhere on any public webserver, but this location is easy and convenient and it simplifies the standard Ajax JavaScript.

To develop the application, We reccommend (and supply and example of) using a Frames based Web page system in which the Host pages are Fetched by Ajax and displayed for confirmation. Also, as you can see in this example, we use a center panel with debug statements emitted to keep track of what is happenning.

For release of one of these web Apps we Collapse the Frame system and define "ViewDebug=false" in our script. The above directory has both release and debug versions of all web pages in it.

Below we illustrate what it is like to work in an interactive Ajax based development environment:

In the new GUI Application only the left panel will be made visible; while several host screens will still be navigated in the background using Ajax, only a few important simplified screens can be shown to the user.

---

Some Thoughts on Web Services and Mashups

How to Consider Applicability.

Obvious needs for new GUI's : NonStop access via the reduced function tiny screens of palmtops; or NonStop application access with multiple screen aggregation from several host screens or even different host apps (even on different hosts); or Nonstop access that simplifies complex login screens or which hides areas of software that are confusing to new users, or to prevent unauthorized access.

Some uses are not obvious to start such as aggregation of multiple apps or hosts, or creation of WebServices out of an aggregated application screen.

In certain existing workflow situations, various established Host Applications will be accessed by a number of employees. Some of the employees may have complained that the software is too complex or a manager may be annoyed that the workers learn it slowly compared to modern web applications. Some repetitive work may be performed or checked by other employees using email or telephone communication and networking which can produce a noticeable bottle neck in the work flow.

By introducing CAIL Studio in the middle of the environment, Screens of each Host Application can be aggregated and reformatted without changing any of the underlying Host application logic, all unmodified data is preserved as well. The new face of the software will be easier to operate and learn by being in the simplified web metaphor which can hide arcane fields and strange function key sequences that are advised on the screens. Likely fewer staff will be required to achieve the same amount of work.

Screens of two or more Host Applications can be aggregated and reformatted without changing any of the underlying logic, and without necessitating as much human networking. In the scenario depicted above, 2 telnet sessions are used - to each host. It might be considered less than optimal that each employee is using a session on each Host, especially if the access to one of the applications is very repetitive.

For repetitive tasks, some Host Applications can be converted into WebServices, this will re-use the connection to the host for applications that can be shared. In the above case we depict the same activity as Figure 4, but the number of connections to host are reduced to only what is needed. Indeed the Web Service is now available for consumers that are outside of the pre-established working context. Note: any set of aggregated screens could be considered as a candidate for a WebService, introducing SOA as a logical step in leveraging Existing architectures and Host Applications.

When an application is to be pooled in this way to make a WebService, the System administrator will access the app using a web page from CAIL Studio thus initiating the telnet session. Then the pool button will be pressed (at the appropriate screen to be offered as the service - there will be one which was specifically designed to bring all the functions together to offer as a WebService). The browser session can then be closed without exiting the CAIL Studio App: as a host session it will persist. If the session might be subject to Host disconnect for inactivity, the CAIL Pool Manager can be used to issue the appropriate keep-alive request into CAIL Studio on behalf of Pooled sessions that have been unused in a period of time. If the usage is likely to be bursty, intermittently busy, more than one session can be pooled to be used by a WebService.

CAIL Studio System Architecture illustrates how a ordinary PC based emulator access can be leveraged non-intrusively to Web Browser access, Ajax Access, and Web Services as well.

CAIL Studio communicates with the NonStop over telnet and delivers screen for screen HTML screens to a user and to the logs. Note when the user visits a Host Application a log is automatically produced, and that log can later be used as a surrogate host in an offline situation or fro remote development.

This provides the most non-intrusive way to develop and debug new applications for NonStop Hosts.

Pooled sessions can be picked up by Custom WebServices and can be maintained by the Pool Manager or directly by the system administrator.

For completely remote (non-intrusive) development and testing situations, A Pagelet servlet delivers the pages from a logged session to the CAIL Studio Ajax Web based development environment.

Extended CAIL System Architecture

Introducing TMF and Server Class Transactions

Extended CAIL Studio Architecture provides a Socket based XMLRPC, for direct access to TMF transactions and Guardian Server Classes.

Using the sample java code provided with the package, you can access the CAIL Guardian TMF facility if you need to leverage direct Guardian data and processing without accessing any existing Telnet/SCOBOL.

---

Web Services

For Axis2 web services a Java class is created with similar input as the HTML GUI application, and all of the Ajax calls are made using java functions with this type of code instead of the Ajax javascript

URL url = new URL(address);

URLConnection connection = url.openConnection();

connection.setDoOutput(true);

InputStream stream = connection.getInputStream();

BufferedInputStream in = new BufferedInputStream(stream);

CAIL reccommends first developing a robust HTML GUI application prior to creating a web service so that the Javascript will be smart enough to handle all eventualities. then simply translate the javascript to Java and away you go!. Eclipse creates a WSDL and an aar file in 2 easy passes.

---

Deeper Integration

The Core Libraries of CAIL Studio in particular the Host Access Session Objects can be accessed by Java Programmers; this requires advanced Java Proficiency and can also be done in conjunction with the simpler process. Using the CAIL Libraries, companies can bypass the HTML layer altogether if they so desire.