jobstatus überprüfen

[holgerscherer]

oje, @holgerscherer..., vielen dank, habe das gleich geändert...

der job prüft in einer datei mit vielen SQLs feldinhalte ab. je nach regel, ändert er diese dann ab. in der datei darf es, z. b., nur einmal eine beleg-nr. geben. wenn nun aber weihnachten auf Ostern fällt, gleichzeitig vollmond ist, dann "entstehen" aber trotzdem zwei identische beleg-nr., folge: der job schmierrt mit MSGW ab! das möchte ich nun ja nicht mit MONMSG abfangen, ich will das ja wissen, nur möchte ich eben nicht immer in die jobs 'reinschauen, ob evtl. gerade etwas brennt...

Irgendwie klingt das für mich aber immer noch mit der falschen Kanone auf den falschen Spatz geschossen.
Wenn Du gewisse Fehler in den Daten vermutest, prüfe mit einem SQL Distinct / Count Group By, ob eine Keygruppe mehrfach vorkommt. Oder besser noch - den Key sauber definieren und beim Schreiben das verursachende Programm auf die Nase fallen lassen. Dann würdest Du Dir viel Arbeit sparen, um zu prüfen, ob ein Prüfjob beim Prüfen auf die Prüfe äh Nase geflogen ist.

-h

[weidenhammer]

Wenn es denn CL sein soll...
Ich habe ein CHKACTJOB, das gibt über das API QUSCRTUS den entsprechenden Job mit Status und ein paar Attributen zurück...

