AWS Le service de modernisation du mainframe (expérience de l'environnement d'exécution géré) n'est plus ouvert aux nouveaux clients. Pour des fonctionnalités similaires au service de modernisation AWS du mainframe (expérience de l'environnement d'exécution géré), explorez le service de modernisation AWS du mainframe (expérience autogérée). Les clients existants peuvent continuer à utiliser le service normalement. Pour plus d'informations, consultez la section [Modification de la disponibilité de la modernisation du AWS mainframe](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html). Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Utilitaires de jeux de ## BLUESAMCOPY/BLUESAMCREATE/BLUESAMDELETE/BLUESAMCLEAR Ces programmes utilitaires fournissent des fonctions essentielles de manipulation de jeux de données sur les ensembles de données [Blusam](https://docs.aws.amazon.com/m2/latest/userguide/ba-shared-blusam.html). L'`bypassBluesamStatus`indicateur (stocké dans JobContext) détermine s'il convient de contourner la validation normale de l'état du jeu de données qui empêche les conflits d'accès simultanés entre les processus en ligne et par lots. Quand `bypassBluesamStatus` est-ce vrai : + Ignore les vérifications d'état normales des ensembles de données pendant les opérations + Autorise l'accès à des ensembles de données qui pourraient normalement être bloqués ### COPIE BLUESAM Le programme BLUESAMCOPY copie la structure des données et des métadonnées d'un ensemble de données Bluesam à un autre. #### Parameters Le programme BLUESAMCOPY utilise deux paramètres : + `FROM=`- Ensemble de données source à partir duquel copier + `TO=`- Ensemble de données cible vers lequel copier #### Comportement + Si le jeu de données cible n'existe pas, il est créé avec la structure de métadonnées de la source + Si la cible existe, efface la cible avant de la copier (remplace les données existantes) + L'opération se poursuit lorsque les ensembles de données ne sont pas utilisés par les processus en ligne ou lorsqu'elle `bypassBluesamStatus` est définie sur true + Préserve les clés, la compression, la longueur d'enregistrement et les autres propriétés des métadonnées #### Gestion des erreurs Renvoie le code 1 si le jeu de données source n'existe pas ou si l'un des ensembles de données est utilisé par des processus en ligne. #### Utilisation de l'échantillon ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // copy bluesam dataset res = mpr.withArguments("FROM=MYBLUESAMTABLE","TO=MYBLUESAMTABLE2").runProgram("BLUESAMCOPY") ``` ### BLUESAMCREATE Le programme BLUESAMCREATE crée un jeu de données Bluesam avec les paramètres spécifiés. #### Parameters Le programme BLUESAMCREATE utilise sept paramètres : + `name=`- Ensemble de données à créer (obligatoire) + `compress=`- Activer la compression (facultatif, valeur par défaut : false) + `fixedLength=`- État des enregistrements de longueur fixe (facultatif, valeur par défaut : faux) + `recordLength=`- Longueur de l'enregistrement en octets (facultatif, valeur par défaut : -1) + `primaryKey=,duplicates=,fields=`- Spécification de la clé primaire (facultatif) + `key=,duplicates=,fields=`- Clé alternative (peut avoir plusieurs ou 0) + `clearExisting=true/false`- Efface le jeu de données existant (valeur par défaut facultative : true) Explications spécifiques des paramètres clés : + `duplicates`: si les doublons sont autorisés ou non pour la clé donnée ; + `fields`: positions des champs (base 1) et longueurs qui définissent la clé ; #### Comportement + Si le jeu de données n'existe pas, le crée avec les paramètres spécifiés + Si le jeu de données existe, l'efface si `clearExisting=true` + L'opération se poursuit lorsque les ensembles de données ne sont pas utilisés par les processus en ligne ou lorsqu'elle `bypassBluesamStatus` est définie sur `true` #### Conditions d'erreur Renvoie le code 0 dans tous les cas. #### Utilisation de l'échantillon ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // create bluesam dataset mpr.withArguments( "name=MYBLUESAMTABLE", "compress=FALSE", "fixedLength=true", "recordLength=54", "primaryKey=MYKEY_PK,duplicates=FALSE,fields=0,6") .runProgram("BLUESAMCREATE") ``` ### BLUESAMDELETE Le programme BLUESAMDELETE supprime les ensembles de données Bluesam. #### Parameters Le programme BLUESAMDELETE accepte un ou plusieurs paramètres : + ``- jeu de données à supprimer (peut en avoir plusieurs) #### Comportement + L'opération se poursuit lorsque les ensembles de données ne sont pas utilisés par les processus en ligne ou lorsqu'elle `bypassBluesamStatus` est définie sur `true` + Si le jeu de données existe, supprimez-le #### Conditions d'erreur Renvoie le code 0 dans tous les cas. #### Utilisation de l'échantillon ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // delete bluesam datasets res = mpr.withArguments("MYBLUESAMTABLE","MYBLUESAMTABLE2","MYBLUESAMTABLE3").runProgram("BLUESAMDELETE") ``` ### BLEU/SAM/CLAIR Le programme BLUESAMCLEAR supprime toutes les données des ensembles de données existants tout en préservant leur structure et leurs métadonnées. #### Parameters Le programme BLUESAMCLEAR prend un ou plusieurs paramètres : + ``- jeu de données à effacer (peut en avoir plusieurs) #### Comportement + L'opération se poursuit lorsque les ensembles de données ne sont pas utilisés par les processus en ligne ou lorsqu'elle `bypassBluesamStatus` est définie sur `true` + Si le jeu de données existe, supprimez-le #### Conditions d'erreur Renvoie le code 0 dans tous les cas. #### Utilisation de l'échantillon ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // clear bluesam datasets res = mpr.withArguments("MYBLUESAMTABLE","MYBLUESAMTABLE2").runProgram("BLUESAMCLEAR") ``` ## BPXWDYN Ce programme utilitaire simule le service z/OS BPXWDYN pour l'allocation et la désallocation dynamiques des ensembles de données. Dans les applications modernes, les allocations de fichiers sont effectuées dans des scripts Groovy via l'API `FileConfigurationUtils` Builder. Ce programme permet une gestion dynamique de ces allocations sans Groovy, ce qui est essentiel pour le traitement de fichiers interactif ou conditionnel dans les applications modernisées. ### Parameters L'ancien format des arguments est préservé. Exige un seul argument contenant un en-tête de 2 octets suivi de la chaîne de commande. format de chaîne de commande pour l'allocation : `ALLOC DD() DSN('') SHR?` format de chaîne de commande pour la désallocation : `FREE DD()` ### Gestion des erreurs + Définissez le code d'erreur 0 en cas de réussite, 1 en cas d'échec + Lance RuntimeException des commandes ou paramètres non valides ### Utilisation de l'échantillon Voici un exemple d'utilisation en Java du programme BPXWDYN, issu d'une modernisation du COBOL via AWS Transform : Le code COBOL : ``` 01 WK-AREA. 03 DS-ALLOC-STRING. 05 DS-LENGTH PIC S9(004) COMP VALUE 100. 05 DS-TEXT PIC X(100) VALUE "ALLOC DD(INFILE) DSN('A.B.JCLLIB(XYZ470)') SHR". ... 01 RC-RETURN-CODE-AREA. 03 RC-RETURN-CODE PIC S9(008) COMP. ... CALL 'BPXWDYN' USING DS-ALLOC-STRING RETURNING RC-RETURN-CODE. ``` et la modernisation Java correspondante : ``` private final Group dsAllocString = new Group(root).named("DS-ALLOC-STRING"); private final Elementary dsLength = new Elementary(dsAllocString,new BinaryType(4, 0, "STD", false, false, true),Short.valueOf("100")).named("DS-LENGTH"); private final Elementary dsText = new Elementary(dsAllocString,new AlphanumericType(100),"ALLOC DD(INFILE) DSN('A.B.JCLLIB(XYZ470)') SHR").named("DS-TEXT"); ... private final Group root = new Group(getData()).named("RC-RETURN-CODE-AREA"); private final Elementary rcReturnCode = new Elementary(root,new BinaryType(8, 0, "STD", false, false, true)).named("RC-RETURN-CODE"); ... // Call to utility program BPXWDYN ctrl.callSubProgram( "BPXWDYN", CallBuilder.newInstance().byReference(ctx.getWkArea().getDsAllocStringReference()).getArguments(), ctx); ctx.getRcReturnCodeArea().setRcReturnCode(NumberUtils.convert(ctx.getProgramReturned()).intValue()); ``` ## GDGUTILS GDGs (Generation Data Group) permet aux applications de travailler avec des ensembles de données versionnés où chaque exécution crée une nouvelle génération tout en conservant l'accès aux générations précédentes. Cet utilitaire crée et gère ces générations de jeux de données. Cet utilitaire est destiné à être appelé dans des scripts groovy. ### Parameters l'ordre des paramètres n'a pas d'importance + `action=`- Opération à effectuer (obligatoire) + `gdgname=`- Nom de la base GDG (obligatoire) + `storageProvider=`- Backend de stockage + `relativeGeneration=<+integer>`- Numéro de génération relatif (par exemple, \+1 pour la génération suivante) + `absoluteGeneration=integer`- Numéro de génération absolu + `recordLength=`- Taille de l'enregistrement dans le jeu de données + `fixedLength=`- Spécifie que les enregistrements ont une longueur fixe dans l'ensemble de données + `ownerPath=`- Le chemin pour stocker l'ensemble de données (spécifique au système de fichiers, obligatoire dans ce cas) + `compress=`- Indique que les données doivent rester compressées en mémoire si les données étaient compressées dans le magasin de données (spécifique à Bluesam) (facultatif, false est la valeur par défaut) + `catalog`- Spécifie le jeu de données à cataloguer (facultatif) + `warmUp`- Indique que l'ensemble de données doit être chargé en mémoire lors de son ouverture (spécifique à Bluesam) (facultatif) RelativeGeneration ou AbsoluteGeneration : l'une de ces propriétés doit être définie. ### Opérations + créer : crée une nouvelle génération de jeu de données GDG en fonction des métadonnées GDG (gère à la fois le système de fichiers et le stockage Bluesam) + refreshevents : ajuste le numéro de génération (métadonnées Gdg) sans créer de nouveaux ensembles de données (utilisé lors du redémarrage de tâches ayant échoué qui ont déjà créé des ensembles de données) ### Gestion des erreurs + Définissez le code d'erreur 0 en cas de réussite, 1 en cas d'échec + Lance RuntimeException des commandes ou paramètres non valides ### Utilisation de l'échantillon Opération de création de Gdg : le code suivant crée une génération bluesam (43) pour l'ensemble de données `IC.PLI.GDGTEST` ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) Map params = new Hashtable() params.put("jobContext", jobContext) Object[] args =["action=create","gdgname=IC.PLI.GDGTEST","absoluteGeneration=43","storageProvider=bluesam","recordLength=80"] mpr.withParameters(params).withArguments(args).runProgram("GDGUTILS") ``` Opération Gdg refreshevents : seule RelativeGeneration est pertinente pour cette opération. Le code suivant met à jour le numéro de génération (\+1 par rapport à la génération actuelle) pour l'`IC.PLI.GDGTEST`ensemble de données ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) Map params = new Hashtable() params.put("jobContext", jobContext) Object[] args =["action=refreshevents","gdgname=IC.PLI.GDGTEST","relativeGeneration=1","storageProvider=bluesam"] mpr.withParameters(params).withArguments(args).runProgram("GDGUTILS") ``` ## ICEGENER/SYNCGENR Ce programme utilitaire imite le comportement de l'utilitaire z/OS système ICEGENER, il copie les ensembles de données de l'entrée (SYSUT1 ensemble de données) vers la sortie (ensemble de données). SYSUT2 Cette implémentation Java fournit des fonctionnalités équivalentes prenant en charge à la fois le système de fichiers et le stockage Bluesam. ### Parameters Aucun argument ### Ensembles de données requis + SYSUT1: jeu de données/fichier d'entrée + SYSUT2: jeu de données/fichier de sortie ### Gestion des dispositions pour l' SYSUT2 ensemble de données + NOUVEAU : Création d'un nouveau jeu de données/fichier + OLD/SHR: Use existing dataset/file(doit exister) + MOD : modifier, créer s'il manque, ajouter s'il existe ### Gestion des erreurs + Définissez le code d'erreur 0 en cas de réussite de la copie, 1 en cas d'échec + Rejets en `IllegalStateException` cas d'utilisation non valide de l'ensemble de données Bluseam ### Utilisation de l'échantillon Voici un exemple d'utilisation groovy du programme ICEGENER, issu d'une modernisation de JCL via AWS Transform : Le code JCL : ``` //STEP01 EXEC PGM=ICEGENER //SYSUT1 DD DSN=POI.INPUT,DISP=SHR //SYSUT2 DD DSN=POI.OUTPU, // DISP=(,CATLG,DELETE), // UNIT=3490, // DCB=(RECFM=FB,LRECL=100) /* ``` et la modernisation correspondante de Groovy : ``` mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("SYSUT1") .dataset("POI.INPUT") .disposition("SHR") .build() .bluesam("SYSUT2") .dataset("POI.OUTPU") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("ICEGENER") ``` ## IDCAMS/KCAMS Ce programme utilitaire imite le comportement des anciens programmes IDCAMS, qui est un outil de gestion des données mainframe utilisé pour les opérations de fichiers VSAM (Virtual Storage Access Method). Il traite les anciennes commandes IDCAMS en conservant la même syntaxe que les entrées SYSIN d'origine. ### Contexte Le comportement du programme peut être configuré à l'aide de deux paramètres définis dans `application-utility-pgm.yml` : + JCLType : identifiant du type JCL (vse ou mvs). Les PRINT/REPRO commandes de l'utilitaire IDCAMS renvoient 4 si le fichier est vide pour un jcl non vse + forcedCharsetIdcams: remplacement facultatif du jeu de caractères pour le traitement IDCAMS ### Parameters Aucun argument. Les opérations sont transmises via le jeu de données SYSIN. ### Ensembles de données requis + SYSIN - Contient des instructions de commande IDCAMS + Ensembles de données d'entrée/sortie - Comme indiqué dans les commandes IDCAMS (selon la déclaration IDCAMS) ### Fonctionnalités principales/Commandes prises en charge Les détails sur les commandes IDCAMS présentes dans la carte de contrôle SYSIN ne sont pas donnés ici mais doivent être extraits des documentations des anciennes plateformes pertinentes existantes. + DEFINE - Crée des clusters et des ensembles de données VSAM + SUPPRIMER - Supprime les ensembles de données (prend en charge les caractères génériques) + REPRO - Copie les données entre les ensembles de données + IMPRIMER - Affiche le contenu du jeu de données + VERIFY : valide l'existence et l'intégrité de l'ensemble de données + ALTER - Modifie les attributs du jeu de données (renommage) + ALLOC - Alloue les ensembles de données de manière dynamique + SET - Gère les codes de condition (LASTCC/MAXCC) + IF-THEN-ELSE - Exécution conditionnelle des commandes + ANNULER - Met fin à l'exécution de la tâche ### Gestion des erreurs + Définissez le code d'erreur 0 si la dernière commande réussit, -1 en cas d'échec + Les commandes SET (LASTCC) peuvent être utilisées pour remplacer le code d'erreur, par ex. `SET LASTCC = 0` ### Utilisation de l'échantillon Voici un exemple d'utilisation groovy du programme IDCAMS, issu d'une modernisation de JCL via AWS Transform : Le code JCL : ``` //STEP15 EXEC PGM=IDCAMS //SYSPRINT DD SYSOUT=* //ACCTDATA DD DISP=SHR, // DSN=AWS.M2.CARDDEMO.ACCTDATA.PS //ACCTVSAM DD DISP=SHR, // DSN=AWS.M2.CARDDEMO.ACCTDATA.VSAM.KSDS //SYSIN DD * REPRO INFILE(ACCTDATA) OUTFILE(ACCTVSAM) /* ``` et la modernisation correspondante de Groovy : ``` mpr.withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .systemOut("SYSPRINT") .output("*") .build() .bluesam("ACCTDATA") .dataset("AWS.M2.CARDDEMO.ACCTDATA.PS") .disposition("SHR") .build() .bluesam("ACCTVSAM") .dataset("AWS.M2.CARDDEMO.ACCTDATA.VSAM.KSDS") .disposition("SHR") .build() .fileSystem("SYSIN") .stream("REPRO INFILE(ACCTDATA) OUTFILE(ACCTVSAM)", getEncoding()) .build() .getFileConfigurations()) .withParameters(params) .runProgram("IDCAMS") ``` ## IEBGENER/JSDGENER Ce programme reproduit l'utilitaire IEBGENER. Il est utilisé pour copier et manipuler des ensembles de données séquentiels. Cette implémentation étend les fonctionnalités de copie de base en prenant en charge les instructions de contrôle IEBGENER pour les opérations de traitement de données avancées. ### Parameters Aucun argument. Les opérations sont transmises via le jeu de données SYSIN. ### Ensembles de données requis + SYSIN : contient des instructions de contrôle (facultatif, s'il n'est pas défini, le programme IEBGENER est identique à ICEGENER) + SYSUT1: jeu de données/fichier d'entrée + SYSUT2: jeu de données/fichier de sortie ### Caractéristiques principales//Déclarations de contrôle IEBGENER prises en charge Les détails concernant la déclaration de contrôle IEBGENER figurant dans les cartes de contrôle SYSIN ne sont pas donnés ici mais doivent être extraits des documentations des anciennes plateformes pertinentes existantes. + GENERATE - définit la structure globale du processus de manipulation des données en spécifiant le nombre maximum de types d'enregistrements (MAXNAME) et de champs (MAXFLDS) à traiter + RECORD - définit la disposition et le contenu réels de chaque type d'enregistrement en spécifiant la position, la longueur et le format des champs individuels qui seront soit copiés à partir du jeu de données en entrée, soit générés avec des valeurs spécifiques + LABEL/MEMBER/EXITne sont pas pris en charge exemple : ``` GENERATE MAXNAME=3,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name */ FIELD=(12,8,CH), /* Birth date */ FIELD=(20,8,CH,VALUE='ACTIVE') RECORD TYPE=3, FIELD=(1,1,CH,VALUE='F'), FIELD=(2,30,CH,VALUE='END OF REPORT ') ``` ### Gestion des erreurs Définissez le code d'erreur 0 si la copie réussit, 1 en cas d'échec. ### Utilisation de l'échantillon Voici un exemple d'utilisation groovy du programme IEBGENER, issu d'une modernisation de JCL via AWS Transform : Le code JCL : ``` //GENDATA EXEC PGM=IEBGENER //SYSUT1 DD DSN=INPUT.EMPLOYEE.DATA, // DISP=SHR //SYSUT2 DD DSN=OUTPUT.EMPLOYEE.FILE, // DISP=(NEW,CATLG,DELETE), // SPACE=(TRK,(1,1)), // DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920) //SYSIN DD * GENERATE MAXNAME=2,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE SALARY REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name from input */ FIELD=(12,8,CH), /* Birth date from input */ FIELD=(20,8,CH), /* Dept from input */ FIELD=(28,8,CH) /* Salary from input */ /* ``` et la modernisation correspondante de Groovy : ``` mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .systemOut("SYSPRINT") .output("*") .build() .bluesam("SYSUT1") .dataset("INPUT.EMPLOYEE.DATA") .disposition("SHR") .build() .bluesam("SYSUT2") .dataset("OUTPUT.EMPLOYEE.FILE") .disposition("NEW") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .fileSystem("SYSIN") .stream( """GENERATE MAXNAME=2,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE SALARY REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name from input */ FIELD=(12,8,CH), /* Birth date from input */ FIELD=(20,8,CH), /* Dept from input */ FIELD=(28,8,CH) /* Salary from input */""", getEncoding()) .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEBGENER") ``` ## IEFBR14 IEFBR14 est un programme « ne rien faire » qui renvoie simplement un code de retour égal à 0 (zéro). Il est principalement utilisé pour l'allocation de jeux de données, la suppression ou la maintenance du catalogue par le biais d'instructions DD, sans effectuer de véritable traitement des données. ### Parameters Aucun argument ### Gestion des erreurs Définissez toujours le code d'erreur 0. ### Utilisation de l'échantillon Voici un exemple d'utilisation du IEFBR14 programme Groovy, issu d'une modernisation de JCL via AWS Transform : Le code JCL pour créer un nouveau jeu de données séquentiel : ``` //STEP1 EXEC PGM=IEFBR14 //NEWSEQ DD DSN=USER.NEW.SEQ.DATA, // DISP=(NEW,CATLG,DELETE), // SPACE=(TRK,(10,5)), // DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920) ``` et la modernisation correspondante de Groovy : ``` mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("NEWSEQ") .dataset("USER.NEW.SEQ.DATA") .disposition("NEW") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEFBR14") ``` Le code JCL pour supprimer un ensemble de données existant : ``` //STEP3 EXEC PGM=IEFBR14 //DELDD DD DSN=USER.OLD.DATASET, // DISP=(OLD,DELETE,DELETE) ``` et la modernisation correspondante de Groovy : ``` mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("DELDD") .dataset("USER.OLD.DATASET") .disposition("OLD") .normalTermination("DELETE") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEFBR14") ``` ## JCLBCICS Ce programme gère l'état des ensembles de données, en fonction de la configuration, en prenant en charge à la fois les fichiers individuels et les modèles génériques : il modifie le champ STATUS dans la table JICS file\_table. enables/disables ### Parameters Aucun argument. Les opérations sont transmises via un `DatasetsConfiguration` objet, par ex. ``` mpr.withDatasetsConfiguration(new DatasetsConfiguration().close() ``` ### Contexte Le comportement du programme peut être configuré à l'aide de deux paramètres : Dans `application-utility-pgm.yml`: + `jclbcics.ddname.size`(la valeur par défaut est 8) : il configure globalement la taille du nom du jeu de données ; si cette valeur est définie et que la longueur du nom du jeu de données est inférieure à cette valeur, le nom du jeu de données sera tronqué. À chaque étape du fichier Groovy, appelez le programme + `JCLBCICS_OVERRIDDEN_SIZE`: il remplace la taille du nom du jeu de données global : ``` TreeMap stepMapTransfo = [:] Map stepParams = ["MapTransfo":stepMapTransfo] stepParams["MapTransfo"]["JCLBCICS_OVERRIDDEN_SIZE"] = '6' ``` Si la taille du nom dd ajustée (après troncature) est inférieure à 8, le nom dd est considéré comme un caractère générique et la fonction fonctionne pour tous les ensembles de données commençant par ce nom dd. ### Fonctionnalités principales Les opérations prises en charge sont les suivantes : + OUVERT : Attribue aux ensembles de données le statut ACTIVÉ + FERMER : Attribue aux ensembles de données le statut DÉSACTIVÉ Ces opérations sont déclarées par le biais de la classe `DatasetsConfiguration` Builder : ``` new DatasetsConfiguration().close(
).open(
) ``` Nom DD : nom du jeu de données, le caractère générique \* est accepté si la taille du nom DD est inférieure à la taille maximale du nom DD (8). ### Gestion des erreurs Définir le code d'erreur 0 ### Utilisation de l'échantillon Voici un exemple d'utilisation Groovy du programme JCLBCICS : il désactive le jeu de données`UFOLJ3P`, il active tous les ensembles de données commençant par AX, il active tous les ensembles de données commençant par DX ``` import com.netfective.bluage.gapwalk.rt.call.MainProgramRunner import com.netfective.bluage.gapwalk.rt.call.ProgramExecutionResult import com.netfective.bluage.gapwalk.rt.io.support.DatasetsConfiguration MainProgramRunner mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) def TreeMap stepMapTransfo = [:] def Map stepParams = ['MapTransfo':stepMapTransfo] stepParams['MapTransfo']['JCLBCICS_OVERRIDDEN_SIZE'] = '7' ProgramExecutionResult res = mpr .withDatasetsConfiguration(new DatasetsConfiguration().close("UFOLJ3P").open("AX*").open("DX")) .withParameters(stepParams) .runProgram("JCLBCICS") ```