Elastic COBOL Getting Started

2013 Heirloom Computing Inc
All Rights Reserved

i
Elastic COBOL Enterprise Developer
Getting Started Guide

REVISION: OCTOBER 2013

The contents of this manual may be revised without prior notice. No part of this
document may be reproduced or transmitted in any form or by any means,
electronic or mechanical, for any purpose, without the expressed written
permission of Heirloom Computing Inc.

Heirloom Computing has made every effort to ensure that this manual is correct
and accurate, but reserves the right to make changes without notice at its sole
discretion at any time.

Elastic COBOL Getting Started Guide 1
Contents
GENERAL INFORMATION ............................................................................................................................... 3
PURPOSE ............................................................................................................................................................. 3
PREFACE ............................................................................................................................................................. 3
TRADEMARKS ..................................................................................................................................................... 3
INTEGRATED DEVELOPMENT ENVIRONMENT ........................................................................................ 4
INSTALLING & STARTING THE ELASTIC COBOL IDE ......................................................................................... 4
Elastic COBOL Requirements (READ ME) .................................................................................................. 4
Licensing ....................................................................................................................................................... 4
Eclipse Perspectives ...................................................................................................................................... 5
Using this Guide ............................................................................................................................................ 5
Cloud (Hosted) .............................................................................................................................................. 5
Windows & Linux/UNIX (Open Systems) ...................................................................................................... 6
Starting the Elastic COBOL IDE for the first time ........................................................................................ 7
INTRODUCTION .................................................................................................................................................. 7
ELASTIC COBOL TOOLBAR ............................................................................................................................... 8
CREATING A NEW ELASTIC COBOL PROJECT .................................................................................................... 9
GENERAL PROJECT PROPERTIES ....................................................................................................................... 10
COBOL Compiler Settings .......................................................................................................................... 10
COBOL Execution Settings ......................................................................................................................... 11
MANAGING APPLICATION ARTIFACTS ............................................................................................................... 11
Creating a New Program ............................................................................................................................ 11
Adding Existing Artifacts to a Project ......................................................................................................... 12
EDITING, COMPILING AND RUNNING A PROJECT ............................................................................................... 13
Incremental Compilation ............................................................................................................................. 13
Compilation Messages ................................................................................................................................ 13
Program Execution ..................................................................................................................................... 14
ELASTIC COBOL FILE AND RECORD SERVERS ................................................................................................. 15
DEBUGGING IN ELASTIC COBOL ............................................................................................................... 16
DEBUG OVERVIEW ........................................................................................................................................... 16
SETTING BREAKPOINTS ..................................................................................................................................... 16
STARTING A DEBUG SESSION ............................................................................................................................ 16
USING THE DEBUGGER ..................................................................................................................................... 18
VARIABLES VIEW ............................................................................................................................................. 18
QUERY VARIABLES VIA HOVER OVER .............................................................................................................. 19
BREAKPOINTS VIEW ......................................................................................................................................... 19
DEBUGGING COMPOSITE APPLICATIONS ........................................................................................................... 20
REMOTE DEBUGGING ....................................................................................................................................... 21
APPLICATION DEPLOYMENT ...................................................................................................................... 25
DEPLOYMENT OVERVIEW ................................................................................................................................. 25
JAVA RUNTIME ENVIRONMENT (JRE) .............................................................................................................. 25
USING THE EXPORT (DEPLOY) WIZARDS .......................................................................................................... 26
STANDALONE APPLICATIONS ............................................................................................................................ 30
Console Command Line .............................................................................................................................. 30
INSTALLING ADDITIONAL SOFTWARE ............................................................................................................... 30
SERVLET APPLICATIONS ................................................................................................................................... 33
Building a Servlet Application .................................................................................................................... 33

Packaging & Deploying Servlet Applications ............................................................................................. 35
Executing Servlet Applications .................................................................................................................... 37
Debugging Servlet Applications .................................................................................................................. 38
Iterative Debugging, Development & Deployment ..................................................................................... 42
CICS APPLICATIONS ..................................................................................................................................... 43
OVERVIEW ........................................................................................................................................................ 43
CREATING A CICS COBOL PROJECT ............................................................................................................... 43
Additional Software Requirements .............................................................................................................. 43
Setting up the Application Server ................................................................................................................ 44
Creating an ETP Project Part 1 Application Project ............................................................................ 46
Data Migration (VSAM to Relational) ........................................................................................................ 49
Resolving Port Conflict ............................................................................................................................... 52
Setting up the Relational Database ............................................................................................................. 53
Creating an ETP Project Part 2 Deployment Project ........................................................................... 55
Deploying an ETP Project .......................................................................................................................... 57
Executing an ETP Application .................................................................................................................... 59

General Information
Purpose
The purpose of this Getting Started Guide is to provide you with a level of
familiarization that enables you to be immediately productive with the Elastic COBOL
toolset.
This guide will cover the most commonly used functions that represent the simple
application development lifecycle of edit, compile & debug. It will also provide an
overview of the various deployment options for executing your application.
Preface
Elastic COBOL is a feature rich implementation for any developer working with
enterprise, commercial or educational COBOL applications.
The Elastic COBOL Integrated Development Environment (IDE) is based on the
industry-leading Eclipse platform. Eclipse offers developers a truly extensible and
configurable toolset that provides a consistent experience on multiple platforms,
seamless support for multiple languages, and a powerful support community.
Elastic COBOL compiles applications so that they execute natively within a Java
runtime environment. This means your COBOL applications can immediately
leverage the benefits of this proven enterprise platform, such as additional libraries,
portability, performance, scalability & system management.
Trademarks
IBM is a registered trademark of International Business Machines Inc.
Oracle and Java are registered trademarks of Oracle and/or its affiliates.
UNIX is a registered trademark licensed exclusively to X/Open Company
Limited.
Linux is a registered trademark of Linus Torvalds.
Windows is a registered trademark of Microsoft Corporation.
Eclipse is a trademark of the Eclipse Foundation Inc.
Other names may be trademarks of their respective owners.