/*  PROGRAM : CHKACTJOB                                       */
  /*  SYSTEM  : ISERIES                                         */
  /*                                                            */
  /*  CHECK IF A CERTAIN JOBNAME IS ACTIVE                      */
  /*                                                            */
  /*  HOW TO EXECUTE :                                          */
  /*                                                            */
  /*  CALL  CHKACTJOB  PARM(&PRM_JBNAM &RC)                     */
  /*       WHERE &PRM_JBNAM  IS THE JOBNAME YOU WANT TO CHECK   */
  /*       AND  &RC  IS THE RESULTING RETURN CODE :             */
  /*                                    '1' = ACTIVE            */
  /*                                    '0' = NOT ACTIVE        */
  /*                                                            */
  /*  IF THE &DEBUG VARIABLE IS SET TO '1' THEN THIS            */
  /*  PROGRAM LISTS ALSO ALL JOBS THAT ARE ACTIVE WITH          */
  /*  THE SPECIFIED JOBNAME  VIA A SNDPGMMSG COMMAND            */
  /*                                                            */
  /*                                                            */
  CHKACTJOB:  PGM        PARM(&PRM_JBNAM &RC)

               DCL        VAR(&DEBUG) TYPE(*LGL) VALUE('1') /* 1 = +
                            DEBUG */

    /*  PARAMETERS   FOR THIS PROGRAM  */

               DCL        VAR(&PRM_JBNAM) TYPE(*CHAR) LEN(10) /* +
                            JOBNAME  */
               DCL        VAR(&RC) TYPE(*CHAR) LEN(1) /* RETURN CODE +
                                  ('1' = JOB IS ACTIVE; '0' = JOB IS NOT +
                                         ACTIVE) */

               /* API DATA  FROM FORMAT  JOBL0100    */
             DCL        VAR(&JOBNAME) TYPE(*CHAR) LEN(10)
             DCL        VAR(&USER   ) TYPE(*CHAR) LEN(10)
             DCL        VAR(&JOBNBR ) TYPE(*CHAR) LEN(6)
             DCL        VAR(&STATUS)  TYPE(*CHAR) LEN(10)
             DCL        VAR(&JOBTYPE) TYPE(*CHAR) LEN(1)
             DCL        VAR(&SUBTYPE) TYPE(*CHAR) LEN(1)
 /*  PARAMETERS FOR THE QUSCRTUS  API    */

              DCL        VAR(&USP_NAME) TYPE(*CHAR) LEN(10) /* USER +
                           SPACE NAME */
              DCL        VAR(&USP_LIB) TYPE(*CHAR) LEN(10) /* USER +
                           SPACE LIBRARY */
              DCL        VAR(&USP_QUAL) TYPE(*CHAR) LEN(20) /* USER +
                           SPACE QUALIFIED NAME */
              DCL        VAR(&USP_TYPE) TYPE(*CHAR) LEN(10) /* USER +
                           SPACE TYPE */
              DCL        VAR(&USP_SIZE) TYPE(*CHAR) LEN(4) /* USER +
                           SPACE SIZE */
              DCL        VAR(&USP_FILL) TYPE(*CHAR) LEN(1) /* USER +
                           SPACE FILL CHARACTER */
              DCL        VAR(&USP_AUT) TYPE(*CHAR) LEN(10) /* USER +
                           SPACE AUTHORITY */
              DCL        VAR(&USP_TEXT) TYPE(*CHAR) LEN(50) /* USER +
                           SPACE TEXT */
  /*  PARAMETERS FOR THE QUSRTVUS  API    */

               DCL        VAR(&STARTPOS) TYPE(*CHAR) LEN(4)
               DCL        VAR(&DATALEN ) TYPE(*CHAR) LEN(4)
               DCL        VAR(&HEADER) TYPE(*CHAR) LEN(150)
   /*  PARAMETERS FOR THE QUSLJOB   API    */

               DCL        VAR(&API_USQUAL) TYPE(*CHAR) LEN(20) /* +
                            QUALIFIED USER SPACE NAME  */
               DCL        VAR(&API_JBQUAL) TYPE(*CHAR) LEN(26) /* +
                           QUALIFIED JOBNAME */
               DCL        VAR(&API_JBNAM) TYPE(*CHAR) LEN(10) /* +
                            JOBNAME */
               DCL        VAR(&API_USER) TYPE(*CHAR) LEN(10) /* USER */
               DCL        VAR(&API_JOBNR) TYPE(*CHAR) LEN(6) /* JOB +
                            NUMBER */
               DCL        VAR(&API_ERROR) TYPE(*CHAR) LEN(256) /* API +
                            ERROR */
               DCL        VAR(&API_STATUS) TYPE(*CHAR) LEN(10) /* +
                            STATUS  */
  /*  LIST DATA SECTION                   */

              DCL        VAR(&LST_OFFSET) TYPE(*DEC) LEN(5 0) /* +
                           OFFSET OF FIRST DATA */
              DCL        VAR(&LST_SIZE) TYPE(*DEC) LEN(5 0) /* SIZE +
                           OF DATA */
              DCL        VAR(&LST_DATA) TYPE(*CHAR) LEN(4096)

              DCL        VAR(&LST_NBR) TYPE(*DEC) LEN(5 0) /* NUMBER +
                           OF ENTRIES IN LIST DATA SECTION */
              DCL        VAR(&LST_LEN) TYPE(*DEC) LEN(5 0) /* ENTRY +
                            LENGTH IN DEC */
               DCL        VAR(&LST_LENBIN) TYPE(*CHAR) LEN(4) /* ENTRY +
                            LENGTH IN BINARY */
               DCL        VAR(&LST_POSBIN) TYPE(*CHAR) LEN(4) /* +
                            POSITION OF LIST ENTRY IN BINARY */
  /*  VARIABLES                           */


              DCL        VAR(&LST_COUNT) TYPE(*DEC) LEN(5) VALUE(0) /* +
                           COUNTER */

 /*  INITIALIZE  RETURN CODE  */

              CHGVAR     VAR(&RC) VALUE('0')
