Attention : Ce code nécessite des droits administrateur.
Le script commence par définir un programme SAS© temporaire ('testprog') qui simule une tâche métier, capable d'échouer (`abort`) aléatoirement en fonction de variables macro. Deux jobs, 'demo1' et 'demo2', sont créés à partir de ce programme temporaire à l'aide de la macro `%mv_createjob`, en les plaçant dans le dossier '/Public/temp' (typiquement un CASLIB). Un dataset `work.inputjobs` est construit pour fournir les paramètres spécifiques (`_program`, `macrovar1`, `macrovar2`, `flow_id`, `_contextName`) pour chaque exécution des jobs dans le flux. La macro `%mv_jobflow` est ensuite appelée avec ce dataset d'entrée pour lancer le flux de jobs en parallèle (concurrence maximale de 2), en spécifiant un dataset de sortie (`work.results`) et un fichier de log de référence (`myjoblog`). L'option `raise_err=1` est utilisée pour propager les erreurs au niveau du système, permettant ainsi une meilleure gestion des échecs de jobs. Le code de retour système (`syscc`) est affiché avant et après l'exécution du flux pour un suivi. Enfin, le contenu du log du flux (`myjoblog`) est affiché dans le log SAS©, et la macro `%mp_assert` est utilisée pour vérifier que le `syscc` est non nul, confirmant que l'échec des jobs distants est correctement signalé. Le `syscc` est ensuite réinitialisé à la fin du script.
Analyse des données
Type : CREATION_INTERNE
Les données sont entièrement générées en interne. Un programme SAS temporaire est créé dynamiquement à l'aide d'un DATA STEP `_null_` écrivant dans un `filename temp`. Les paramètres d'entrée pour le flux de jobs (`work.inputjobs`) sont également créés par un DATA STEP explicite. Aucun fichier externe ni dataset SASHELP n'est directement lu pour les données principales du script.
1 Bloc de code
DATA STEP Data
Explication :
Ce bloc SAS crée un fichier temporaire nommé `testprog` et y écrit un programme SAS. Ce programme est conçu pour simuler une tâche métier qui utilise des variables macro `&_program`, `&flow_id`, `¯ovar1`, et `¯ovar2`. Il inclut une logique conditionnelle où `abort` est déclenché si une valeur aléatoire (`rand("uniform")`) est supérieure à 0.50, simulant ainsi un échec de job. Le programme génère également un dataset anonyme contenant des variables calculées (`rval`, `rand`, `y`).
Ce bloc SAS crée un fichier temporaire nommé `testprog` et y écrit un programme SAS. Ce programme est conçu pour simuler une tâche métier qui utilise des variables macro `&_program`, `&flow_id`, `¯ovar1`, et `¯ovar2`. Il inclut une logique conditionnelle où `abort` est déclenché si une valeur aléatoire (`rand("uniform")`) est supérieure à 0.50, simulant ainsi un échec de job. Le programme génère également un dataset anonyme contenant des variables calculées (`rval`, `rand`, `y`).
Copié !
| 1 | filename testprog temp; |
| 2 | DATA _null_; |
| 3 | file testprog; |
| 4 | put '%put this is job: &_program;' |
| 5 | / '%put this was run in flow &flow_id;' |
| 6 | / 'data ;' |
| 7 | / ' rval=rand("uniform");' |
| 8 | / ' rand=rval*¯ovar1;' |
| 9 | / ' do x=1 to rand;' |
| 10 | / ' y=rand*¯ovar2;' |
| 11 | / ' if (rval>0.50) then abort;' |
| 12 | / ' else output;' |
| 13 | / ' end;' |
| 14 | / 'run;' |
| 15 | ; |
| 16 | RUN; |
2 Bloc de code
MACRO CALL (mv_createjob)
Explication :
Appelle la macro `%mv_createjob` pour créer un job nommé 'demo1'. Ce job est enregistré dans le chemin '/Public/temp' (probablement un dossier dans un CASLIB) et utilise le code SAS généré dans le fichier temporaire `testprog` comme source. Cette macro prépare le job pour une exécution ultérieure dans un flux de jobs sur l'environnement SAS Viya.
Appelle la macro `%mv_createjob` pour créer un job nommé 'demo1'. Ce job est enregistré dans le chemin '/Public/temp' (probablement un dossier dans un CASLIB) et utilise le code SAS généré dans le fichier temporaire `testprog` comme source. Cette macro prépare le job pour une exécution ultérieure dans un flux de jobs sur l'environnement SAS Viya.
Copié !
| 1 | %mv_createjob(path=/Public/temp,name=demo1,code=testprog) |
3 Bloc de code
MACRO CALL (mv_createjob)
Explication :
Appelle de nouveau la macro `%mv_createjob` pour créer un second job nommé 'demo2', utilisant également le même code source (`testprog`) et le même chemin de sauvegarde que le job 'demo1'. Cela configure deux jobs indépendants qui seront gérés par le même flux d'exécution.
Appelle de nouveau la macro `%mv_createjob` pour créer un second job nommé 'demo2', utilisant également le même code source (`testprog`) et le même chemin de sauvegarde que le job 'demo1'. Cela configure deux jobs indépendants qui seront gérés par le même flux d'exécution.
Copié !
| 1 | %mv_createjob(path=/Public/temp,name=demo2,code=testprog) |
4 Bloc de code
DATA STEP Data
Explication :
Ce DATA STEP crée l'ensemble de données `work.inputjobs`. Ce dataset sert de tableau de bord pour le flux de jobs, spécifiant les paramètres d'exécution pour chaque instance de job. Il définit le `_contextName` comme 'SAS Job Execution compute context', itère sur deux `flow_id` distincts et, pour chaque `flow_id`, prépare des exécutions pour 'demo1' et 'demo2' avec des valeurs différentes pour `macrovar1` et `macrovar2`. Cela permet de tester le comportement des jobs avec divers inputs et de simuler plusieurs exécutions.
Ce DATA STEP crée l'ensemble de données `work.inputjobs`. Ce dataset sert de tableau de bord pour le flux de jobs, spécifiant les paramètres d'exécution pour chaque instance de job. Il définit le `_contextName` comme 'SAS Job Execution compute context', itère sur deux `flow_id` distincts et, pour chaque `flow_id`, prépare des exécutions pour 'demo1' et 'demo2' avec des valeurs différentes pour `macrovar1` et `macrovar2`. Cela permet de tester le comportement des jobs avec divers inputs et de simuler plusieurs exécutions.
Copié !
| 1 | DATA work.inputjobs; |
| 2 | _contextName='SAS Job Execution compute context'; |
| 3 | DO flow_id=1 to 2; |
| 4 | DO i=1 to 4; |
| 5 | _program='/Public/temp/demo1'; |
| 6 | macrovar1=10*i; |
| 7 | macrovar2=4*i; |
| 8 | OUTPUT; |
| 9 | i+1; |
| 10 | _program='/Public/temp/demo2'; |
| 11 | macrovar1=40*i; |
| 12 | macrovar2=44*i; |
| 13 | OUTPUT; |
| 14 | END; |
| 15 | END; |
| 16 | RUN; |
5 Bloc de code
MACRO CALL (%put)
Explication :
Affiche la valeur actuelle de la variable automatique `SYSCC` (System Return Code) dans le log SAS. `SYSCC` contient le code de retour du dernier appel système ou macro, servant ici de point de contrôle avant l'exécution du flux de jobs pour s'assurer d'un état initial connu, généralement 0 en cas de succès.
Affiche la valeur actuelle de la variable automatique `SYSCC` (System Return Code) dans le log SAS. `SYSCC` contient le code de retour du dernier appel système ou macro, servant ici de point de contrôle avant l'exécution du flux de jobs pour s'assurer d'un état initial connu, généralement 0 en cas de succès.
Copié !
| 1 | %put NOTE: &=syscc; |
6 Bloc de code
MACRO CALL (mv_jobflow)
Explication :
Appelle la macro `%mv_jobflow` pour exécuter les jobs définis. Elle prend `work.inputjobs` comme dataset d'entrée (`inds`), limite la concurrence à 2 jobs en parallèle (`maxconcurrency=2`), sauvegarde les résultats dans `work.results` (`outds`) et les informations de log dans un fileref `myjoblog` (`outref`). L'option `raise_err=1` est cruciale car elle assure que les erreurs survenant dans les jobs exécutés sont reflétées dans le `SYSCC` du processus appelant, permettant une gestion d'erreurs centralisée. `mdebug=1` active le mode de débogage pour la macro, fournissant des informations détaillées dans le log.
Appelle la macro `%mv_jobflow` pour exécuter les jobs définis. Elle prend `work.inputjobs` comme dataset d'entrée (`inds`), limite la concurrence à 2 jobs en parallèle (`maxconcurrency=2`), sauvegarde les résultats dans `work.results` (`outds`) et les informations de log dans un fileref `myjoblog` (`outref`). L'option `raise_err=1` est cruciale car elle assure que les erreurs survenant dans les jobs exécutés sont reflétées dans le `SYSCC` du processus appelant, permettant une gestion d'erreurs centralisée. `mdebug=1` active le mode de débogage pour la macro, fournissant des informations détaillées dans le log.
Copié !
| 1 | %mv_jobflow(inds=work.inputjobs |
| 2 | ,maxconcurrency=2 |
| 3 | ,outds=work.results |
| 4 | ,outref=myjoblog |
| 5 | ,raise_err=1 |
| 6 | ,mdebug=1 |
| 7 | ) |
7 Bloc de code
MACRO CALL (%put)
Explication :
Affiche la valeur de `SYSCC` après l'exécution du flux de jobs. Cela permet de vérifier si les erreurs des jobs internes (qui peuvent `abort`) ont été correctement capturées et transmises au niveau du processus appelant par la macro `%mv_jobflow`, et si le `SYSCC` reflète un échec potentiel du flux.
Affiche la valeur de `SYSCC` après l'exécution du flux de jobs. Cela permet de vérifier si les erreurs des jobs internes (qui peuvent `abort`) ont été correctement capturées et transmises au niveau du processus appelant par la macro `%mv_jobflow`, et si le `SYSCC` reflète un échec potentiel du flux.
Copié !
| 1 | %put NOTE: &=syscc; |
8 Bloc de code
DATA STEP
Explication :
Ce DATA STEP lit le contenu du fichier référencé par `myjoblog` (qui a été renseigné par la macro `%mv_jobflow` et contient le log consolidé du flux de jobs) et imprime chaque ligne (`_infile_`) dans le log SAS. C'est une étape essentielle de débogage et de vérification pour examiner les messages et les statuts générés par les jobs exécutés dans le flux.
Ce DATA STEP lit le contenu du fichier référencé par `myjoblog` (qui a été renseigné par la macro `%mv_jobflow` et contient le log consolidé du flux de jobs) et imprime chaque ligne (`_infile_`) dans le log SAS. C'est une étape essentielle de débogage et de vérification pour examiner les messages et les statuts générés par les jobs exécutés dans le flux.
Copié !
| 1 | DATA _null_; |
| 2 | INFILE myjoblog; |
| 3 | INPUT; put _infile_; |
| 4 | RUN; |
9 Bloc de code
MACRO CALL (mp_assert)
Explication :
Utilise la macro `%mp_assert` (probablement une macro de test ou d'assertion personnalisée) pour vérifier une condition logique. Ici, elle s'assure que la variable `SYSCC` n'est pas égale à zéro, ce qui indiquerait qu'une erreur a été détectée et propagée depuis le flux de jobs. Le message `desc` explicite l'objectif : 'Vérifier qu'un code de retour non nul est renvoyé si le job appelé échoue'. Cette assertion est cruciale pour valider la robustesse de la gestion des erreurs du système de flux.
Utilise la macro `%mp_assert` (probablement une macro de test ou d'assertion personnalisée) pour vérifier une condition logique. Ici, elle s'assure que la variable `SYSCC` n'est pas égale à zéro, ce qui indiquerait qu'une erreur a été détectée et propagée depuis le flux de jobs. Le message `desc` explicite l'objectif : 'Vérifier qu'un code de retour non nul est renvoyé si le job appelé échoue'. Cette assertion est cruciale pour valider la robustesse de la gestion des erreurs du système de flux.
Copié !
| 1 | %mp_assert( |
| 2 | iftrue=(&syscc ne 0), |
| 3 | desc=Check that non zero return code is returned IF called job fails |
| 4 | ) |
10 Bloc de code
MACRO CALL (%let)
Explication :
Réinitialise la variable macro automatique `SYSCC` à zéro. Cette pratique est courante à la fin d'un test ou d'une section de code pour éviter que le `SYSCC` de cette section n'affecte les vérifications ou l'état général du programme exécuté par la suite.
Réinitialise la variable macro automatique `SYSCC` à zéro. Cette pratique est courante à la fin d'un test ou d'une section de code pour éviter que le `SYSCC` de cette section n'affecte les vérifications ou l'état général du programme exécuté par la suite.
Copié !
| 1 | %let syscc=0; |
Ce matériel est fourni "tel quel" par We Are Cas. Il n'y a aucune garantie, expresse ou implicite, quant à la qualité marchande ou à l'adéquation à un usage particulier concernant le matériel ou le code contenu dans les présentes. We Are Cas n'est pas responsable des erreurs dans ce matériel tel qu'il existe maintenant ou existera, et We Are Cas ne fournit pas de support technique pour celui-ci.
Le Conseil de l'Expert
Michael
Responsable de l'infrastructure Viya.
« L'automatisation et le test de flux de travaux dans un environnement SAS Viya exigent une approche radicalement différente de celle utilisée sur SAS 9. Ce script illustre parfaitement l'utilisation de la bibliothèque SASjs (via les macros %mv_) pour piloter l'API de Job Execution. En encapsulant la logique métier dans des programmes enregistrés dans le "SAS Content", vous permettez une exécution parallélisée et isolée du programme maître. »