U.S. patent application number 14/394769 was filed with the patent office on 2015-04-09 for providing instructions to a mainframe system.
This patent application is currently assigned to International Business Machines Corporation. The applicant listed for this patent is International Business Machines Corporation. Invention is credited to Colin C. Stone, John D. Taylor, Gary O. Whittingham, Joseph R. Winchester.
Application Number | 20150100136 14/394769 |
Document ID | / |
Family ID | 46209180 |
Filed Date | 2015-04-09 |
United States Patent
Application |
20150100136 |
Kind Code |
A1 |
Stone; Colin C. ; et
al. |
April 9, 2015 |
Providing Instructions to a Mainframe System
Abstract
Method and system are provided for providing instructions to a
mainframe system. The method at a client system includes
constructing a job control language (JCL) job embedded with an
interpreted language program to provide instructions to a mainframe
operating system. The method at a mainframe system includes:
receiving a job control language (JCL) job embedded with an
interpreted language program to provide instructions to a mainframe
operating system; copying the interpreted language program to a
transient executable area; and executing the interpreted language
program.
Inventors: |
Stone; Colin C.; (Hursley,
GB) ; Taylor; John D.; (Hursley, GB) ;
Whittingham; Gary O.; (Hursley, GB) ; Winchester;
Joseph R.; (Hursley, GB) |
|
Applicant: |
Name |
City |
State |
Country |
Type |
International Business Machines Corporation |
Armonk |
NY |
US |
|
|
Assignee: |
International Business Machines
Corporation
Amonk
NY
|
Family ID: |
46209180 |
Appl. No.: |
14/394769 |
Filed: |
April 3, 2013 |
PCT Filed: |
April 3, 2013 |
PCT NO: |
PCT/IB2013/052650 |
371 Date: |
October 16, 2014 |
Current U.S.
Class: |
700/18 |
Current CPC
Class: |
G06F 9/45512 20130101;
G05B 19/0426 20130101; G05B 2219/23039 20130101 |
Class at
Publication: |
700/18 |
International
Class: |
G05B 19/042 20060101
G05B019/042 |
Foreign Application Data
Date |
Code |
Application Number |
Apr 17, 2012 |
GB |
1206726.0 |
Claims
1. A method at a client system for providing instructions to a
mainframe system, comprising: constructing a job control language
(JCL) job embedded with an interpreted language program to provide
instructions to a mainframe operating system.
2. The method as claimed in claim 1, wherein a command to be issued
to the mainframe operating system is embedded in the interpreted
language program.
3. The method as claimed in claim 1, wherein a command to be issued
to the mainframe operating system is read in from an input step
when the interpreted language program is run.
4. The method as claimed in claim 1, including: submitting the job
control language job to a mainframe system; and obtaining a
response to the job control language job including a response to
the interpreted language program.
5. The method as claimed in claim 1, including: providing a
template of the job control language job with embedded interpreted
language program including appropriate places for user inputs in
text form.
6. The method as claimed in claim 1, wherein the interpreted
language program is embedded in the job control language job as an
in-line dataset.
7. A method at a mainframe system for receiving instructions,
comprising: receiving a job control language (JCL) job embedded
with an interpreted language program to provide instructions to a
mainframe operating system; copying the interpreted language
program to a transient executable area; and executing the
interpreted language program.
8. The method as claimed in claim 7, including: deleting the
transient executable area after execution of the interpreted
language program.
9. The method as claimed in claim 7, wherein the interpreted
language program has access to a mainframe operating system
application programming interface (API).
10. The method as claimed in claim 7, wherein the interpreted
language program creates a console as a means to issue commands to
the mainframe operating system and to receive replies.
11. The method as claimed in claim 10, wherein multiple commands
are included in the interpreted language program and multiple
responses retrieved.
12. The method as claimed in claim 7, including: writing responses
to interpreted language program as a job output step; and including
the job output step in a job control language completion code.
13. A client system for providing instructions to a mainframe
system, comprising: a processor; a component configured for
constructing a job control language (JCL) job embedded with an
interpreted language program to provide instructions to a mainframe
operating system.
14. The client system as claimed in claim 13, including: a job
sending component for submitting the job control language job to a
mainframe system; and a receiving component for obtaining a
response to the job control language job including a response to
the interpreted language program.
15. The client system as claimed in claim 13, including: a template
component for providing a template of the job control language job
with embedded interpreted language program including appropriate
places for user inputs in text form.
16. The client system as claimed in claim 13, wherein the
interpreted language program is embedded in the job control
language job as an in-line dataset.
17. A mainframe system for receiving instructions, comprising: a
job entry subsystem configured for receiving a job control language
(JCL) job embedded with an interpreted language program to provide
instructions to a mainframe operating system; a copying component
configured for copying the interpreted language program to a
transient executable area; and an interpreted language executing
component configured for executing the interpreted language
program.
18. The mainframe system as claimed in claim 17, including: an
allocating component configured for allocating the transient
executable area and deleting the transient executable area after
execution of the interpreted language program.
19. The mainframe system as claimed in claim 17, including a
console component configured for creating a console to which a
command is issued and from which a response is retrieved.
20. The mainframe system as claimed in claim 17, including: a first
job output component at the interpreted language executing
component configured for writing responses to the interpreted
language program as a job output step; and a second job output
component at the job entry subsystem configured for including the
job output step in a job control language completion code.
21. A computer program stored on a non-transitory computer readable
medium and loadable into the internal memory of a digital computer,
comprising software code portions, when said program is run on a
computer, for performing the method of claim 1.
22. A computer program stored on a non-transitory computer readable
medium and loadable into the internal memory of a digital computer,
comprising software code portions, when said program is run on a
computer, for performing the method of claim 7.
23-24. (canceled)
Description
FIELD OF INVENTION
[0001] This invention relates to the field of providing
instructions to a mainframe system. In particular, the invention
relates to providing instructions to a mainframe system without
using an additional component in the form of a server installed
component or separate terminal.
BACKGROUND OF INVENTION
[0002] Mainframes have grown up with dumb terminals as the primary
way to access system functionality. There has been a growth of
newer devices, such as personal computers with graphical user
interface (GUI) operating systems, mobile devices such as smart
phones and tablets, or mashup devices used in situational
applications. Providing a way to drive the mainframe through these
heterogeneous client devices, as well as future form factors such
as mobile and touch devices, is key to continued existence and
relevance of the mainframe.
[0003] The legacy of 45 years of functionality in mainframes means
that there are hundreds of commands which are already proven,
reliable and trusted to perform tasks, such as, start address
spaces, query system information, or respond to system events. A
solution is required which unlocks the commands to access through
any client device, without incurring the overhead that comes
through explicit client/server boundary configuration or
coupling.
[0004] The IBM.RTM. 3270 (IBM is a trade mark of International
Business Machines Corporation, registered in many jurisdictions
worldwide) is a class of block oriented terminals made by IBM since
1972 (known as "display devices") normally used to communicate with
IBM mainframes.
[0005] Current implementations either use IBM 3270 interfaces or a
server component incurring problems described below.
[0006] The client implements an IBM 3270 data stream, or screen
scrapes an IBM 3270 terminal emulator and uses that session to
issue the commands.
Drawbacks:
[0007] (A) The user's user id is required to log into the system,
meaning that the user id could not be used separately to log into
the system. This means that if the user is logged into a separate
3270 session then either they will be logged off that session, or
the client will be unable to issue the commands, making them less
productive. Current work-arounds require the creation of multiple
user ids which has a cost overhead and is less flexible.
[0008] (B) Interpreting and responding to a 3270 data stream
requires significant logic. This means any such implementation is
costly to develop, test and maintain.
[0009] (C) Screen scraping adds to complexity and requires a
coupling between the client code and the server 3270 panels. If the
panels change without modifications to the client, then the
application fails. This problem makes this approach brittle,
difficult to maintain and unreliable.
[0010] In server stored programs, the client sends Job Control
Language (JCL) that executes a stored program with command(s)
passed in the JCL. Job Control Language (JCL) is a scripting
language used on mainframe operating systems to instruct the system
on how to run a batch job or start a subsystem.
Drawbacks:
[0011] (D) This approach requires one or more programs to be
pre-installed on the server. This introduces cost and complexity of
configuration and restricts the ability of the client to attach to
any server and execute commands.
[0012] (E) Any maintenance changes may have to be applied to both
the client and all targeted servers. This introduces cost and
complexity of configuration.
[0013] (F) Server configuration changes are closely controlled and
managed by system administrators and often constrained to fixed
maintenance windows. This means that updates are delayed and incur
a higher deployment cost.
[0014] Therefore, there is a need in the art to address the
aforementioned problems.
BRIEF SUMMARY OF THE INVENTION
[0015] According to a first aspect of the present invention there
is provided a method at a client system for providing instructions
to a mainframe system, comprising: constructing a job control
language (JCL) job embedded with an interpreted language program to
provide instructions to a mainframe operating system.
[0016] According to a second aspect of the present invention there
is provided a method at a mainframe system for receiving
instructions, comprising: receiving a job control language (JCL)
job embedded with an interpreted language program to provide
instructions to a mainframe operating system; copying the
interpreted language program to a transient executable area; and
executing the interpreted language program.
[0017] According to a third aspect of the present invention there
is provided a client system for providing instructions to a
mainframe system, comprising: a processor; a component for
constructing a job control language (JCL) job embedded with an
interpreted language program to provide instructions to a mainframe
operating system.
[0018] According to a fourth aspect of the present invention there
is provided a mainframe system for receiving instructions,
comprising: a job entry subsystem for receiving a job control
language (JCL) job embedded with an interpreted language program to
provide instructions to a mainframe operating system; a copying
component for copying the interpreted language program to a
transient executable area; and an interpreted language executing
component for executing the interpreted language program.
[0019] According to a fifth aspect of the present invention there
is provided computer program stored on a computer readable medium
and loadable into the internal memory of a digital computer,
comprising software code portions, when said program is run on a
computer, for performing the method of any the first aspect of the
present invention.
[0020] According to a sixth aspect of the present invention there
is provided a computer program stored on a computer readable medium
and loadable into the internal memory of a digital computer,
comprising software code portions, when said program is run on a
computer, for performing the method of the second aspect of the
present invention.
[0021] According to a seventh aspect of the present invention there
is provided a method substantially as described with reference to
the figures.
[0022] According to an eighth aspect of the present invention there
is provided a system substantially as described with reference to
the figures.
[0023] The described aspects of the invention provide the advantage
of providing instructions to a mainframe system without using an
additional component in the form of a server installed component or
separate terminal.
BRIEF DESCRIPTION OF THE DRAWINGS
[0024] The subject matter regarded as the invention is particularly
pointed out and distinctly claimed in the concluding portion of the
specification. The invention, both as to organization and method of
operation, together with objects, features, and advantages thereof,
may best be understood by reference to the following detailed
description when read with the accompanying drawings.
[0025] Preferred embodiments of the present invention will now be
described, by way of example only, with reference to the following
drawings in which:
[0026] FIG. 1 is block diagram of an example embodiment of a system
in accordance with the present invention;
[0027] FIG. 2 is a block diagram of an embodiment of a computer
system in which the present invention may be implemented;
[0028] FIG. 3 is a flow diagram of an example embodiment of an
aspect of a method in accordance with the present invention;
[0029] FIG. 4 is a flow diagram of an example embodiment of an
aspect of a method in accordance with the present invention;
and
[0030] FIG. 5 is a schematic diagram showing a flow of an
embodiment of a method in accordance with the present invention in
relation to the system components.
DETAILED DESCRIPTION OF THE DRAWINGS
[0031] It will be appreciated that for simplicity and clarity of
illustration, elements shown in the figures have not necessarily
been drawn to scale. For example, the dimensions of some of the
elements may be exaggerated relative to other elements for clarity.
Further, where considered appropriate, reference numbers may be
repeated among the figures to indicate corresponding or analogous
features.
[0032] In the following detailed description, numerous specific
details are set forth in order to provide a thorough understanding
of the invention. However, it will be understood by those skilled
in the art that the present invention may be practiced without
these specific details. In other instances, well-known methods,
procedures, and components have not been described in detail so as
not to obscure the present invention.
[0033] Method and system are provided for interacting with a
mainframe system without using an additional component (e.g. server
installed component, separate terminal). More specifically, a
solution is provided for constructing a Job Control Language (JCL)
job embedded with instructions in an interpreted language (e.g.
REXX) that has access to the operating system (z/OS.RTM.) of a
mainframe (z/OS is a trade mark of International Business Machines
Corporation, registered in many jurisdictions worldwide). When the
job is submitted to the mainframe, the interpreted language program
interacts with the operating system and the embedded instructions
are executed.
[0034] A client may construct a single JCL job that in-lines
instructions in an interpreted language that has access to the
operating system application programming interface (API), for
example, REXX (Restructure Extended Executor) on z/OS, or Perl
(Perl is a trade mark of The Perl Foundation). This JCL is
submitted to the server for execution.
[0035] While this could be achieved using a non-interpreted
language such as Assembler or C, that would require compilation or
link-edit steps and/or specification of the location of system
libraries. The disadvantage of this approach when compared to the
described method is that the client needs explicit information
about the server such as the location of specific system libraries.
This increases the cost and complexity of configuration and
restricts the ability of the client to attach to any server and
execute commands. The described method has no such restriction.
[0036] Having submitted the JCL to the server for execution, the
JCL job may firstly copy the interpreted language payload into a
transient executable area from which it can be run, and may then
execute the interpreted language before finally deleting the
contents from the transient executable area.
[0037] The interpreted language program may issue the command or
commands (either included in the program sent from the client, or
read in from an input step when the interpreted language program is
run), capture the responses to these commands, and write the
responses to an output step of the JCL job.
[0038] Once the job has been submitted, the client may poll the
server to check for the completion of the job or may wait a
pre-defined time period, and once the job has completed, the output
step containing the response to the commands may be read by the
client.
[0039] Since the interpreted language program is contained in the
submitted JCL job, there is no requirement for any code to be
pre-installed on the server. This avoids the drawbacks described in
D, E and F above in the background section.
[0040] As there is no use of the 3270 interface, cost and
complexity described in A, B and C above in the background section
are avoided.
[0041] Referring to FIG. 1, a block diagram shows an example
embodiment of the described system 100. The system 100 may include
a client system 110 for instructing a mainframe system 130.
[0042] The client system 110 may be any client device, for example,
a personal computer, mobile device such as a smart phone or tablet,
a mashup device, or another mainframe, etc.
[0043] The client system 110 may include a template component 111
for providing a template 120 to the user. The template 120 may be
an interpreted language program 121 embedded in a JCL instruction
122. The template component 111 may include an input receiving
component 112 for receiving user inputs in text form and the
template 120 may include inserts 123 into which the user inputs are
added.
[0044] The client system 110 may include a job sending component
113 for sending the completed JCL instruction 122 with the embedded
interpreted language program 121 to the mainframe system 130.
[0045] The mainframe system 130 may include a job entry subsystem
(JES) 140 for receiving jobs into the operating system. The JES 140
may include a temporary dataset allocating component 141 for
allocating and deleting a temporary dataset 142 and a copying
component 143 for copying the embedded interpreted language program
121 to the temporary dataset 142.
[0046] An interpreted language executing component 150 represents
the interpreted language used by the program 121. The executing
component 150 may include the following components with facilities
provided by the interpreted language and used by the interpreted
language program 121, namely: a suppressing component 151 for
suppressing unsolicited messages, a console component 152 for
creating and deactivating a time sharing option (TSO) console 160,
a command component 153 for issuing commands and receiving
responses to and from the console, and a first job output component
154 for issuing the response to the command(s).
[0047] The supressing component 151 may be provided as it is
possible that broadcast messages may be sent to all `users` on the
system. If one of these messages were received by the program 121
then the message may not be understood and could cause an error in
the program 121. Suppressing unsolicited messages stops these
messages being received by the program 121.
[0048] The console component 152 may create a console as a means to
issue commands to the mainframe operating system and receive
replies. This is analogous to creating a command prompt window in
an operating system, except the console created here is accessible
programmatically and does not have a component that is visible to a
user.
[0049] The JES 140 may include a second job output component 144
for writing the job output 171 to a dataset spool 170 which may be
checked by a receiving component 114 of the client system 110. In
one embodiment, the receiving component 114 may poll the mainframe
system for a job output. Alternatively, receiving component 114 may
include another form of checking component, for example, for
checking after a predetermined time period. The client system 110
may also include a job completion component 115 for reading and
checking the response.
[0050] Referring to FIG. 2, an exemplary system for implementing
aspects of the invention includes a data processing system 200
suitable for storing and/or executing program code including at
least one processor 201 coupled directly or indirectly to memory
elements through a bus system 203. The memory elements may include
local memory employed during actual execution of the program code,
bulk storage, and cache memories which provide temporary storage of
at least some program code in order to reduce the number of times
code must be retrieved from bulk storage during execution.
[0051] The memory elements may include system memory 202 in the
form of read only memory (ROM) 204 and random access memory (RAM)
205. A basic input/output system (BIOS) 206 may be stored in ROM
204. Software 207 may be stored in RAM 205 including system
software 208 comprising operating system software 209. Software
applications 210 may also be stored in RAM 205.
[0052] The system 200 may also include a primary storage means 211
such as a magnetic hard disk drive and secondary storage means 212
such as a magnetic disc drive and an optical disc drive. The drives
and their associated computer-readable media provide non-volatile
storage of computer-executable instructions, data structures,
program modules and other data for the system 200. Software
applications may be stored on the primary and secondary storage
means 211, 212 as well as the system memory 202.
[0053] The computing system 200 may operate in a networked
environment using logical connections to one or more remote
computers via a network adapter 216.
[0054] Input/output devices 213 may be coupled to the system either
directly or through intervening I/O controllers. A user may enter
commands and information into the system 200 through input devices
such as a keyboard, pointing device, or other input devices (for
example, microphone, joy stick, game pad, satellite dish, scanner,
or the like). Output devices may include speakers, printers, etc. A
display device 214 is also connected to system bus 203 via an
interface, such as video adapter 215.
[0055] Referring to FIG. 3, a flow diagram 300 shows an embodiment
of the described method at a client system.
[0056] A template may be provided 301 to the user of a client
system. The template may comprise an interpreted program which is
embedded in JCL as an in-line dataset. Input may be received 302
from the user in the form of mainframe operating system command(s)
in text form and inserted 303 into the interpreted program of the
template in the appropriate place(s). The resulting JCL with
embedded interpreted language program may be submitted 304 to a
target mainframe system via file transfer protocol (FTP) (or
equivalent protocol) for dispatch by the job scheduling system.
[0057] The command to be issued to be executed may either be
embedded in the interpreted language program, or it may be read in
from an input step when the interpreted language program is run. In
either case, the command may be added to the JCL/interpreted
language program before it is sent to the mainframe.
[0058] Checks may be made 305 for completion of the job by the
mainframe system. Once the job is completed, the job completion
code may be read 306 (to check for errors) and the output step
created by the interpreted program is read to capture the response
to the command(s).
[0059] Referring to FIG. 4, a flow diagram 400 shows an embodiment
of the described method at a mainframe system.
[0060] The JCL with the embedded interpreted language program from
the client may be received 401 by the host system, and may comprise
two JOB steps.
[0061] Step one may allocate 402 a temporary dataset and may copy
the embedded interpreted language program into a member in that
dataset.
[0062] Step two may execute 410 the interpreted language program
from the temporary dataset. The interpreted program may carry out
the following. Unsolicited messages to the console to be used may
be suppressed 411. A TSO console may be created 412 from which
commands can be issued. A command may be issued 413 to the console
and the command response may be retrieved 414 from the console, for
example, using the CART (Command and Response Token) mechanism to
relate responses to the commands that they were issued for.
[0063] It may be determined 415 if there is another command. If so,
steps 413 and 414 of issuing the command and retrieving the
response are repeated. If there are no more commands, the console
may be deactivated 416.
[0064] The response(s) from the command(s) may be written 417 to a
job output step. The response may be richer than simply the command
response(s).
[0065] On completion of step two 410, the temporary dataset may be
automatically deleted 418.
[0066] The following is an example of a JCL template with embedded
REXX program.
TABLE-US-00001 Template JCL: //PRECOPY EXEC PGM=IEBUPDTE,PARM=NEW
//SYSUT2 DD DISP=(,PASS),UNIT=SYSDA,SPACE= (TRK,(3,1,1)), //
LRECL=80,RECFM=FB,DSORG=PO //SYSPRINT DD DUMMY //SYSIN DD * ./ ADD
NAME=CMDPGM /* REXX */ : : REXX program to issue command and
retrieve response : /* //* //RUN EXEC PGM=IKJEFT01,PARM=`%CMDPGM`,
COND=(0,NE) //SYSEXEC DD DSN=*.PRECOPY.SYSUT2,DISP= (OLD,DELETE)
//SYSTSPRT DD SYSOUT=* //REXXOUT DD SYSOUT=* //SYSTSIN DD DUMMY
[0067] In the embodiment in which a command is read in from an
input step when the interpreted language program is run, the client
would have to add a suitable jobcard to the start of the template
JCL (such as the sample JCL given above). A very simple jobcard
would be:
[0068] //JOBNAME JOB
[0069] Referring to FIG. 5, a schematic diagram 500 shows an
embodiment of the described method in the context of the example
system of FIG. 1.
[0070] A user may add a command 501 at a client system 110 to an
interpreted language program 121 embedded in a JCL instruction 122.
The JCL instruction 122 may be submitted 502 as a job to a JES 140
of a mainframe system 130.
[0071] The JES 140 copies 503 the interpreted language program 121
to a temporary dataset 142 from which it is executed 504, 505 by an
interpreted language executing component 150. The interpreted
language executing component 150 creates and issues commands to 506
a console 160 and receives 507 responses back from the console
160.
[0072] The job output of the interpreted language program 121 is
sent 508 to the JES 140 and to a data set spool 509 from which it
is polled 510 by a polling component 114 at the client system
110.
[0073] This disclosure describes a process to allow commands to be
issued from a client without requiring a server component or a 3270
session.
[0074] The invention can take the form of an entirely hardware
embodiment, an entirely software embodiment or an embodiment
containing both hardware and software elements. In a preferred
embodiment, the invention is implemented in software, which
includes but is not limited to firmware, resident software,
microcode, etc.
[0075] The invention can take the form of a computer program
product accessible from a computer-usable or computer-readable
medium providing program code for use by or in connection with a
computer or any instruction execution system. For the purposes of
this description, a computer usable or computer readable medium can
be any apparatus that can contain, store, communicate, propagate,
or transport the program for use by or in connection with the
instruction execution system, apparatus or device.
[0076] The medium can be an electronic, magnetic, optical,
electromagnetic, infrared, or semiconductor system (or apparatus or
device) or a propagation medium. Examples of a computer-readable
medium include a semiconductor or solid state memory, magnetic
tape, a removable computer diskette, a random access memory (RAM),
a read only memory (ROM), a rigid magnetic disk and an optical
disk. Current examples of optical disks include compact disk read
only memory (CD-ROM), compact disk read/write (CD-R/W), and
DVD.
[0077] Improvements and modifications can be made to the foregoing
without departing from the scope of the present invention.
* * * * *