/*  CREATE USER SPACE */

             CHGVAR     VAR(&USP_NAME) VALUE('MYUSRSPACE') /* SET +
                          USER SPACE NAME */
             CHGVAR     VAR(&USP_LIB) VALUE('QTEMP') /* SET USER +
                          SPACE LIBRARY */
             CHGVAR     VAR(&USP_QUAL) VALUE(&USP_NAME *CAT +
                          &USP_LIB) /* SET USER SPACE QUALIFIED NAME */
             CHGVAR     VAR(&USP_TYPE) VALUE('MYTYPE') /* SET USER +
                          SPACE TYPE */
             CHGVAR     VAR(%BIN(&USP_SIZE)) VALUE(64000) /* SET +
                          USER SPACE SIZE */
             CHGVAR     VAR(&USP_FILL) VALUE(' ') /* SET USER SPACE +
                          FILL CHARACTER */
             CHGVAR     VAR(&USP_AUT) VALUE('*USE') /* SET USER +
                        SPACE AUTHORITY */
             CHGVAR     VAR(&USP_TEXT) VALUE('MY USER SPACE') +
                          /* SET USER SPACE TEXT */


             CALL       PGM(QUSCRTUS) PARM(&USP_QUAL &USP_TYPE +
                          &USP_SIZE &USP_FILL &USP_AUT &USP_TEXT)


/*  EXECUTE  API  */
             CHGVAR     VAR(&API_USQUAL) VALUE(&USP_QUAL) /* USER +
                          SPACE NAME */
             CHGVAR     VAR(&API_JBNAM) VALUE(&PRM_JBNAM) /* JOBNAME */
             CHGVAR     VAR(&API_USER) VALUE('*ALL') /* USER */
             CHGVAR     VAR(&API_JOBNR) VALUE('*ALL') /* JOB NUMBER */
             CHGVAR     VAR(&API_STATUS) VALUE('*ACTIVE') /* STATUS +
                          OF THE JOB */
             CHGVAR     VAR(&API_JBQUAL) VALUE(&API_JBNAM *CAT +
                          &API_USER *CAT &API_JOBNR) /* QUALIFIED +
                          JOB NAME */
             CHGVAR     VAR(%BIN(&API_ERROR 1 4)) VALUE(0)

              CALL       PGM(QUSLJOB) PARM(&API_USQUAL 'JOBL0100' +
                           &API_JBQUAL &API_STATUS &API_ERROR)

 /*  RETRIEVE  HEADER DESCRIPTION INFORMATION   */

              CHGVAR     VAR(%BIN(&STARTPOS)) VALUE(1) /* SET START +
                           POSITION */
              CHGVAR     VAR(%BIN(&DATALEN)) VALUE(140) /* SET DATA +
                           LENGTH    */

              CALL       PGM(QUSRTVUS) PARM(&API_USQUAL &STARTPOS +
                           &DATALEN &HEADER)


     /* RETRIEVE DATA IN LIST   SECTION */
              CHGVAR     VAR(&LST_OFFSET) VALUE(%BIN(&HEADER 125 4))
              CHGVAR     VAR(&LST_SIZE) VALUE(%BIN(&HEADER 129 4))
              CHGVAR     VAR(&LST_NBR) VALUE(%BIN(&HEADER 133 4))
              CHGVAR     VAR(&LST_LEN) VALUE(%BIN(&HEADER 137 4))

              CHGVAR     VAR(%BIN(&LST_POSBIN)) VALUE(&LST_OFFSET + 1)
              CHGVAR     VAR(&LST_LENBIN) VALUE(%SST(&HEADER 137 4))
  /*  RETRIEVE LIST DATA ENTRIES */

              CHGVAR     VAR(&LST_COUNT) VALUE(0) /* INITIALIZE +
                           NUMBER OF LIST ENTRIES COUNTER */

 LST_LOOP:   IF         COND(&LST_COUNT *EQ &LST_NBR) THEN(GOTO +
                           CMDLBL(LST_END))


              CALL       PGM(QUSRTVUS) PARM(&API_USQUAL &LST_POSBIN +
                           &LST_LENBIN &LST_DATA)


              CHGVAR     VAR(&JOBNAME) VALUE(%SST(&LST_DATA 1 10))
              CHGVAR     VAR(&USER) VALUE(%SST(&LST_DATA 11 10))
              CHGVAR     VAR(&JOBNBR) VALUE(%SST(&LST_DATA 21 6))
             CHGVAR     VAR(&STATUS) VALUE(%SST(&LST_DATA 43 10))
              CHGVAR     VAR(&JOBTYPE) VALUE(%SST(&LST_DATA 53 1))
              CHGVAR     VAR(&SUBTYPE) VALUE(%SST(&LST_DATA 54 1))

    /*  TREATMENT OF 1 LIST ENTRY  */
                IF         COND(&DEBUG) THEN(DO)
                   SNDPGMMSG  MSG('** JOB IDENTIFICATION **')
                   SNDPGMMSG  MSG('JOB NAME : ' *CAT &JOBNAME)
                   SNDPGMMSG  MSG('USER     : ' *CAT &USER)
                   SNDPGMMSG  MSG('JOBNBR   : ' *CAT &JOBNBR)
                   SNDPGMMSG  MSG('STATUS   : ' *CAT &STATUS)
                   SNDPGMMSG  MSG('JOB TYPE : ' *CAT &JOBTYPE)
                   SNDPGMMSG  MSG('SUBTYPE  : ' *CAT &SUBTYPE)
                 ENDDO

                 IF         COND((&JOBNAME *EQ &PRM_JBNAM) *AND (&STATUS +
                              *EQ *ACTIVE)) THEN(DO)
                   CHGVAR     VAR(&RC) VALUE('1')
                 ENDDO
   /*   END  TREATMENT  OF 1 LIST ENTRY  */

              CHGVAR     VAR(&LST_COUNT) VALUE(&LST_COUNT + 1)
              CHGVAR     VAR(%BIN(&LST_POSBIN)) +
                           VALUE(%BIN(&LST_POSBIN) + &LST_LEN)
              GOTO       CMDLBL(LST_LOOP)



 LST_END:    DLTUSRSPC  USRSPC(&USP_LIB/&USP_NAME)

 END:        ENDPGM

