Paramètre pour un job

[sam01]

Bonjour à tous,

je dois passer un job via TWS et ce job doit avoir un paramétrage spécial à chaque passage.

C'est un valeur qui apparaît à plusieurs endroits et cette valeur nous est donnée par ma maîtrise d'ouvrage.

j'aimerais savoir s'il est possible de trouver un moyen d'automatiser cette valorisation ?

Au lieu de rentrer dans le JCL et changer la valeur XXXX par APPU par un CHANGE ALL, j'aimerais trouver un moyen plus automatique.

Comment faîtes-vous dans votre société ?

Merci.

[bernard59139]

Bonjour

les variables OPC sont là pour ca.

Associées à une WS de préparation "job setup=yes", et des variables définies en "prompt=yes", ca roule.
Une fois l'application au plan, l'application est bloquée, interrogeable en 4.1

J'ai vu ce fonctionnement dans de nombreuses prod.

[sam01]

Bonjour bernard59139,

le souci c'est que dans mon cas, ce n'est pas forcément une variable OPC...

Par exemple, pour une application hebdomadaire.

On doit attendre, l'information venant de la maîtrise d'ouvrage (donc l'application doit être bloqué). Ensuite, quand la DMOP nous donne la valeur (qui n'est pas forcément une valeur OPC (ça peut être MAJ=OUI ou encore VOL=9999), je dois inscrire cette variable et elle doit apparaître partout dans le JCL ou il y a la variable.

Pourrais-tu me donner plus de détail sur la fonction : job setup=yes

et aussi sur le prompt yes...

Aurais-tu un cas concret ?

Merci.

[BernardBZH]

Bonjour,

Si j'ai bien compris la question de sam01, je pense qu'il serait possible de coder en tête de JCL une carte INCLUDE faisant référence à un membre (figurant dans la PROCLIB ou dans tout autre PDS défini par une JCLLIB) dans lequel seraient définies les variables symboliques du JCL. Une fois reçues les informations attendues, il suffit de modifier ledit membre.

Pour être plus clair :

Code :

1
2
3
4
5
6
7
//JCLLIB   JCLLIB ORDER=(MON.PDS.PARAM)
//ENVIRON  INCLUDE MEMBER=PARAMS                                      
//....
//STEPXXXX EXEC PGM=TOTO
//SYSOUT    DD SYSOUT=*
//DDN00001  DD DISP=SHR,DSN=&DSN00001.

Dans le code ci-dessus PARAMS est membre du PDS MON.PDS.PARAM et on y trouve par exemple :

Code :

1
2
//PARM SET DSN00001='MON.DSNAME',                                            
//         PARMXXXX='VALEURXXX'

Voila. J'espère ne pas avoir été hors sujet.

[sam01]

Bonjour BernardBZH, tu n'es pas du tout hors sujet. c'est même très intéressant ce que tu proposes.

Est-ce que ça fonctionne si les variables sont dans des sysin ?

[BernardBZH]

Bonjour Sam01,

Hélas non. On a toujours cette limitation de l'interdiction de variables symboliques dans une SYSIN.

Pour remédier à ce problème, sur chaque site où je suis intervenu j'ai trouvé des petits programmes (en assembleur ou en COBOL) qui codaient le contenu de la SYSIN dans un fichier temporaire à partir des variables symboliques qui leur étaient passées en paramètres. La SYSIN est ensuite codée :

Code :

//SYSIN DD DSN=&&DSNTEMP,DISP=(OLD,DELETE)

au lieu de :

Code :

//SYSIN DD *

Voici un exemple de programme COBOL qui permet de générer le fichier pris pour la SYSIN :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
       IDENTIFICATION DIVISION.                                   
       PROGRAM-ID. PARMSYS.                                      
       AUTHOR. XXXXXXXX.                                         
      *----------------------------------------------------------*
      * SERT A PRENDRE LE CONTENU D'UN PARM ET A L'ECRIRE SUR     
      * UN FICHIER.  POUR PARAMETRES SYMBOLIQUES DE PROCEDURES    
      * A PASSER EN SYSIN DU LINK PAR EXEMPLE OU DU TRI ETC...    
      * LE CARACTERE § EST LA FIN LOGIQUE DE LIGNE                
      *----------------------------------------------------------*
       ENVIRONMENT DIVISION.                                      
       INPUT-OUTPUT SECTION.                                      
       FILE-CONTROL.                                              
           SELECT OUT      ASSIGN TO UT-S-OUT.                    
       DATA DIVISION.                                             
       FILE SECTION.                                              
       FD  OUT                                                    
           RECORDING F                                            
           BLOCK 0 RECORDS                                        
           LABEL RECORD STANDARD.                                 
       01  ENROUT.                                                
           05  ENRCAR           PIC   X OCCURS 80.                
       WORKING-STORAGE SECTION.                             
       01  ZWS.                                             
         05  I                  PIC   S9(2) VALUE ZERO COMP.
         05  J                  PIC   S9(2) VALUE ZERO COMP.
       LINKAGE SECTION.                                     
       01  PARM.                                            
          05  LL                PIC   S9(4) COMP.           
          05  PARMCAR           PIC   X OCCURS 100.         
       PROCEDURE DIVISION       USING PARM.                 
           OPEN OUTPUT OUT                                  
           MOVE ZERO       TO RETURN-CODE.                  
           IF  LL     =  0 GO ERREUR.                       
           MOVE SPACE      TO   ENROUT                      
           PERFORM VARYING I FROM 1 BY 1 UNTIL I > LL       
               IF  PARMCAR(I) = '§' THEN                    
                   PERFORM ECRIRE                           
                   MOVE    0      TO J                      
               ELSE                                         
                   ADD     1      TO J                      
                   IF      J      >  80                     
                           GO     ERREUR                    
                   ELSE                                     
                           MOVE   PARMCAR(I) TO ENRCAR(J)
                   END-IF                                
               END-IF                                    
           END-PERFORM.                                  
      *                                                  
       ECRIRE.                                           
               WRITE ENROUT                              
               MOVE SPACE      TO   ENROUT.              
       ECRIRE-F. EXIT.                                   
           GO  FIN.                                      
      *                                                  
       ERREUR.                                           
               DISPLAY  'AUCUN PARAMETRE EN ENTREE'      
               DISPLAY  'OU LIGNE LOGIQUE > 80 CAR'      
               DISPLAY  '***** ARRET IMMEDIAT ****'      
               MOVE 16         TO RETURN-CODE.           
       FIN.                                              
               CLOSE OUT.                                
           GOBACK.

Et voici un exemple d'appel de ce programme :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
//PARMS SET DSN01='MON.FICHIER.A.TRAITER'
//*
//GENSYS02 EXEC PGM=PARMSYS,                                        
//         PARM=' DELETE &DSN01. SCRATCH § SET MAXCC=0'              
//STEPLIB  DD DSN=MON.PDS.DE.LOADS,DISP=SHR                          
//SYSOUT   DD SYSOUT=*                                               
//OUT      DD DSN=&&DELETE,DISP=(,PASS),SPACE=(TRK,1),UNIT=SYSDA     
//* =================================================================
//DELETE01 EXEC PGM=IDCAMS                                           
//SYSPRINT DD SYSOUT=*                                               
//SYSIN    DD DSN=&&DELETE,DISP=(OLD,DELETE)

Il y a peut être ce genre de programme là où tu es. Sinon le code ci-dessus est copyleft

[sam01]

Merci BernardBZH pour toutes ces informations,

pardon d'insister mais si j'ai bien compris en tête de chaque JCL, je dois mettre ce code :

Code :

1
2
3
4
5
6
7
8
9

//PARMS SET DSN01='MON.FICHIER.A.TRAITER'
//*
//GENSYS02 EXEC PGM=PARMSYS,                                        
//         PARM=' DELETE &DSN01. SCRATCH § SET MAXCC=0'              
//STEPLIB  DD DSN=MON.PDS.DE.LOADS,DISP=SHR                          
//SYSOUT   DD SYSOUT=*                                               
//OUT      DD DSN=&&DELETE,DISP=(,PASS),SPACE=(TRK,1),UNIT=SYSDA

0 quoi correspond cette ligne

Code :

1
2
//         PARM=' DELETE &DSN01. SCRATCH § SET MAXCC=0'

et si la sysin fait plusieurs lignes à variabiliser ?

Sans vouloir abuser, aurais-tu un exemple avec 2 ou 3 sysin différentes afin que je saisisse bien le fonctionnement ?

Merci

[BernardBZH]

Bonjour Sam01 (et aux autres par la même occasion),

Tu n'abuses pas du tout et on est là pour se donner des coups de main.

Le programme servant à générer les SYSIN que je te proposais dans une précédente réponse peut être appelé à tout moment dans ton JCL. En tête de JCL tu dois seulement décrire les paramètres que tu utilises dans tes différents STEP.

Le programme que je te propose s'appelle PARMSYS avec un LOAD du même nom qui se trouve dans le PDS de LOAD adéquat.

Le PARM='xxxxx' contient le masque de ta SYSIN que mettra en forme le programme PARMSYS.

Exemple d'une PROC nommée EXEDB2 qui me sert pour exécuter des programmes DB2 :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//EXEDB2   PROC LOAD=&LOAD.,                                          
//             PLAN=&LOAD.                                            
//* ==========================================                        
//GENSYS01 EXEC PGM=PARMSYS,                                         
//  PARM='DSN SYSTEM (NBB) § RUN PROGRAM (&LOAD.) PLAN (&PLAN.) § END'
//SYSOUT   DD SYSOUT=*                                                
//OUT      DD DSN=&&SYSTSIN,DISP=(,PASS),SPACE=(TRK,1),UNIT=SYSDA     
//* ==========================================                        
//EXEDB2   EXEC PGM=IKJEFT01                                          
//SYSPRINT DD SYSOUT=*                                                
//SYSUDUMP DD SYSOUT=Z                                                
//SYSOUT   DD SYSOUT=*                                                
//SYSABOUT DD SYSOUT=*                                                
//SYSDBOUT DD SYSOUT=*                                                
//SYSTSPRT DD SYSOUT=*                                                
//SYSTSIN  DD DSN=&&SYSTSIN,DISP=(OLD,DELETE)

Dans mon JCL, j'appelle cette PROC de la manière suivante :

Code :

1
2
3
4
5
//STEP0001 EXEC EXEDB2,LOAD=MONLOAD
//EXEDB2.B DD DUMMY  <== pour que les fichiers qui suivent soient liés au STEP EXEDB2 de la PROC                
//SYSOUT   DD SYSOUT=*              
//DDN00001 DD DSN=MON.FICHIER.FINAL
// ...

A l'exécution, la PROC reçoit le paramètre LOAD et le programme PARMSYS construit un fichier temporaire nommé SYSTSIN qui contient ce qui suit :

Code :

1
2
3
4
DSN SYSTEM (NBB) 
RUN PROGRAM (MONLOAD) PLAN (MONLOAD)
END

Si je n'avais pas utilisé la PROC en question j'aurais codé dans mon JCL :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
//STEP0001 EXEC PGM=IKJEFT01                                          
//SYSPRINT DD SYSOUT=*                                                
//SYSUDUMP DD SYSOUT=Z                                                
//SYSOUT   DD SYSOUT=*                                                
//SYSABOUT DD SYSOUT=*                                                
//SYSDBOUT DD SYSOUT=*                                                
//SYSTSPRT DD SYSOUT=*                                                
//SYSTSIN  DD *
DSN SYSTEM (NBB) 
RUN PROGRAM (MONLOAD) PLAN (MONLOAD)
END
/*

Le caractère "§" indique au programme PARMSYS qu'il faut créer un nouvel enregistrement dans le fichier.
Tu peux aussi lancer le programme PARMSYS plusieurs fois pour générer des lignes supplémentaires dans une même SYSIN en codant DISP=MOD sur le fichier de DDNAME OUT.

Dans l'exemple de ma réponse précédente

Code :

1
2
3
4
5
6
7
8
9
10
11
//PARMS SET DSN01='MON.FICHIER.A.TRAITER'
//*
//GENSYS02 EXEC PGM=PARMSYS,                                        
//         PARM=' DELETE &DSN01. SCRATCH § SET MAXCC=0'              
//STEPLIB  DD DSN=MON.PDS.DE.LOADS,DISP=SHR                          
//SYSOUT   DD SYSOUT=*                                               
//OUT      DD DSN=&&DELETE,DISP=(,PASS),SPACE=(TRK,1),UNIT=SYSDA
//*
//DELETE01 EXEC PGM=IDCAMS                                           
//SYSPRINT DD SYSOUT=*                                               
//SYSIN    DD DSN=&&DELETE,DISP=(OLD,DELETE)

on peut imaginer une PROC nommée DELETE dans laquelle figurerait uniquement le STEP exécutant PARMSYS et qui serait appelée de la façon suivante

Code :

1
2
3
4
5
6
7
8
9
//PARMS SET DSN01='MON.FICHIER.A.TRAITER'
//*
//.....
//DELETE01 EXEC DELETE,DSN01=&DSN01.
//*
//STEP0001 EXEC PGM=TOTO
//SYSOUT=*
//DDN00001 DSN=&DSN01.,DISP=...
//...

La PROC DELETE générerait un fichier temporaire nommé &&DELETE contenant

Code :

1
2
3
DELETE MON.FICHIER.A.TRAITER SCRATCH
SET MAXCC=0

D'accord ça ne sert à rien et c'est plus simple de coder le DELETE IDCAMS en direct mais c'était juste pour l'exemple.

Voila. J'espère t'avoir été utile et n'hésite pas à revenir si je n'ai pas été assez clair.

Mes excuses à tous si mes réponses prennent un peu de place ...

[sam01]

Super BernardBZH, merci pour tous ces détails !