Integrated Development Environment
The Elastic COBOL Integrated Development Environment (IDE) is the graphical
framework used by Elastic COBOL programmers to edit, compile, debug, deploy and
execute programs. The Elastic COBOL IDE has been developed by Heirloom
Computing based on the IBM Eclipse Platform.
Installing & Starting the Elastic COBOL IDE
Elastic COBOL Requirements (READ ME)
If you intend to install Elastic COBOL on your machine, you must install the Java
Development Kit (JDK) before you install Elastic COBOL.
NOTE: If you have a 32-bit version of Elastic COBOL, you must install a 32-bit JDK.
If you have a 64-bit version of Elastic COBOL, you must install a 64-bit JDK.
Select the JDK Standard Edition from:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Download and install the JDK for your system. The JDK also includes a copy of the
Java Runtime Environment (JRE) which is used by both the Eclipse Platform and
Elastic COBOL applications.
The recommended Eclipse Platform for Elastic COBOL is the Indigo (or later)
distribution of the Eclipse IDE for Java EE Developers and can be found here:
http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/indigor
This (or a later version) is already included in the Elastic COBOL product download,
and also in the hosted version in the cloud.
Licensing
Elastic COBOL is protected by a cloud-based licensing mechanism. This means that
periodically (dependent on your subscription type), you must have an active network
connection for the product to continue to operate.
Because the licensing mechanism resides in the cloud, this means that it is not
necessary to install any licensing software on your installation machine.
When you purchase a subscription to download Elastic COBOL, you will be provided
with a file called elasticcobol.properties. This file must be placed in the users home
directory. e.g. C:\users\elastic.bot\elasticcobol.properties (or
/usr/elastic.bot/elasticcobol.properties on Linux/UNIX).

Eclipse Perspectives
Elastic COBOL is installed as a plugin of the Eclipse Platform. As such it creates an
Elastic COBOL perspective, which is a visual container for a set of views and
editors. The Eclipse Platform supports many different perspectives for different
tasks, and Elastic COBOL can be used to seamlessly interoperate with different
perspectives when building composite applications (e.g. a web application consisting
of a browser interface and a COBOL server).
Using this Guide
Within each section, there are a set of suggested actions that you should take to get
the most from the content. These actions are identified as:
Perform the action described in this text.
Alternatively, perform this action described in this text.
Cloud (Hosted)
Sign in to the management portal at:
https://www.elasticcobol.com/index.php/sign-in
If instance is not on, click Power On for the instance you want to start.
Click Connect on the instance you want to activate.
Enter your credentials. These are the same as your management portal
credentials.

Click OK and you will see the Elastic COBOL product banner which will
then proceed to load the Elastic COBOL IDE.

Windows & Linux/UNIX (Open Systems)
There are 2 ways to install Elastic COBOL on Open Systems. You can select your
preferred method for installation via the product package that you downloaded.
You can choose to install your product as:
A full install which contains the Eclipse Platform and the Elastic COBOL IDE.
This is best if you do not already have the required Eclipse Platform installed
on your machine, or if you want to create an Eclipse install that is isolated
from any other Eclipse installation.
A plugin install (over the network) which contains just the Elastic COBOL
IDE. This is best if you intend to install Elastic COBOL into an existing
Eclipse installation (please ensure your Eclipse installation meets the
requirements of Elastic COBOL).

Full Install
Open the ecobol-YY.MM.DD-[win|lnx]-[x86|x86_64].zip file and extract the
contents to a folder location of your choice on your computer (e.g.
C:\elasticcobol on Windows, or /usr/share/elasticcobol on Linux/UNIX).
You can start the IDE by simply running the eclipse executable in your
elasticcobol folder. You may prefer to create a shortcut to the eclipse
executable and use that to load the Elastic COBOL IDE.

Plugin Install
Load your existing Eclipse IDE.
Select Help Install New Software from the IDE menu.
Enter http://elasticcobol.com/downloads/updates in the Work with: text-
box and click Add.
Select Heirloom Elastic COBOL Developer products on the Available
Software dialog and click Next.
Click Next on the Install Details dialog.
On the Review Licenses dialog, select I accept the terms of the license
agreements and click Finish.
If a Security Warning about unsigned content appears, click OK.
Click Restart Now on the Software Updates dialog.

Starting the Elastic COBOL IDE for the first time
NOTE: If you are using the cloud version of the IDE, your IDE is already pre-
configured and your default workspace will contain pre-loaded samples. To follow
this guide, switch to a new workspace (File Switch Workspace Other).
Your installation of Elastic COBOL is now complete. To start the Elastic COBOL
perspective, follow these steps in the Eclipse IDE:
Start the Eclipse IDE.
If you are asked to select a workspace, do so, and click OK.
D:\workspace is used as the default workspace reference in this manual

The Eclipse Platform supports multiple workspaces. You can easily switch between
workspaces when you start Eclipse, or via the File Switch Workspace menu
inside Eclipse.
If displayed, close the Welcome page by clicking on the tab.
Select Window Open Perspective Other from the IDE menu.
Select Elastic COBOL in the Open Perspective dialog and click OK.
Introduction
The Eclipse Platform is highly configurable and supports multiple views (windows) in
multiple configurations. This manual will describe and refer to only the default views
and configuration, but you can easily customize your environment based on your
own requirements and preferences.


Once loaded, the Elastic COBOL IDE will look very similar to the above image.
The Navigator view displays your workspace. It is currently empty because no
projects have been created.
The Editor view is activated when a project artifact is loaded for editing.
The Problems view lists any warnings or errors produced by compiling the
projects in your workspace will be displayed here.
Elastic COBOL Toolbar

The Elastic COBOL IDE has a number of primary actions incorporated as
toolbar icons. From left to right, these are:
Create a COBOL Project
Create a COBOL Program
Create an Elastic Transaction Platform Project
Initiate a Debug Session
Run an application

Creating a New Elastic COBOL Project
A project is a collection of artifacts that are developed to create a functional
application.
The sample program used in this section of the manual consists of 2 artifacts 1
COBOL program and 1 Java program. The application function consists of the
COBOL program calling the Java program with a set of parameters.
On the toolbar, click to create a new COBOL project. You can also
access this function via the File New COBOL Project menu.
Name the project by entering co2ja as the project name.
In the Project type pane, expand Samples, select COBOL calling Java
and click Finish.

The Navigator view now contains the co2ja project.

General Project Properties
The co2ja project can be run immediately with the default set of project properties.
Project properties by default are global in nature but program specific properties can
be also set as local so that they only apply to individual program modules. Program
specific properties can be very helpful in those instances where a particular or
unique compiler characteristic must be set.
To access the project properties, right-click on the root of the co2ja project
tree and then select Properties from the context menu.
COBOL Compiler Settings
Select COBOL Compiler Settings.

The Cobol Compiler Settings define the parameters to be used by the Elastic
COBOL compiler during program compilation. By selecting Category you can
review & modify all the different types of compiler options that can be set from this
dialog.

COBOL Execution Settings
Select COBOL Runtime Settings.

