JCL - Traitement conditionnel

Le Job Entry System utilise deux approches pour effectuer un traitement conditionnel dans un JCL. Lorsqu'un travail se termine, un code retour est défini en fonction de l'état de l'exécution. Le code retour peut être un nombre compris entre 0 (exécution réussie) et 4095 (une condition d'erreur différente de zéro). Les valeurs conventionnelles les plus courantes sont:

0 = Normal - tout est OK
4 = Avertissement - erreurs ou problèmes mineurs.
8 = Erreur - erreurs ou problèmes importants.
12 = Erreur grave - erreurs ou problèmes majeurs, les résultats ne doivent pas être fiables.
16 = Erreur de terminal - problèmes très graves, n'utilisez pas les résultats.

L'exécution d'une étape de travail peut être contrôlée en fonction du code retour de la ou des étapes précédentes à l'aide du COND paramètre et IF-THEN-ELSE construct, qui a été expliqué dans ce tutoriel.

Paramètre COND

UNE CONDLe paramètre peut être codé dans l'instruction JOB ou EXEC de JCL. Il s'agit d'un test sur le code retour des étapes de travail précédentes. Si le test est évalué comme vrai, l'exécution de l'étape de travail en cours est ignorée. Le contournement est simplement une omission de l'étape de travail et non une interruption anormale. Il peut y avoir au plus huit conditions combinées dans un seul test.

Syntaxe

Voici la syntaxe de base d'un paramètre JCL COND:

COND=(rc,logical-operator)
or
COND=(rc,logical-operator,stepname)
or
COND=EVEN
or 
COND=ONLY

Voici la description des paramètres utilisés:

rc : Ceci est le code retour
logical-operator : Cela peut être GT (supérieur à), GE (supérieur ou égal à), EQ (égal à), LT (inférieur à), LE (inférieur ou égal à) ou NE (différent de).
stepname : Il s'agit de l'étape du travail dont le code retour est utilisé dans le test.

Les deux dernières conditions (a) COND = EVEN et (b) COND = ONLY, ont été expliquées ci-dessous dans ce tutoriel.

Le COND peut être codé à l'intérieur de l'instruction JOB ou de l'instruction EXEC, et dans les deux cas, il se comporte différemment comme expliqué ci-dessous:

Instruction COND inside JOB

Lorsque COND est codé dans l'instruction JOB, la condition est testée pour chaque étape du travail. Lorsque la condition est vraie à une étape de travail particulière, elle est contournée avec les étapes de travail qui la suivent. Voici un exemple:

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID,COND=(5,LE)
//*
//STEP10 EXEC PGM=FIRSTP  
//* STEP10 executes without any test being performed.

//STEP20 EXEC PGM=SECONDP 
//* STEP20 is bypassed, if RC of STEP10 is 5 or above. 
//* Say STEP10 ends with RC4 and hence test is false. 
//* So STEP20 executes and lets say it ends with RC16.

//STEP30 EXEC PGM=SORT
//* STEP30 is bypassed since 5 <= 16.

COND dans l'instruction EXEC

Lorsque COND est codé dans l'instruction EXEC d'une étape de travail et trouvé vrai, seule cette étape de travail est contournée et l'exécution se poursuit à partir de l'étape de travail suivante.

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)
//* In STP02, condition evaluates to TRUE and step bypassed.

//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),(10,GT,STP02))
//* In STP03, first condition fails and hence STP03 executes. 
//* Since STP02 is bypassed, the condition (10,GT,STP02) in 
//* STP03 is not tested.

COND = MÊME

Lorsque COND = EVEN est codé, l'étape de travail en cours est exécutée, même si l'une des étapes précédentes se termine anormalement. Si une autre condition RC est codée avec COND = EVEN, alors l'étape de travail s'exécute si aucune des conditions RC n'est vraie.

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)
//* In STP02, condition evaluates to TRUE and step bypassed.

//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),EVEN)
//* In STP03, condition (10,LT,STP01) evaluates to true,
//* hence the step is bypassed.

COND = UNIQUEMENT

Lorsque COND = ONLY est codé, l'étape de travail en cours est exécutée uniquement lorsque l'une des étapes précédentes se termine anormalement. Si une autre condition RC est codée avec COND = ONLY, alors l'étape de travail s'exécute si aucune des conditions RC n'est vraie et si l'une des étapes de travail précédentes échoue anormalement.

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(4,EQ,STP01)
//* In STP02, condition evaluates to FALSE, step is executed 
//* and assume the step abends.

//STP03 EXEC PGM=IEBGENER,COND=((0,EQ,STP01),ONLY)
//* In STP03, though the STP02 abends, the condition 
//* (0,EQ,STP01) is met. Hence STP03 is bypassed.

Construction IF-THEN-ELSE

Une autre approche pour contrôler le traitement du travail consiste à utiliser des constructions IF-THEN-ELSE. Cela donne plus de flexibilité et un moyen convivial de traitement conditionnel.

Syntaxe

Voici la syntaxe de base d'une construction JCL IF-THEN-ELSE:

//name IF condition THEN
list of statements //* action to be taken when condition is true
//name ELSE 
list of statements //* action to be taken when condition is false
//name ENDIF

Voici la description des termes utilisés dans la construction IF-THEN-ELSE ci-dessus:

