Execution pathway for interfacing with legacy programs in a mainframe environment
View Patent ↗A computer-implemented method is provided for creating an execution path for interfacing with legacy programs in a mainframe computing environment. The method includes: creating a run-time environment for programs on a mainframe computer by an initiator program; initiating execution of a configuration program in the run-time environment by the initiator program, where the configuration program is written in the high level programming language; specifying user-defined parameters for a Java Virtual Machine to the configuration program; and creating a Java Virtual Machine in another run-time environment of the mainframe computer, where the JVM is created by the configuration program using the user-defined parameters.
1. A computer-implemented method for creating an execution path for interfacing with a legacy program that is unable to create a Java Virtual Machine in a mainframe computing environment, comprising:
initiating execution of an initiator program using a script program executed by a z/OS operating system of a mainframe computer;
creating, by the initiator program, a first run-time environment for programs on the mainframe computer, where the creation of the runtime environment uses pre-initialization (PIPI) services of a Language Environment component of the z/OS operating system;
initiating execution of a configuration program in the first run-time environment by the initiator program, where the configuration program is written in a high level programming language that differs from the programming language of the legacy program;
specifying user-defined parameters for a Java Virtual Machine to the configuration program;
creating, by the configuration program, a Java Virtual Machine (JVM) in second run-time environment of the mainframe computer, where the JVM is created by the configuration program using the user-defined parameters and the second run-time environment differs from the first run-time environment; and
executing the legacy program in the first run-time environment, where the legacy program passes data to the configuration program which in turn invokes a Java method.
2. The computer-implemented method of claim 1 wherein creating a run-time environment further comprises initializing a Language Environment supported by the z/OS operating system.
3. The computer-implemented method of claim 1 further comprises disabling error handling by the run-time environment for the legacy program.
4. The computer-implemented method of claim 1 further comprises allocating a memory space by the initiator program; receiving by the initiator program an instruction from the legacy program; and storing a portion of the instruction in the memory space for subsequent retrieval.
5. The computer-implemented method of claim 1 wherein specifying user-defined parameters further comprises specifying a first path to Java itself, specifying a second path to executables for Java; and creating the Java Virtual Machine using the first and second paths.
6. The computer-implemented method of claim 1 wherein specifying user-defined parameters further comprises reading the user-defined parameters by the configuration program from a text file.
7. The computer-implemented method of claim 1 wherein the configuration program uses a Java Native Interface (JNI) to invoke Java methods.
8. The computer-implemented method of claim 1 further comprises initiating execution of the initiator program using a script program executed by an operating system of the mainframe computer, detecting by the configuration program an error as reported by the JNI, and outputting the detected error to a data file defined by the script program.
9. The computer-implemented method of claim 1 wherein the another run-time environment is further defined as a UNIX System Services component of the z/OS operating system.
10. A computer-implemented method for creating an execution path for interfacing with legacy programs in a mainframe computing environment, comprising:
initiating execution of an initiator program using Job Control Language executed by a z/OS operating system of the mainframe computer;
creating, by the initiator program, a run-time environment on a mainframe computer executing the z\OS operating system;
initiating, by the initiator program, execution of a configuration program in the run-time environment of the mainframe computer, where the configuration program is written in the high level programming language that differs from the programming language of the legacy program;
specifying user-defined parameters for a Java Virtual Machine to the configuration program;
creating, by the configuration program, a Java Virtual Machine (JVM) in another run-time environment of the mainframe computer, where the JVM is created by the configuration program using the user-defined parameters;
invoking Java methods by the configuration program via a Java Native Interface (JNI) associated with the JVM; and
detecting an error reported by the JNI and outputting the detected error by the configuration program to a data file defined by the Job Control Language.
11. The computer-implemented method of claim 10 further comprises creating the run-time environment using pre-initialization (PIPI) services of a Language Environment component of a z/OS operating system to create the run-time environment.
12. The computer-implemented method of claim 11 further comprises disabling error handling by the Language Environment for the legacy program.
13. The computer-implemented method of claim 10 further comprises allocating a memory space by the initiator program; receiving by the initiator program an instruction from the legacy program; and storing a portion of the instruction in the memory space for subsequent retrieval.
14. The computer-implemented method of claim 10 wherein specifying user-defined parameters further comprises specifying a first path to Java itself, specifying a second path to executables for Java; and creating the Java Virtual Machine using the first and second paths.
15. The computer-implemented method of claim 14 wherein specifying user-defined parameters further comprises reading the user-defined parameters by the configuration program from a text file.
16. A computer-implemented method for creating an execution path for interfacing secondary application programs with a legacy program in a mainframe computing environment, comprising:
creating, by an initiator program, a run-time environment for programs on a mainframe computer executing a z/OS operating system, where the creation of the run-time environment uses pre-initialization (PIPI) services of a Language Environment component of the z/OS operating system;
initiating execution of a configuration program in the run-time environment by the initiator program, where the configuration program is written in the high level programming language;
specifying user-defined parameters for a virtual machine to the configuration program; and
creating a virtual machine to support execution of the secondary application programs in another run-time environment of the mainframe computer, where the virtual machine is created by the configuration program using the user-defined parameters and the secondary application programs are written in a programming language that is different than the high level programming language of the configuration program.
17. The computer-implemented method of claim 16 wherein specifying user-defined parameters further comprises specifying a first path to the virtual machine itself, specifying a second path to executables associated with the virtual machine; and creating the virtual machine using the first and second paths.