The COBOL Runtime Settings are a set of configuration parameters that change
execution characteristics of all application modules in a particular project. For
example, you can change the color and font used for applications that use the
character console.
It is also possible to set these configuration parameters on an individual program
basis via the Run Run Configurations menu. After selecting the COBOL
program, select the Runtime tab and uncheck the Use global runtime execution
settings.
Click OK to close the Properties dialog.
Managing Application Artifacts
Creating a New Program
New program units for your project can be created by selecting your project in the
Navigator view and then clicking on the toolbar.


A template can be specified that will provide an initial coding structure. You can also
choose your source code format preference (fixed, free or variable).
Adding Existing Artifacts to a Project
Additional artifacts can be added to a project by using the Import Wizard and
specifying the program identifier information. Alternatively, you can simply drag &
drop them into the appropriate folder in the Navigator view.

Editing, Compiling and Running a Project
Incremental Compilation
The Elastic COBOL IDE will incrementally compile your project when the project, or
changes to the project artifacts, are saved. This enables your project to be in a
current state during its development lifecycle.
The incremental compile feature can be disabled by via the Windows
Preferences menu. On the resulting dialog, you can then deselect Build
automatically. If deselected, all project builds must be initiated manually.

Compilation Messages
In the Navigator view, expand co2ja and expand cobol_source.
Right-click on calljava.cbl, and select Open on the context menu.
Enter tmp in the calljava.cbl Editor view and click to save.


During compilation, which generally occurs automatically (unless unset in the
preferences as above) upon any file import or modification, the compiler may
generate error messages with one of three severity levels (error, warning &
information). These messages will be listed in the Problems view.
To correct an error, click on the relevant message in the Problems view. If
possible, the editor will be positioned at the error. Any changes that are saved are
recompiled and the Problems view is refreshed with the results.
Move the cursor in the calljava.cbl Editor view to a different line than where
the error is.
In the Problem view, expand Errors (1 item), right-click on the error
(Identifier not declared) and select Go To. This repositions the cursor on
the line immediately after the error.
Delete tmp from the source file and click on the toolbar to save.
Program Execution
In the Navigator view, expand java_source and double-click
ShowParams.java to open the program file.
Click the calljava.cbl editor tab in the Editor view to switch focus back
to the COBOL program.

In the Navigator view, right-click on calljava.cbl and select Run As
COBOL Application.
Alternatively you can execute the program by selecting calljava.cbl in
the Navigator view and clicking on the toolbar.

Any console output from the executing application will be displayed in the Console
view, which will be automatically activated.
Elastic COBOL File and Record Servers
The Elastic COBOL File Server provides access to files on the host server when the
execution environment is implicitly constrained. For development & testing, the File
Server can be started within the Elastic COBOL IDE via the Tools Start File
Server menu.
The Elastic COBOL Record Server provides record locking for indexed files. This
can also be started within the Elastic COBOL IDE via the Tools Start Record
Server menu.

Debugging in Elastic COBOL
Elastic COBOL applications may be deployed across a broad range of systems, and
the Elastic COBOL debugger supports local and remote debugging scenarios,
including the debugging of applications deployed under a web application server.
Debug Overview
Application debugging provides a source level debug capability in the programming
language that the application was written. The Elastic COBOL debugger displays
COBOL source statements and COBOL variables. The debugger allows you to step
through the program (from COBOL statement to the next COBOL statement) and
examine the contents of COBOL data items.
Setting Breakpoints
Move the cursor in the calljava.cbl Editor view to the line with the last
statement of the program.
Double-click the line in the
left most column. The
appearance of a blue circle
confirms the breakpoint has
been set.
Click the ShowParams.java editor tab in the Editor view to switch
focus to the Java program.
Enter Ctrl + F to invoke the Find/Replace tool, and enter return new in
the Find: text-box, followed by clicking Find. Click Close.
Double-click the found line in the
left most column. The appearance
of a blue circle confirms the
breakpoint has been set.
Starting a Debug Session
Elastic COBOL applications are always ready to be debugged. You do not need to
specify any compiler or runtime parameters for your application.
In the Navigator view, right-click on calljava.cbl and select Debug As
COBOL Application.
Alternatively, you can select the pull-down menu from the toolbar and
select calljava.cbl.
Click Yes on the Confirm Perspective Switch dialog. You also have the
option to remember this selection if you do not want to see this dialog again.


Once loaded, the Elastic COBOL debug perspective will look very similar to the
above image.
The Debug view is where you control the stepping and execution of your
application. It displays the stack frame for the suspended threads for each target
you are debugging. Each thread in your application appears as a node in the
tree.
The Variables view displays information associated with the stack frame
selected in the Debug view. Variables can be selected to have more
information displayed. The Breakpoints view can be selected to list all the
breakpoints that you currently have set in your workspace.
You can use the Editor view in the same way as you would in the Elastic
COBOL perspective.
The Console view is where any character system output from the executing
application is displayed.

Using the Debugger
The primary controls for the debugger can be found on top of the
Debug view. Each of these primary controls act against the currently
selected stack frame. For example, the current stack frame in the picture
below is calljava: MAIN-PARAGRAPH.

Resume (F8)
Terminate Debug (Ctrl + F2)
Step Into (F5)
Step Over (F6)
Reset debugging at start
Use step filtering
Variables View
The Variables view provides a structured display of any variables used within the
COBOL program that is being debugged. Selecting a variable in this view will display
its contents & formatting information.
In the Variables view, expand this & then expand wrk, and select
item_1_OF_param_3 (this is the 05 item-1 data item of the 01 param-3
group data item).

Query Variables via Hover Over
The contents of variables can be immediately shown by hovering the mouse pointer
over the variable. If you want to see the content of a specific item in an array or a
non-unique variable name in a group (e.g. ITEM1 OF GROUP2), first select the
construct and then hover over it.

Breakpoints View
Select the Breakpoints tab to display the view.
The Breakpoints view will list all of the breakpoints that are set in the workspace.
In other words, breakpoints from all applications are listed, not just the ones from the
application stack frame that is currently being debugged.

You can activate/deactivate the breakpoints for the debugging session by toggling
the check-box.

Debugging Composite Applications
Elastic COBOL supports debugging of composite applications within the Eclipse
Platform (for example, COBOL and Java programs). Debugging an application is
done at the source level and will automatically switch between COBOL and Java
source when those statements are executed or a breakpoint is activated.
Click (or F6) a few times to see the execution stepping.
Click (or F8) to resume execution of the application.