name : Ceci est facultatif et un nom peut comporter de 1 à 8 caractères alphanumériques commençant par l'alphabet, #, $ ou @.
Condition : Une condition aura un format: KEYWORD OPERATOR VALUE, où KEYWORDSpeut être RC (code de retour), ABENDCC (code d'achèvement du système ou de l'utilisateur), ABEND, RUN (exécution de l'étape démarrée). UnOPERATOR peut être un opérateur logique (AND (&), OR (|)) ou un opérateur relationnel (<, <=,>,> =, <>).

Exemple

Voici un exemple simple montrant l'utilisation de IF-THEN-ELSE:

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//PRC1   PROC
//PST1	   EXEC PGM=SORT
//PST2	   EXEC PGM=IEBGENER
//       PEND
//STP01  EXEC PGM=SORT 
//IF1    IF STP01.RC = 0 THEN
//STP02     EXEC PGM=MYCOBB1,PARM=123
//       ENDIF
//IF2    IF STP01.RUN THEN
//STP03a    EXEC PGM=IEBGENER
//STP03b    EXEC PGM=SORT
//       ENDIF
//IF3    IF STP03b.!ABEND THEN
//STP04     EXEC PGM=MYCOBB1,PARM=456
//       ELSE
//       ENDIF
//IF4    IF (STP01.RC = 0 & STP02.RC <= 4) THEN
//STP05     EXEC PROC=PRC1
//       ENDIF
//IF5    IF STP05.PRC1.PST1.ABEND THEN
//STP06     EXEC PGM=MYABD
//       ELSE
//STP07     EXEC PGM=SORT
//       ENDIF

Essayons d'examiner le programme ci-dessus pour le comprendre un peu plus en détail:

Le code retour de STP01 est testé dans IF1. S'il vaut 0, alors STP02 est exécuté. Sinon, le traitement passe à l'instruction IF suivante (IF2).
Dans IF2, si STP01 a commencé l'exécution, alors STP03a et STP03b sont exécutés.
Dans IF3, si STP03b n'ABEND, alors STP04 est exécuté. Dans ELSE, il n'y a aucune déclaration. Cela s'appelle une instruction NULL ELSE.
En IF4, si STP01.RC = 0 et STP02.RC <= 4 sont TRUE, alors STP05 est exécuté.
Dans IF5, si l'étape de processus PST1 dans PROC PRC1 dans l'étape de travail STP05 ABEND, alors STP06 est exécuté. Sinon, STP07 est exécuté.
Si IF4 est évalué à faux, alors STP05 n'est pas exécuté. Dans ce cas, IF5 ne sont pas testés et les étapes STP06, STP07 ne sont pas exécutées.

Le IF-THEN-ELSE ne sera pas exécuté en cas d'arrêt anormal du travail tel que l'annulation du travail par l'utilisateur, l'expiration du temps du travail ou un ensemble de données est référencé en arrière vers une étape qui est contournée.

Définition des points de contrôle

Vous pouvez définir un jeu de données de point de contrôle dans votre programme JCL en utilisant SYSCKEOV, qui est une instruction DD.

UNE CHKPTest le paramètre codé pour les ensembles de données QSAM multi-volumes dans une instruction DD. Lorsqu'un CHKPT est codé comme CHKPT = EOV, un point de contrôle est écrit dans l'ensemble de données spécifié dans l'instruction SYSCKEOV à la fin de chaque volume de l'ensemble de données multi-volumes d'entrée / sortie.

//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01     EXEC PGM=MYCOBB
//SYSCKEOV  DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1       DD DSN=SAMPLE.IN,DISP=SHR
//OUT1      DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
//          CHKPT=EOV,LRECL=80,RECFM=FB

Dans l'exemple ci-dessus, un point de contrôle est écrit dans l'ensemble de données SAMPLE.CHK à la fin de chaque volume de l'ensemble de données de sortie SAMPLE.OUT.

Redémarrer le traitement

Vous pouvez redémarrer le traitement de l'éther de manière automatisée en utilisant le RD parameter ou manuel en utilisant le RESTART parameter.

RD parameter est codé dans l'instruction JOB ou EXEC et facilite le redémarrage automatisé du JOB / STEP et peut contenir l'une des quatre valeurs: R, RNC, NR ou NC.

RD=R autorise les redémarrages automatisés et considère le point de contrôle codé dans le paramètre CHKPT de l'instruction DD.
RD=RNC autorise les redémarrages automatisés, mais remplace (ignore) le paramètre CHKPT.
RD=NRindique que le travail / l'étape ne peut pas être redémarré automatiquement. Mais lorsqu'il est redémarré manuellement à l'aide du paramètre RESTART, le paramètre CHKPT (le cas échéant) sera pris en compte.
RD=NC interdit le redémarrage automatique et le traitement des points de contrôle.

S'il est nécessaire d'effectuer un redémarrage automatique pour des codes de fin anormale spécifiques uniquement, cela peut être spécifié dans le SCHEDxx membre de la bibliothèque IBM System parmlib.

RESTART parameterest codé dans l'instruction JOB ou EXEC et facilite le redémarrage manuel du JOB / STEP après l'échec du travail. RESTART peut être accompagné d'un checkid, qui est le point de contrôle écrit dans l'ensemble de données codé dans l'instruction SYSCKEOV DD. Lorsqu'un checkid est codé, l'instruction SYSCHK DD doit être codée pour référencer l'ensemble de données de point de contrôle après l'instruction JOBLIB (le cas échéant), sinon après l'instruction JOB.

//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID,RESTART=(STP01,chk5)
//*
//SYSCHK    DD DSN=SAMPLE.CHK,DISP=OLD
//STP01     EXEC PGM=MYCOBB
//*SYSCKEOV	DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1       DD DSN=SAMPLE.IN,DISP=SHR
//OUT1      DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
//          CHKPT=EOV,LRECL=80,RECFM=FB

Dans l'exemple ci-dessus, chk5 est le checkid, c'est-à-dire que STP01 est redémarré au point de contrôle5. Veuillez noter qu'une instruction SYSCHK est ajoutée et l'instruction SYSCKEOV est commentée dans le programme précédent expliqué dans la section Définition du point de contrôle.