[programmer400]

Zu Bedenken bei wrkactjob *print.

Vor ein paar Releases hatte die IBM die Spalten im Spoolfile geändert. Dann musste das entsprechende CL angepasst werden.

[Fuerchau]

Ich würde mich da immer noch eher um das ursächliche Problem kümmern als Workarounds stricken.
Wenn ein Programm abschmiert, so gehört dieses Programm korrigiert.
Im Gegensatz zur Windows (Windows hat ein Problem festgestellt und das Programm muss beendet werden) liefert die AS/400 immerhin die Zeile des Programmes und man kann einen Variablendump ziehen.
Aber ich nehme eh an, dass die Ursachen der Probleme bekannt sind und somit behebbar.

[hel400]

Ich würde mich da immer noch eher um das ursächliche Problem kümmern als Workarounds stricken.
Wenn ein Programm abschmiert, so gehört dieses Programm korrigiert.
Im Gegensatz zur Windows (Windows hat ein Problem festgestellt und das Programm muss beendet werden) liefert die AS/400 immerhin die Zeile des Programmes und man kann einen Variablendump ziehen.
Aber ich nehme eh an, dass die Ursachen der Probleme bekannt sind und somit behebbar.

Das ist (im gegenständlichen Fall) wohl richtig.
Trotzdem bleibt die ursprüngliche Frage, wie man Jobs auf "MSGW"-Status überprüfen kann.
Und da ist der einzig wirklich vernünftige Weg, dass man das Ganze mit den in den vorigen Antworten beschriebenem API löst (egal ob in CL oder RPG oder sonstwo).
Ein WRKACTJOB mit *PRINT ist wohl auch möglich, aber eher mehr dirty als quick ...

Und grundsätzlich muss man ja wirklich sagen, dass so ein "MSGW-Wächter" absolut hilfreich ist (und zwar nicht nur für das Monitoring eines speziellen- sondern für alle am System laufenden Jobs. Ich habe das auf praktisch allen Kundensystemen seit Jahren laufen)