The debugger encounters the breakpoint that was set in the Java program
Showparams.java, automatically displays the source code and suspends
execution.
Click (or F8) to once again resume execution of the application.
The debugger encounters the breakpoint that was set in the COBOL
program calljava.cbl, automatically displays the source code, and suspends
execution.
Click (or F8) to once more resume execution of the application.


In the image above the debugger has completed execution of the application. The
<terminated> notification of this appears in the Debug view.
Remote Debugging
With remote debugging you can attach the Elastic COBOL debugger to an
application executing on a different machine over the network. The application
source code needs to be available on the same machine as the debug session, but
the source code does not need to be on the remote machine.
For simplicity, the illustration in this manual will show how to do this on the same
machine via the http://localhost URL (i.e. by establishing a network connection
between 2 processes on the same machine).
To setup an application for remote debugging it is necessary to deploy the
application using the Elastic COBOL Deploy Wizard. Application deployments are
covered in more detail later in this manual, but for now follow these steps:
Switch back to the Elastic COBOL perspective by clicking the Elastic
COBOL button located at the top right of the IDE.
In the Navigator view, right-click on the root of the co2ja project tree and
then select Export from the context menu. In the Export dialog, expand
Elastic COBOL, select Elastic COBOL Deploy Wizard and click Next.

Enter d:\tmp\co2ja.jar (or /tmp/co2ja.jar on Linux/UNIX) in JAR or WAR
file: text-box and click Next.
Click the Run Configuration: pull-down and select calljava.cbl. The Main
Class: area is automatically updated with the main entry point.
The COBOL Deploy Wizard dialog should now look like the image below.
Check Generate script-based application launcher stub and click Finish.

Start a command console on your system and if on Windows, enter d: to
change drive and enter cd \tmp to change directory (or cd /tmp on
Linux/UNIX).
NOTE: If using the cloud version of the IDE, in the Navigator
view, right-click on Other-Tools.html (in the [Welcome]
project), and select Open.
In the Other Tools window, click on Start Command Console.
If it appears, click Yes on the Windows Security Warning
dialog to start Command Console.

Execute the co2ja_debug_remote script. Depending on your system, this
will either have a .bat (Windows) or .sh extension (Linux/UNIX). The
application is now suspended, awaiting a connection from a debugger.
We now need to create a debug configuration to attach the debugger to the
suspended application. In the IDE, select Run Debug Configurations,
and click Remote COBOL Application in the Debug Configurations dialog.
Click on the toolbar to create a new debug configuration.
In the Debug Configurations dialog, enter co2ja in both the Name: text-
box and the Project: text-box. Click Apply.

Click Debug, and click Yes on the Confirm Perspective Switch dialog (if
it appears).
The debugger encounters the first breakpoint that was set in the Java
program Showparams.java, and suspends execution.
Switch back to the command console where the application was launched.
As expected, the output from the application is displayed on this console.
In the IDE click (or F8) to resume execution to the second breakpoint that
was set in the COBOL program, and then click (or F8) again to resume
execution to the end of program. At this point, the execution of your
application in your command console will have completed.

If the application was on a different machine then the address in Host: would be
the host name or IP network address of that machine. As long as there is a network
connection to the machine running the remote application, you can initiate a
debugging session for that application.

Application Deployment
Deployment Overview
Elastic COBOL supports multiple deployment scenarios. Depending on the
application architecture, applications can be packaged for deployment via the
Elastic COBOL Deploy Wizard as:
JAR Java application archive (.jar file)
o These applications are typically loaded and executed directly by the
Java runtime (e.g. from the command line: java -jar myapp.jar).
WAR Web application archive (.war file)
o These applications are typically deployed under the control of a Web
Application Server (such as Apache Tomcat). They are executed via
a URL associated with the Web Application Server.
Or via the Elastic Transaction Platform Deploy Wizard as:
EAR Enterprise application archive (.ear file)
o Used when the application being deployed uses CICS transactions.
o These applications are typically deployed under the control of an
Enterprise Application Server (such as Apache Geronimo). They are
executed via a URL associated with the Enterprise Application Server.
Depending on your requirements you can also choose to create any of the above
package types (manually or via your own custom scripts) without using the wizards.
When using the wizards, the runtime services, as well as any other resources,
required by the application are packaged along with the application itself. The
runtime services are presented as modular packages which you can opt to include
or exclude from the final package (i.e. not all of the runtime services may be
required to execute your application).
Java Runtime Environment (JRE)
Deployed applications require a JRE to execute. The JRE is also commonly referred
to as the Java Virtual Machine (JVM) and provides an execution framework that is
platform independent. The JRE must be installed on the target machine. JREs for
many platforms can be downloaded from here:
http://www.java.com/en/download/index.jsp
If a JRE for your platform is not available from here, you will need to locate it via
your platform (i.e. hardware or operating system) providers website. For JREs from
the java.com website, you can check the version from your command line console
by entering:
java version

You should validate that your application behaves as expected against all of the
JREs and platforms that you want to support, but generally speaking, applications
will run as expected on JREs that have the same (or later) version of the JRE that
you tested your application on (and on any platform assuming that you do not have
platform-specific code in your application).
Using the Export (Deploy) Wizards
On the toolbar, click to create a new COBOL project. Enter screen as
the project name.
In the Project type pane, expand Samples, select Text Screen and
click Finish.
In the Navigator view, click on the triangle for co2ja to collapse the
project view.
Click on the triangle to expand screen, and then expand
cobol_source. Double-click screens.cbl to open it in the Edtior view.

As you can see, it is very easy to work on multiple projects in the Elastic COBOL
IDE. The Navigator view presents a single view of all projects in your workspace.

The screens.cbl application is an example of a simple console application that can
be deployed as a standalone application.
In the Navigator view, right-click on screens.cbl, select Run As and
COBOL Program.
Click on the top-right of the Screens application to close it. By executing
the application we have automatically created a default Run Configuration
that we are going to use in the deployment process.
In the Navigator view, right-click on the root of the screen project and
select Export.

Expand Elastic COBOL, select Elastic COBOL Deploy Wizard, and click
Next.


In the JAR or WAR file: text-box, enter d:\tmp\screen.jar (or
/tmp/screen.jar on Linux/UNIX), and click Next.


By default, the wizard includes all available runtime modules. These will be included
in the executable packages created by the deploy wizard. You can reduce the disk
and memory footprint of your application by excluding runtime modules that you
know are not required.
Click the Run Configuration: pull-down and select screens.cbl. The Main
Select the Other Options: as in the image above, and click Finish.

