Production Control Analyst
Part Two - Challenge #14

Background:

Try an internet search using words z/OS Production Control Analysts. You will find jobs using terminology from the previous challenges. Large Enterprise IT organizations use Job Scheduling Software to control thousands of JCL jobs with complex processing dependencies. The skill set of a Production Control Analyst includes analysis of JCL job dependencies. A responsibility of the Production Control Analyst is to identify and resolve issues related to scheduled JCL jobs.

An analogy to JCL job scheduling dependencies is a manufacturing assembly line where cars proceed through a series of assembly stations. Each station completes a task, such as installing the front windshield. If the windshield installation station fails, the assembly line stops until the windshield installation station problem is resolved. Obviously, immediate attention is directed to the windshield installation station due to business impact that can be costly.

You can think of z/OS Production Control and Job Scheduling as an assembly line where the product passing through the assembly process is critical business data.

JES2 is a z/OS component that reads and prepares JCL for processing by z/OS. A brand new Job Scheduling feature is available in the latest z/OS level used in this contest.

This is an opportunity for you to learn some specific z/OS technology and terminology many professional z/OS Production Control Analysts have not had the opportunity to learn.

The new feature is JES2 Execution Control, JEC.

If you interview for a z/OS Production Control Analyst position and the employer asks, "Are you familiar with XYZ Production Control Job Scheduling software?"

You can respond, "No, however, I do have experience with JES2 Execution Control which is the principle behind the more sophisticated Production Job Scheduling software packages."

That response would be impressive, demonstrate your technology flexibilty, and potentially prompt them to ask, "What is JES2 Execution Control?", giving you the opportunity explain your value to them.

A JEC statement stream is a special type of JCL statement stream that creates a job group. A job group includes related job names with assigned attributes that determime when execution should begin for each job name.

What value is the new JEC capability in an IT organization that has Job Scheduling Software?

  • Application developers can use a private Job Scheduling mechanism to test dependency processing before implementing the jobs into the production schedule
  • A Production Control Analyst could use JEC to resolve a problem in the production job schedule
    * a toolbag of JEC procedures could be constructed to resolve production job scheduling processing problems more quickly
  • New automated operation procedures can be implemented without adding additional complexity in the production control job schedule
  • JEC is included with z/OS and does not require installation or additional software costs

As previously mentioned, z/OS technology skills can be applied to a wide variety of businesses.

For the purpose of this challenge, let's assume a business that orders massive volumes of food products, then distributes packaged food products to bakeries, restaurants, donut shops, etc. The specific business application involves bulk ordering of flours, sugars, and oils, then distributed in packed smaller bulk amounts to client bakeries, restaurants, donut shops, etc.

The fictitious company name is "FSOC, Flours, Sugars, Oils Company"

A daily set of JCL jobs are scheduled and processed that are critical to the business.

Clients place orders for flour, sugar, and oil throughout the day as input to the following schedule of JCL jobs:

J####?? where ?? represents a JCL job name suffix for:

??  JOB Description
 ---------------------------------------------------------------------------------
00  cut-off ordering deadline is reached for next day deliveries
 ---------------------------------------------------------------------------------
 --- 10, 20, and 30 can run concurrently after 00 successfully completes
 ---------------------------------------------------------------------------------
10  flour orders are totalled
20  sugar orders are totalled
30  oil orders are totalled
 ---------------------------------------------------------------------------------
 --- 11, 21, and 31 can run concurrently after 10, 20, and 30 respectively
 ---------------------------------------------------------------------------------
11  flour inventory checked to fill orders
21  sugar inventory checked to fill orders
31  oil inventory checked to fill orders
 ---------------------------------------------------------------------------------
 --- 12, 22, and 32 can run concurrently after 11, 21, and 31 respectively
 ---------------------------------------------------------------------------------
12  flour order added to next day client shipment
22  sugar order added to next day client shipment
32  oil order added to next day client shipment
 ---------------------------------------------------------------------------------
 --- 40 can run after 12, 22, and 32 successfully completes
 ---------------------------------------------------------------------------------
40  create truck delivery loads and shipping instructions
 ---------------------------------------------------------------------------------
 --- 41 can run after 40 successfully completes
 ---------------------------------------------------------------------------------
41  create massive bulk order based upon product inventory levels

The challenge will focus on JEC statements used to control job name dependency processing of the above jobs.

Challenge Setup Actions:

