- Job Control Language
-
Job Control Language (Language de Contrôle des Tâches), couramment appelé JCL désigne certains langages de scripts, en particulier sur les systèmes d'exploitation mainframe d'IBM, dont le rôle est d'exécuter un batch.
Il existe deux langages JCL d'IBM, l'un utilisé sur la famille DOS/360, l'autre sur la famille OS/360. Bien qu'ils aient en commun des règles de syntaxe et de conception, il s'agit de langages assez différents.
Sommaire
Points communs aux JCLs DOS et OS
Conception
Dans le JCL, l'unité est le job (tâche), laquelle consiste en un ou plusieurs step (étapes). Chaque step consiste en l'exécution d'un programme spécifique. Ainsi, un job qui consisterait à créer un rapport pourrait être composé des steps suivants :
- sélection des enregistrements voulus à l'aide d'un programme et stockage des résultats dans un fichier temporaire ;
- tri des résultats à l'aide d'un utilitaire approprié ;
- création du rapport proprement dit à l'aide d'un autre programme qui fait le calcul (cumuls, etc.) et la mise en forme des informations voulues ;
- affichage du rapport, etc.
Le JCL utilise des identifiants basiques que l'on nomme « cartes ». Un script JCL devra débuter par la carte JOB qui permet notamment :
- de donner un nom au job ;
- d'identifier le groupe qui recevra le rapport d'exécution ;
- de définir comment le job doit être exécuté (par exemple sa priorité)
Il est possible de créer des scripts JCL qui pourront être appelés dans d'autres scripts JCL en passant si nécessaire des paramètres. De tels scripts sont appelées procédures.
Syntaxe
La syntaxe du JCL comparée à la plupart des langages de batch, est assez lourde. Par exemple, si on désire copier un fichier dans un autre sous MS-DOS ou UNIX, il suffit d'écrire une instruction du style :
copy fichier1 fichier2
or en JCL OS, pour obtenir le même résultat il faudrait écrire quelque chose comme :
//IS198CPY JOB (IS198T30500),'COPY JOB',CLASS=L,MSGCLASS=X //COPY01 EXEC PGM=IEBGENER //SYSPRINT DD SYSOUT=* //SYSUT1 DD DSN=FICHIER1,DISP=SHR //SYSUT2 DD DSN=FICHIER2, // DISP=(NEW,CATLG,DELETE), // SPACE=(CYL,(40,5),RLSE), // DCB=(LRECL=115,BLKSIZE=1150) //SYSIN DD DUMMY
Cette lourdeur est due à quelques facteurs.
- D'une part le JCL a été développé pour des ordinateurs des années 1960, limités en termes de mémoire et d'instructions par seconde. Que les instructions soient plus faciles à être interprétées pour la machine (et donc plus rapides à exécuter) était un objectif considéré comme plus important qu'avoir des instructions faciles à coder pour le programmeur.
- D'autre part, les systèmes /360 ont été conçus dans un esprit multi-utilisateur. Il fallait donc transmettre des paramètres permettant par exemple d'identifier qui devait recevoir les rapports d'exécution (ici le compte IS198T30500), quelle était la priorité de la tâche (CLASS), s'il fallait verrouiller ou non les fichiers lus par les programmes durant leur exécution (DISP), etc.
IBM a gardé la syntaxe originelle du JCL de manière à ce que les anciens scripts puissent toujours être exécutés, mais a également introduit des alternatives plus faciles à utiliser pour le programmeur comme CLIST. La possibilité d'utiliser des procédures paramétrables est également une manière de contourner en partie la lourdeur de la syntaxe.
Les lignes des scripts JCL sont limités à 80 caractères. Il s'agit d'un héritage du temps où les programmes s'écrivaient à l'aide de cartes perforées de 80 colonnes. Tout ce qui est écrit au delà du 80e caractère est ignoré par le système d'exploitation. En réalité, seuls les 71 premiers caractères sont réellement pris en compte et utilisables par le programmeur. Le 72e caractère consiste usuellement en un espace, et les caractères 73 à 80 sont réservés pour la numérotation des lignes.
Toutes les lignes, à l'exception des flots d'entrée, doivent commencer par un slash (/), et toutes les lignes contenant les processus du système d'exploitation doivent débuter par deux slashs (//) devant toujours commencer en colonne 1. Il existe deux exceptions à cette règle : le délimiteur (/*), et le commentaire (//*).
Beaucoup d'instructions JCL sont trop longues pour tenir sur 71 caractères, mais peuvent être prolongées sur un nombre non-défini de lignes.
La syntaxe générale d'une instruction JCL est :
//NOM CARTE PARAMETRES
Les paramètres sont séparés par des virgules (,) sans espace.
Flots d'entrée
Le JCL permet les flots d'entrée, c'est-à-dire des cartes qui seront utilisés directement par les programmes appelées et pas le système d'exploitation directement.
Bien que le JCL DOS et OS ne définissent pas les flots d'entrées de la même façon, ils les délimitent tous deux par un slash-étoile (/*) en colonne 1.
Les flots, ainsi que les fichiers entrée/sortie, peuvent être décrits à l'aide de la carte DD (qui inspirera plus tard l'utilitaire dd d'UNIX).
Points particuliers au JCL DOS
Paramètres positionnels
En JCL DOS, les paramètres sont positionnels. L'ordre d'entrée des paramètres est donc extrêmement important, et même l'emplacement destiné aux paramètres optionnels doivent être remplis au moyen de virgules si le programmeur ne les utilise pas.
Ceci est illustré par l'exemple ci-dessous :
// TLBL TAPEFIL,'COPYTAPE.JOB',,,,2 // ASSGN SYS005,DISK,VOL=VOL01,SHR // DLBL DISKFIL,'COPYTAPE.JOB',0,SD // EXTENT SYS005,VOL01,1,0,800,16
Dépendance du matériel
Dans la version originale de DOS/360 ainsi que dans la plupart des versions de DOS/VS, il fallait spécifier le numéro de modèle du matériel utilisé pour lire chaque disque ou cassette, y compris pour les fichiers temporaires. Changer le matériel signifiait donc devoir modifier de nombreux scripts JCL.
Points particuliers au JCL OS
De manière générale, le JCL des familles OS/360 est plus flexible et plus facile à utiliser que le JCL des familles DOS/360.
Cartes basiques
Le JCL OS ne comporte que trois cartes basiques :
- la carte JOB, qui permet d'identifier le job et de fournir des informations qui lui sont relatives ;
- la carte EXEC, qui permet à chaque step d'identifier quel programme appeler ;
- la carte DD qui permet d'identifier les fichiers ou flots à utiliser au cours d'un step.
Paramètres à mots-clefs
Le JCL OS utilise également des paramètres à mots-clefs, ce qui signifie que l'ordre de passage des paramètres importe peu et qu'il n'est pas nécessaire d'entrer les paramètres optionnels si ceux-ci ne servent pas.
Par exemple :
//NEWFILE DD DSN=MYFILE01,UNIT=DISK,SPACE=(TRK,80,10), // DCB=(LRECL=100,BLKSIZE=1000), // DISP=(NEW,CATLG,DELETE)
De nombreux mots-clefs (DSN, UNIT, SPACE, etc.) permettent de passer les paramètres relatifs au fichier NEWFILE.
Indépendance vis-à-vis du matériel
En JCL OS, le matériel peut être déclaré via des termes génériques du style TAPE ou DISK, ce qui offre une indépendance relative vis-à-vis du matériel.
Procédures paramétrables
Le JCL OS permet de créer des procédures paramétrables, ce qui permet de créer des scripts faciles à réutiliser.
Les procédures sont déclarées au moyen de la carte PROC. Les paramètres sont indiqués au moyen de et-commerciaux (&) et une valeur par défaut peut être déclarée.
On peut par exemple créer une procédure de cette manière :
//MYPROC PROC FNAME=MYFILE01,SPTYPE=TRK,SPINIT=50,SPEXT=10,LR=100,BLK=1000 ..... //NEWFILE DD DSN=&FNAME,UNIT=DISK,SPACE=(&SPTYPE,&SPINIT,&SPEXT), // DCB=(LRECL=&LR,BLKSIZE=&BLK),DISP=(NEW,CATLG,DELETE) ....
Et l'appeler ainsi :
//JOB01 JOB .......... //STEP01 EXEC MYPROC FNAME=JOESFILE,SPTYPE=CYL,SPINIT=10,SPEXT=2,LR=100,BLK=2000
ou encore :
//JOB02 JOB .......... //STEP01 EXEC MYPROC FNAME=SUESFILE,SPTYPE=TRK,SPINIT=500,SPEXT=100,LR=100,BLK=5000
Exécution conditionnelle
Le JCL OS permet de conditionner l'exécution des steps en fonction des erreurs produites par les steps précédents. En effet, chaque step produit un code retour (COND), qui suit généralement cette norme :
- 0 : exécution normale
- 4 : erreur mineure
- 8 : erreur importante
- 12 : erreur majeure
- 16 : erreur très sérieuse
Le JCL OS permet de tester (ou modifier) la valeur de ce code erreur pour conditionner l'exécution du step suivant.
Ainsi dans le script JCL suivant :
//MYJOB JOB ........... //STEP01 EXEC PGM=PROG01 .... //STEP02 EXEC PGM=PROG02,COND=(4,GT,STEP01) .... //STEP03 EXEC PGM=PROG03,COND=(8,LE) .... //STEP04 EXEC PGM=PROG04,COND=(ONLY,STEP01) .... //STEP05 EXEC PGM=PROG05,COND=(EVEN,STEP03) ....
va :
- démarrer le step STEP01 qui exécute le programme PROG01
- si le code retour actuel est supérieur à 4, lancer STEP02
- si le code retour actuel est inférieur ou égal à 8, lancer STEP03
- si STEP01 n'a pas fini normalement, lancer STEP04
- lancer STEP05 même si STEP03 a fini anormalement
IBM a également introduit plus tard l'instruction IF qui permet de coder ces conditions un peu plus facilement.
Utilitaires JCL
IBM fournit avec ses installations mainframes divers utilitaires, lesquels peuvent être appelés lors d'un script JCL. Ils permettent souvent la gestion de datasets (copie, allocation, reformattage, etc.) ou permettent d'effectuer dessus des opérations diverses (tri, fusion, etc).
Parmi les plus couramment utilisés on peut citer :
- SORT (tri et fusion de fichiers séquentiels)
- IDCAMS (utilitaire de gestion de fichiers VSAM)
- IEBGENER (copie ou reformatage de fichiers)
- IEBCOPY (copie et fusion de fichiers PDS)
- IEBCOMP (comparaison de fichiers séquentiels ou partitionnés)
- IEBEDIT (permet de copier des portions de JCL)
- IEFBR14 (un faux-programme « dummy » invoqué pour allouer ou effacer des datasets)
Références
- (en) z/OS V1R6.0-V1R8.0 Guide Utilisateur MVS JCL
- (en) z/OS V1R7.0-V1R8.0 Référence MVS JCL
- (en) Doug Lowe and Raul Menendez, Murach's OS/390 and z/OS JCL
Wikimedia Foundation. 2010.