Depending on the settings selected, the Elastic COBOL Deploy Wizard will
generate scripts and packages that can be used to load & execute the exported
application. For example:
screen.jar can be executed from the command line using java -jar
screen.jar or deployed & executed under a Web Application Server
screen.bat (or screen.sh) can be executed directly from the command line
screen.html can be executed by loading the file from within a browser
screen.war needs to be deployed & executed under a Web Application
Server
screen.ear needs to be deployed & executed under an Enterprise
Application Server
Note that any external files other than application artifacts, such as sequential,
relative, indexed files or databases, will always be separate from the exported
packages.
Standalone Applications
Console Command Line
Start a command console on your system and if on Windows, enter d: to
change drive and enter cd \tmp to change directory (or cd /tmp on
Linux/UNIX). You can find the output of the deploy wizard in this folder.
NOTE: If using the cloud version of the IDE, in the Navigator
view, right-click on Other-Tools.html (in the [Welcome]
project), and select Open.
In the Other Tools window, click on Start Command Console.
If it appears, click Yes on the Windows Security Warning
dialog to start Command Console.
From your command line console, enter screen.bat (or sh screen.sh on
Linux/UNIX) to execute the application.
Alternatively, you can execute the application by entering java -
jar screens.jar.
Enter some data and hit enter to exit.
Installing Additional Software
One of the major benefits of the Eclipse Platform is the availability of additional
plugins that can significantly enhance your productivity as a developer. This is a list
of suggested plugins that you may want to install to enhance the functionality of the
Elastic COBOL IDE:
Apache Tomcat
o Description: An open source web application server implementation of
Java Servlet and JavaServer Pages.

o Relevance: Elastic COBOL applications can run as servlets, deployed
under a web application server. Apache Tomcat integrates with the
Eclipse Platform to provide a very fast & easy to use server for
developing web applications in Elastic COBOL.
o Location: http://tomcat.apache.org
NOTE: If you are using the cloud version of the IDE, this step has already been done
for you and you can move to the next section (Servlet Applications).
Download and install Apache Tomcat from http://tomcat.apache.org
follow the instructions on the website for your platform.
In the Eclipse IDE, select File New Other from the IDE menu.
In the Select a wizard dialog, expand Server, select Server and click
Next.

In the Define a New Server dialog, expand Apache, select Tomcat v7.0
Server (or other version), and click Next.


In the Tomcat Server dialog, click Browse, select the root directory of
your Tomcat installation, and click OK.
Click Finish. The Apache Tomcat server configuration can verified by
expanding Servers in the Navigator view.
In the IDE, select Window Show View Other.
In the Show View dialog, expand Server, select Servers, and click
OK.
In the Servers view, right-click on Tomcat v7.0 Server at localhost
[Stopped] and click Open.
In the Editor view, select Use Tomcat installation under the Server
Locations area, and click on the toolbar to save. This configuration,
which should be for application development only, enables tight integration
between Elastic COBOL projects and the Apache Tomcat web application
server.


Servlet Applications
A servlet is a Java application that executes on the server side of the network.
Servlets extend the capability of the web application server and are accessed via a
request-response programming model (very similar in concept to the pseudo-
conversational model employed by CICS transactions).
The sample program used in this section of the manual uses an HTML page to pass
information to a COBOL servlet running under a web application server. The COBOL
program then stores the data in a relative file and also generates an HTML page
confirming the registration details.
Building a Servlet Application
On the toolbar, click to create a new COBOL project. Name the project by
entering register as the project name. In the Project type pane, expand
Samples, select Servlet Register and click Finish.
In the Navigator view, click on the triangle for screen to collapse the
project view.
Click on the triangle to expand register, and then expand resources.
Right-click register.html, select Open With Web Browser


Any project artifacts contained in the resources folder will be included in the
deployment packages created by the Elastic COBOL Deploy Wizard.
Edit the HTML file by right-clicking on register.html in the Navigator
view and selecting Open With Web Page Editor.
Enter My in the Editor view for register.html and click to save.
Click on the Servers view to start Apache Tomcat.


Packaging & Deploying Servlet Applications
A requirement of using the Elastic COBOL Deploy Wizard is for the project
to be deployed to have a valid Run Configuration. Running an application
will automatically create one, but in this example we will create it manually as
there may be scenarios where you want to do this. In the Navigator view,
click the root of the register project and then select Run As Run
Configurations from the IDE menu.
In the Run Configurations dialog, select COBOL Application in the left
pane and then click on the toolbar to create a new Run Configuration.
Enter register.cbl in the Name: text-box.
The Project: text-box should already identify the register project, so to
identify the Main program, click on the Search button, select
register (default package) and click OK.
Click Apply and then click Close.
In the Navigator view, right-click on the root of the register project, and
select Export.
In the Export dialog, select Elastic COBOL Elastic COBOL Deploy
Wizard and click Next.

In the JAR or WAR file: text-box, enter the location of your Tomcat server
deployment folder C:\Program Files\Apache Software Foundation\Tomcat
7.0\webapps\register.war (or C:\tomcat7\webapps\register.war if using
the cloud version of the IDE, or /usr/share/tomcat7/webapps/register.war
on Linux/UNIX), and click Next.
Click the Run Configuration: pull-down and select register.cbl. The Main

Select the Other Options: as in the image above, and click Finish.
Because we deployed directly into the Apache Tomcat deployment folder, the
web application server will automatically deploy the register.war package.
When this is done the Elastic COBOL IDE will automatically switch to the
Console view to display the deployment message from Apache Tomcat.

In the Console view, click both of Show Console When Standard
Out Changes and Show Console When Standard Error Changes to
deselect them. This will now stop the Elastic COBOL IDE switching to the
Console view when something displays a message to standard-out or
standard-error.

Executing Servlet Applications
In the Editor view, select the Elastic COBOL Registration Sample web
browser tab.
In the web browsers address bar, enter
http://localhost:8080/register/register.html. Because the web browser
already had a copy of the form loaded from the local file system, it may
appear that nothing much happened, but the form now displayed was loaded
from the servlet application deployed under the web application server.
Fill out the form. The fields that are identified in bold are required.
Click the Register Software button on the form.


Debugging Servlet Applications
Debugging a servlet application running under the web application server requires the
configuration of a remote debugging session to be set up between the application
and the server.
In the Console view, click to terminate Apache Tomcat. The IDE will
automatically switch to the Servers view to confirm that the server has
terminated.
In the Servers view, select Tomcat v7.0 Server at localhost [Stopped,
Synchronized] and press F3. This will open the configuration page.
In the Editor view, click Open launch configuration (under the General
Information tab).
In the Edit Configuration dialog, select the (x)= Arguments tab.
In the VM arguments panel, enter -Xdebug -
Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n, and
click OK.