Learning System IDs Only (AU0####), click on link below for special instructions.
Learning System ID special instructions for this challenge.

Enter the following:
tso ch14
The above changed all occurrences of #### to the last 4 digits of your ID in hlq.JCL(JOB14A) and hlq.JCL(JOB14B)

Enter the following:
tso submit 'zos.public.jcl(fsoc)'
The above copied data sets and executable modules required for this challenge.

The following data sets were created as application program inputs and outputs:
hlq.FSOC.INVNTRY
hlq.FSOC.ORDERS
hlq.FSOC.PRODUCT.PROFILE
hlq.FSOC.SHIPMENT

Several executable modules were copied to hlq.LOAD

Notes:

  • The challenge is limited to a "correction" in the JCL JEC statement stream
  • The challenge is limited to a subset of JEC capability and function
      JES2 Execution Control includes capability and function beyond what you will observe in this challenge
  • You will have no need to understand the application code or application JCL in this challenge
      Part 3 includes exposure to the application code and application JCL

Challenge:

JEC statement dependency relationship has 2 steps:
  1. Submit JEC statements to inform the system of JOB dependencies
  2. Submit the JCL JOBs identified by the JEC statements

View hlq.JCL(JOB14A)
Observe the following:

  • JOBGROUP statement identifies a job group named G####
      where #### is last 4 digits of your ID
  • 12 GJOB entries
  • GJOB statements identify individual JCL job names in the group
  • AFTER operand associated with GJOB statement creates a JCL job dependency relationship

Submit the JCL JEC statements and review the status of the job group as follows:
Enter the following while viewing hlq.JCL(JOB14A):

submit ; =sd ; jg

help or F1

  Note: In the event of system message, "In data Z#####.JCL", then help or F1 again

3 to select Action Characters
Observe
D, Display Information in the log.
You can add:
E - Jobs in the group that encountered an error
J - Jobs associated with the group
L - Information about the group, long form
N - Network
P - Dependencies for the group

Enter to go forward in the Action Characters help panel and observe:
JP    Dependencies for the group (access the JP panel).

Try the various actions above on the Job Group JG panel Action Characters against your job group, G####. You will need to F3 to exit from action command output and return to JOB GROUP DISPLAY panel to enter next action character command.

The next step of the challenge is to submit the JCL jobs, then enter these same commands to observe the differences

Note: Next action involves JCL JOB14B - NOT JOB14A

The JCL job names identified in the JOB GROUP DISPLAY need to be submitted - which follows:

View hlq.JCL(JOB14B)
Observe the following:

  • 12 job names, each identified by JCL JOB statement - 1 for each GJOB in JCL JOB14A
  • Each job name is executing a JCL procedure with the exception of J####00
      Each JCL procedure contains:
        unique program name to be executed
        allocation of specific inputs and outputs required by the program
      However, understanding the JCL procedure is NOT relevant to completing this challenge
  • SCHEDULE is a JEC statement that connects a job name to JOBGROUP=G####
    12 SCHEDULE statements
  • J####00 job name contains
    TYPRUN=HOLD on the JCL JOB statement
     EXEC PGM=IEFBR14 - not a JCL procedure
  • J####00 will execute immediately upon being 'released' from hold status
  • G#### job dependency chain will begin to execute only upon completion of J####00
Enter the following while viewing hlq.JCL(JOB14B):

submit ; =sd ; jg

Try the Job Group Action Characters to observe differences
  • JP now includes unique JES2 JobIDs with dependency JES2 JobIDs
  • DJ now includes unique JES2 JobIDs with job status and completion status
From SDSF enter
st
Observe:
  • J#####00 in Status HOLD
  • Several J####?? jobs in queue SETUP
  • However, one of the J####?? jobs is in queue PRINT
      - this is a big hint about the correction needed to JEC statement stream
      - check the dependency diagram in the instructions above

From SDSF ST panel enter a to the left of J####00 as follows to 'release' the job:

Following completion of J####00, then the other job names with dependencies will run

Note: It may take a minute or so for the order of the jobs and the Queue to match the above display.

Check the Job Group from SDSF as follows:

=sd ; jg

Observe:
  • JOBGROUP Status is Complete
  • Current-CC is ABENDU4038

Select s G#### and observe the messages in the JOBGROUP log to determine which jobname ended with ABEND=U4038

According to the dependency diagram above in the instructions, what job name should run last? A correction is needed in JOB14A JEC statement stream to avoid the abend


If the JOBGROUP has a program abend, then:

  • from SDSF jg panel, enter c to the left of G#### to cancel the JOBGROUP
  • from SDSF jg panel, enter p to the left of G#### to purge the jobs and the JOBGROUP
    NOTE: purge might take a minute or two to complete.
      Do NOT proceed until G#### is purged from queue.
  • tso submit 'zos.public.jcl(fsocx)'
      above JCL resets the application input and output data sets to the original state
  • Edit JOB14A
    correct the JEC statement stream to be consistent with the dependency diagram
       view the other JEC statements and observe AFTER JEC dependency operands
       the correction is to insert 1 JEC statement in the JOBGROUP stream of statements
    submit
      The above submit of JOB14A established the JES JOBGROUP dependencies.
    tso submit jcl(job14b)
      The above submit of JOB14B put the JCL jobs in the queue for execution using established JOBGROUP dependencies.
  • from SDSF ST panel, release a J####00
  • from SDSF JG, select s G#### JOBGROUP log

If the JOBGROUP log reads that all jobs completed successfully, then:

  • from SDSF jg panel, enter xdc to the left of G#### as follows:

    Another panel appears and enter the following to write the G#### JOBGROUP log to hlq.P2.OUTPUT(#14)

  • from SDSF jg panel, enter c to the left of G#### to cancel the jobs and the JOBGROUP
  • from SDSF jg panel, enter p to the left of G#### to purge the jobs and the JOBGROUP
    NOTE: purge might take a minute or two to complete

z/OS JES2 Execution Control Statements

You'll find the output from this challenge is stored in P2.OUTPUT(#14). Well done! You are quickly reaching the end of part two!

Next: Challenge #15