Click on the Servers view to restart Apache Tomcat.
The web application server is now configured for remote debugging. We now
need to configure the application side of the debugging session. In the
Navigator view, expand register and cobol_source. Double-click
register.cbl to open the source file in the Editor view.
Enter Ctrl + F to invoke the Find/Replace tool, and enter servlet-post in
Double-click the next line with the
PERFORM statement in the left most
column. The appearance of a blue
circle confirms the breakpoint has
been set.
Set another breakpoint on the first
ACCEPT statement in the READ-
DATA paragraph by double-clicking
the line in the left most column.
In the Navigator view, select the
root of the register project, and then select Run Debug
Configurations from the IDE menu.

Click Remote COBOL Application in the Debug Configurations dialog.
Click on the toolbar to create a new debug configuration.
In the Debug Configurations dialog, enter [DEBUG] register.cbl the
Name: text-box, and click Debug.
The application is now configured for remote debugging. The next step is to
execute the application in the same way as we have already done. In the
Editor view, select the Product Registration Received web browser tab,
and click on the browser toolbar to go back to the previous page.
Go to the bottom of the web page, and click the Register Software button.
A Debugger Source Lookup dialog may appear. If so, select Do not ask
again and click OK.
If the Confirm Perspective Switch dialog appears, click Yes and the
debugger perspective will automatically load. The program will suspend
execution when the first breakpoint is encountered (at PERFORM READ-
DATA).
In the Variables view, expand this, expand wrk and select
city_OF_work_record. In the content window below the Variables view
you will see that this variable is currently empty.

Click (or F6) to step over the perform statement. The program will
suspend execution when the next breakpoint is encountered (at ACCEPT).
This is the start of the code that reads the data that has been posted to the
COBOL servlet from the web page form.
Select the register.cbl tab in the Editor view.
Enter Ctrl +F to invoke the Find/Replace tool, and enter notify-done in
Double-click the next line with the EXEC
HTML statement in the left most column.
The appearance of a blue circle confirms the
breakpoint has been set.
Click (or F8) to resume execution of the servlet application. The debugger
once again suspends execution when it encounters the next breakpoint. This
is the start of the code in the COBOL servlet that generates the registration
web page. In the Variables view, the variable city_OF_work_record now
contains the data CITY that came from the submission of the web page
form.

Click (or F8) to once again resume execution of the COBOL servlet. At
this point, the COBOL servlet has terminated. Select the Product
Registration Received tab in the Editor view to see the registration web
page created by the COBOL servlet.

Iterative Debugging, Development & Deployment
With the web application server running, additional changes that you make to the
servlet application you are developing can be easily redeployed to the web
application server using the Elastic COBOL Deploy Wizard. As soon as a new .war
package is exported to the Apache Tomcat deployment folder, it will automatically
undeploy the currently installed version of the application and then deploy the new
version.
When debugging, to prevent having to stop/start the Apache Tomcat web application
server, it is important to terminate the debug session in the proper way, otherwise
the remote network connection between the debugger and application can
sometimes fail to function as expected.
To properly terminate the
debug session for the
servlet application, in the
Debug view, scroll to the
top of the process/thread
list and locate the
[DEBUG] register.cbl
[Remote COBOL
Application] process.
Right-click on this
process and select
Terminate and Relaunch.
In the Editor view, select the Product Registration Received web browser
tab, and click on the browser toolbar to go back to the previous page.
Go to the bottom of the web page, and click the Register Software button.
A Debugger Source Lookup dialog may appear. If so select Do not ask
again and click OK.
To finish your debug session, scroll to the top of the process/thread list in
the Debug view, right-click on the [DEBUG] register.cbl [Remote COBOL
Application process and select Terminate and Remove.
In the Terminate and Remove dialog, click Yes.

CICS Applications
Overview
Elastic COBOL supports the use of the Customer Information Control System
(CICS) transactions via the Elastic Transaction Platform (ETP). ETP enables CICS
COBOL applications to be deployed as Enterprise Java Beans (EJB) so that they
can be executed within the Java Enterprise platform.
Creating a CICS COBOL Project
When building a CICS COBOL application for ETP, the following resources may
need to be configured:
Journals a structured mechanism for writing to a sequential data store
Templates HTML resources
Queues for holding and accessing data in sequential order
SQL information about the database connection
File Definitions mapping of file record structures to SQL table
Additional Software Requirements
for you and you can move to the next section (Creating an ETP Project Part 1).
ETP projects generate EJBs for transactions, so a JEE Application Server is
required to execute the application. Native file access is not permitted within a JEE
environment and so ETP projects require a relational database for data storage.
Download and install Apache Geronimo (with Tomcat) from
http://geronimo.apache.org/apache-geronimo-v300-release.html follow the
instructions on the website for your platform.
Download and install Oracle Database 11g Express Edition from
http://www.oracle.com/technetwork/database/express-
edition/downloads/index.html follow the instructions on the website for your
platform.
In the Eclipse IDE, select File New Other from the IDE menu.
Next.
In the New Server dialog click Download additional server adapters.
In the Install New Extension dialog, select the Geronimo v3.0 Server
Adapter and click Next.

Click I accept the terms of the license agreement in the Review Licenses
dialog and click Finish.

Click OK on the Install Extension dialog.
If you are asked to trust an Apache Geronimo certificate, select it and click
OK.
In the Software Updates dialog, click Yes to restart the IDE.
Setting up the Application Server
When the Eclipse IDE restarts, select File New Other from the IDE
menu.
Next.

In the Define a New Server dialog, expand Apache, select Apache
Geronimo 3.0 Server, and click Next.


In the New Apache Geronimo dialog, click Browse, select the root
directory of your Geronimo installation, and click OK.
Click Finish. The Apache Geronimo server configuration can verified by
selecting the Servers view.

Creating an ETP Project Part 1 Application Project
When creating a new ETP project in Elastic COBOL, use the Create a COBOL
Project Wizard and select Compatibility Elastic Transaction Platform Template.
This will ensure that the right compiler options are set; otherwise EXEC
TRANSACTION or EXEC CICS statements will not be recognized by the Elastic
COBOL compiler.
We are going to use the ETP Account sample application, but before we
start lets clean up our IDE workspace. In the Editor view, right-click any
of the tabs and select Close All.
In the Navigator view click on the toolbar to collapse all the projects.
On the toolbar, click to create a new COBOL project.
Name the project by entering account as the project name.
In the Project type pane, expand Samples, select ETP Account and
click Next.
Because ETP projects require a relational database for data storage, the project
needs to be configured to locate the JDBC driver and setup SQL compiler options.
In the Navigator view, right-click on the root of the account project, and
select Properties Java Build Path Libraries, and click Add
External JARs.
In the Java Settings dialog, select the Libraries tab, Locate the Oracle
JDBC driver ojdbc5, click Open and then click Finish on the Java
Settings dialog.

In the Navigator view, click on the triangle to expand account, then
expand cobol_source, copylib, and resources.
Right-click on the root of the account project tree and then select
Properties from the context menu.
In the Properties for account dialog, select COBOL Compiler Settings and
SQL from the Category: pull-down.
Select Oracle from the SQL Mode: pull-down, select CHARF from the
PIC X(n): pull-down, and select JDBC 2.x from the JDBC: pull-down.

Click OK to finalize the settings, and click No on the Compiler Settings
Changed dialog to prevent a rebuild of the project (it is not necessary yet).
CICS COBOL applications that have terminal interfaces almost always use Basic
Mapping Support (BMS) to move data streams between CICS and the COBOL
application. Elastic COBOL can generate a symbolic map so that the COBOL
program can directly refer to the display fields contained within a BMS file.
In the Navigator view, right-click on resources/ACCTSET.bms and
select Elastic COBOL BMS Generate Copyfile. This generates the
symbolic map for the COBOL program.

Because, ETP projects are deployed to a Java Enterprise Application Server, they
are typically accessed via an internet browser, so Elastic COBOL has a facility to
generate HTML files from the BMS maps. These HTML files can then be used as
the user-interface to the deployed COBOL program.
In the Navigator view, right-click on resources/ACCTSET.bms and
select Elastic COBOL BMS Generate HTML.
Select Project Clean from the IDE menu.
In the Clean dialog, select only account, select Clean projects selected
below, and click OK. At this stage, the project should compile cleanly (i.e.
no major errors listed in the Problems view).

Data Migration (VSAM to Relational)
CICS COBOL applications that use native file-systems (such as VSAM) must
migrate these data stores to a relational database so that the application can
execute within a Java Enterprise platform. To assist with this, Elastic COBOL has a
facility that can generate an XML file from a COBOL record descriptor. This XML file
can then be used by ETP to access SQL columns in a table.
In the Navigator view, right-click on ACCT01.cbl and select Open.
Enter Ctrl + F to invoke the Find/Replace tool, and enter $XFD in the
Find: text-box, followed by clicking Find. Click Close.
Remove the * from the left-most column and click to save. The Elastic
COBOL compiler produces a file called ACCTFIL.XML (placed in the
listing folder) which is an XML representation of the ACCTREC-SQL.cpy
copyfile (which is the record layout for the VSAM file). This is the same layout
as ACCTREC.cpy, but the data names have been changed to be more
descriptive (e.g. FIRST-NAME rather than FNAMEDO). These names will
become the names for the SQL columns in the relational data store.
In the Navigator view, drag & drop ACCTFIL.XML from the listing
folder to the resources folder.

We need to identify any primary and alternate keys for the VSAM file so that
we can mark them as such in the XML representation of the file record.
Click File Refresh to synchronize the project files before doing a
search.
From the IDE menu, click Search File. Enter read dataset into the
Containing text: text-box on the Search dialog. Click Search.

In the Search view, double-click on the first result (line 833 in the image
above). In the Editor view, this shows:
EXEC CICS READ DATASET (ACCTFIL) RIDFLD(ACCTC)
INTO(ACCTREC)
The primary key for the VSAM file is the data item ACCTNO
(this is the value that is moved into ACCTC elsewhere in the
program), and this is accessed with ACCTFIL (which we have
already created but need to edit to mark the key field).
In the Search view, double-click on the third result (line 871 in the image
above). In the Editor view, this shows:
EXEC CICS READ DATASET (ACCT-PATH-NAME)
RIDFLD(NAME2C) INTO (ACCTREC)
The alternate key for the VSAM file is the group data item NAME
(this is the value that is moved into NAME2C elsewhere in the
program), and this is accessed with ACCT-PATH-NAME (which
we need to create and edit to mark the key field).
For the primary key:
In the Navigator view, right-click on ACCTFIL.XML and
select Open. If necessary, click the Design tab on the bottom
of the Editor view for ACCTFIL.XML.
Expand group and then expand the first column (the
first attribute is name with a value of acctno).
Right-click on column and select Add Attribute New
Attribute.
In the New Attribute dialog, enter ridfld in the Name: text-box,
enter dupcheck in the Value: text-box, click OK, and then
click to save.


For the alternate key:
We first need to create a file called ACCT-PATH-NAME.XML (to
correspond to the EXEC CICS READ statement. In the
Navigator view, right-click on ACCTFIL.XML and select
Copy.
In the Navigator view, right-click on the resources folder and
select Paste.
In the Name Conflict dialog, enter ACCT-PATH-NAME.XML in
the text-box and click OK.
In the Navigator view, right-click on ACCT-PATH-NAME.XML
and select Open. If necessary, click the Design tab on the
bottom of the Editor view for ACCT-PATH-NAME.XML.
Expand group and then expand the first column (the
first attribute is name with a value of acctno).
Right-click on ridfld and select Remove.
Expand the next group (the first attribute is name with a
value of name).
Right-click on group and select Add Attribute New
Attribute.

In the New Attribute dialog, enter ridfld in the Name: text-box,
enter dupcheck in the Value: text-box, click OK, and then
click to save.

Resolving Port Conflict
for you and you can move to the next section (Setting up the Relational Database).
Unless you specified otherwise, by default, the HTTP listener for Oracle XE
database will have been installed on the same port as the Apache application
servers (i.e. 8080). To avoid this conflict:
Start a command console on your system, enter sqlplus system and enter
the password (that you setup when you installed the database).
In the SQL Command Console, enter:
SQL> begin dbms_xdb.sethttpport(8081); end; [enter]
/ [enter]
PL/SQL procedure successfully completed.
SQL> quit [enter]

Setting up the Relational Database
NOTE: If you are using the cloud version of the IDE, the database has already been
configured for you so you can move to the next section (Creating and ETP Project
Part 2).

In the Navigator view, right-click on ACCTSET_ACCTDTL.html, select
Open With Web Browser (we are only doing this to quickly load the
internal browser in the Editor view).
In the address bar, enter http://localhost:8081/apex/f?p=4950. This will load
the initial console for the Oracle Express Database.

In the Oracle Express Database window, click on Application Express.
Enter the username (e.g. system) and the password that you set the
database up with when you installed it; and click Login.
In the Create Application Express Workspace window, enter ACCTUSER
in the Database Username text-box, enter account in the Application
Express Username text-box, and enter acctpassword in both the
Password and Confirm Password text-boxes.
Click Create Workspace.

Once the workspace has been created, you will see the following message
appear. Click click here to login.

On the login screen, enter acctpassword and click Login.
We are now going to load the application data into the database. Click the
SQL Workshop box, click the SQL Scripts box, and then click the
Create > button.
In the Navigator view, right-click on oracleXE-acctfil.sql, and select
Open.
NOTE: This script creates a database table that represents the
layout of the COBOL data files, and records that contain the same
data as the original COBOL indexed-sequential data file. In this
application the script is provided for you.
In the Editor view for this script, click CTRL-A to select all the text and
click CTRL-C to copy it.
In the Editor view, click the Script Editor tab to return to the script edit
window.
Enter acctfil in the script name text-box.
Click inside the script edit window, and click CTRL-C to paste the script in
to the editor.
Click the Save button (located at the top right of the page).

Click the Traffic Light icon, and then click the Run Now button to execute
the script.

The database is now populated with the applications dataset. Optionally, you
can click on the icon below View Results to see the output from running the
script. Here, you will see 1 Error which is the result of a request to unload a
database called ACCTFIL (on the chance that one already exists).

Creating an ETP Project Part 2 Deployment Project
Elastic COBOL uses a separate project to configure and manage the deployment of
an ETP project. Some of the items configured in an ETP Deployment Project include
things like participating projects, transaction to program-id mappings and database
connection information.
In the Elastic COBOL IDE, click to create a new Elastic Transaction
Platform Project.
In the Elastic Transaction Platform Project dialog, enter account-deploy in
the Project name: text-box, and click Finish.
Elastic COBOL will automatically open the ETP Deploy Settings in the
Editor view. In the General category, enter acct in the SYSID: text-
box, select account as the Participating project on the Properties pane,
and click Apply.
Click Programs in the Categories pane and you will see that the COBOL
CICS applications have been automatically populated.
We now need to associate the CICS transaction IDs with COBOL program
IDs. Click Transactions in the Categories pane. The initial transaction ID
is always init and this should be associated with the first program that
needs to be run for the application.
In the Transactions pane, click Add.
In the Add dialog enter init in the Transaction ID: text-box, select
acct00 from the Program ID: pull-down, and click OK.
We must associate a program ID with a transaction ID for every CICS
RETURN statement. From the IDE menu, click Search File. Enter
return transid into the Containing text: text-box on the Search dialog.
Click Search.
In the Search view, click to expand all search results. From
the list, we need to associate program IDs with transaction IDs
for AC01 (which is ACCT01.cbl) and AC02 (which is
ACCT02.cbl).
In the Add dialog enter ac01 in the Transaction ID: text-box,
select acct01` from the Program ID: pull-down, & click OK.
In the Add dialog enter ac02 in the Transaction ID: text-box,
select acct02` from the Program ID: pull-down, & click OK.
Click SQL in the Categories pane. This is where we enter the information
necessary to establish the connection to the database. Click Add. In the
Add dialog:
Enter file in the Connection name: text-box.
Enter acctuser in the Username: text-box.

Enter acctpassword in the Password: text-box.
Enter jdbc:oracle:thin:@localhost:1521:xe in the Connection
URL: text-box
Enter oracle.jdbc.OracleDriver in the Driver classname: text-
box.
Click OK.
Click File Control in the Categories pane. This is where we associate the
VSAM file names to the XML files that contain the SQL column names:
Click Add. In the Add dialog enter acctfil (which has the
primary key) in the Source name: text-box.
Enter jdbc:ACCTFIL.XML (this is case-sensitive) in the
Destination name: text-box, and click OK.
Click Add. In the Add dialog enter acct-path-name (which
has the alternate key) in the Source name: text-box.
Enter jdbc:ACCT-PATH-NAME.XML (this is case-sensitive) in
the Destination name: text-box, and click OK.
In the Editor view for ETP Deploy Settings, click Apply to save.
You can review all the settings made by clicking the
project.etp_deploy_settings tab in the ETP Deploy Settings editor.

Deploying an ETP Project
In Elastic COBOL, ETP projects are deployed via the familiar mechanism of a
deployment wizard. For ETP projects, this is the Elastic Transaction Deploy
Wizard.
In the Navigator view, right-click on the root of the account-deploy
project, select Export Elastic COBOL Elastic Transaction Platform
Deploy Wizard and click Next.
In the ETP Deploy Wizard dialog, ETP Project: should be set to account-
deploy. In the EAR file: text-box, enter the location of your Geronimo
deployment folder C:\g3\deploy\account.ear (or
/usr/share/g3/deploy/account.ear on Linux/UNIX).
Click Finish.
If a Confirm Create dialog appears, click Yes.
Click OK on the Archive Export Problems dialog and click OK on the
Export Successful dialog.
Select the Servers view, select the Apache Geronimo v3.0 Server at
localhost, and click to start the server. Because we deployed directly into
the Apache Geronimo deployment folder, once the JEE application server
has started, it will automatically deploy the account.ear package.
You can monitor the progress of Apache Geronimo by selecting the
Console view.
To validate the application was successfully deployed, right-click on
Apache Geronimo v3.0 Server at localhost [Started, Synchronized] in the
Servers view, and select Launch Geronimo Console.
In the Editor view for Geronimo, enter system in the User Name: text-
box, enter manager in the Password: text-box, and click Login.
In the Console Navigation pane, expand [+] Applications, and click
Application EARs. The State for /acct should be running.


Executing an ETP Application
ETP Applications are invoked as servlets. This is a highly complementary model for
COBOL CICS applications, which typically have a request/respond execution flow.
From the Elastic COBOL IDE menu, select Window Show View
Other.
In the Show View dialog, select General Internal Web Browser, click
OK.
In the Internal Web Browser view, click to expand the window.
In the address bar, enter http://localhost:8080/acct/servlet.
In the application screen of account, enter GREEN in the SURNAME:
text-box and click PF2 (the command for forward in this application).
Because this is the initial load of the database there will be a few seconds
delay before the results are displayed. Subsequent requests will typically be
sub-second.
Click PF1 (backward) or PF2 (forward) to scroll through the records.
Other actions are permitted as per menu. Always click Clear before issuing
a new request to the application.

Elastic COBOL Getting Started

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Elastic COBOL Getting Started

Enviado por

Direitos autorais:

Formatos disponíveis

2013 Heirloom Computing Inc

All Rights Reserved

Você também pode gostar