//BCHJOB JOB(JOLDLOG) JOBD(NERONI2/NERONI2) OUTQ(QPRINT) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) CCSID(280) /* Open source from www.neroni.it */ /* LA JOB DESCRIPTION "NERONI2/NERONI2" DEVE PREESISTERE. PUO' ESSERE */ /* IDENTICA A QBATCH E PUO' ESSERE SOSTITUITA DA QBATCH O SIMILE. */ /* From System: "S65D69DA" */ /* From Library: "NERONI2" */ /* Unload Time: 2016-08-23 13:16 */ /* To File : "JOLDLOG" */ /* To Library : "NERONI2" */ /* To Text : "Archives old log. Src" */ /********* INIZIO ISTRUZIONI **************************************************/ /* LE SUCCESSIVE ISTRUZIONI PERMETTONO DI RICARICARE I SORGENTI. */ /* 1) DA UN VIDEO COMANDI DELL'AS400 RICEVENTE */ /* CREARE UN FILE SORGENTE DI LUNGHEZZA RECORD 112: */ /* CRTSRCPF FILE(NERONI2/STRINGHE) RCDLEN(112) */ /* 2) SPOSTARE IL FILE "JOLDLOG.txt" NELL'INDIRIZZARIO */ /* DI UN PC CONNESSO IN RETE CON L'AS400 RICEVENTE */ /* (AD ES.: "c:\"). */ /* 3) DAL VIDEO COMANDI DEL PC CHIAMARE FTP: */ /* ftp nomeas400 */ /* 4) DIGITARE UTENTE E PASSWORD. */ /* 5) ESEGUIRE IL COMANDO DI COPIA DA FILE PC A MEMBRO AS400: */ /* put "c:\JOLDLOG.txt" "/qsys.lib/NERONI2.lib/stringhe.file/JOLDLOG.mbr" */ /* 6) ABBANDONARE FTP: */ /* quit */ /* 7) DA UN VIDEO COMANDI DELL'AS400 RICEVENTE */ /* ESEGUIRE LA STRINGA COPIATA NEL MEMBRO SORGENTE: */ /* SBMDBJOB FILE(NERONI2/STRINGHE) MBR(JOLDLOG) JOBQ(QBATCH) */ /* LE SUCCESSIVE ISTRUZIONI PERMETTONO DI CREARE L'UTILITY. */ /* 8) DA UN VIDEO COMANDI DELL'AS400 RICEVENTE */ /* ESEGUIRE LA STRINGA O LE STRINGHE SORGENTE DI TIPO SEU "CL" */ /* (IL CUI NOME TERMINA SEMPRE CON ".") */ /* PRESENTI NEL FILE RICARICATO "NERONI2/JOLDLOG" */ /* FACENDO ATTENZIONE ALL'ORDINE DI ESECUZIONE INDICATO NEL */ /* MEMBRO FACOLTATIVO "A.LEGGIMI", AD ESEMPIO: */ /* SBMDBJOB FILE(NERONI2/JOLDLOG) MBR(JOLDLOG.) JOBQ(QBATCH) */ /********* FINE ISTRUZIONI ****************************************************/ /* Crea la libreria. */ MKDIR DIR('/qsys.lib/NERONI2.lib') CHGLIB LIB(NERONI2) TEXT('Claudio Neroni Utility') /* Imposta la lista librerie. */ CHGLIBL LIBL(QTEMP NERONI2 QGPL) /* Crea il file sorgente. */ DLTF FILE(NERONI2/JOLDLOG) CRTSRCPF FILE(NERONI2/JOLDLOG) RCDLEN(112) + TEXT('Archives old log. Src') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JOLDLOG) TOFILE(NERONI2/JOLDLOG) + TOMBR(JOLDLOG) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JOLDLOG) MBR(JOLDLOG) + SRCTYPE(CMD) + TEXT('Archives old log. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JOLDLOG.) TOFILE(NERONI2/JOLDLOG) + TOMBR(JOLDLOG.) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JOLDLOG) MBR(JOLDLOG.) + SRCTYPE(CL) + TEXT('Archives old log. CrtJs') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JOLDLOGC) TOFILE(NERONI2/JOLDLOG) + TOMBR(JOLDLOGC) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JOLDLOG) MBR(JOLDLOGC) + SRCTYPE(CLLE) + TEXT('Archives old log. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JOLDLOGD) TOFILE(NERONI2/JOLDLOG) + TOMBR(JOLDLOGD) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JOLDLOG) MBR(JOLDLOGD) + SRCTYPE(RPGLE) + TEXT('Archives old log. PrunesLog') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JOLDLOGE) TOFILE(NERONI2/JOLDLOG) + TOMBR(JOLDLOGE) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JOLDLOG) MBR(JOLDLOGE) + SRCTYPE(RPGLE) + TEXT('Archives old log. Separator') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JOLDLOGP) TOFILE(NERONI2/JOLDLOG) + TOMBR(JOLDLOGP) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JOLDLOG) MBR(JOLDLOGP) + SRCTYPE(PNLGRP) + TEXT('Archives old log. Help') /*----------------------------------------------------------------------------*/ //DATA FILE(JOLDLOG) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Archives old log. Cmd */ /* Archivia vecchio log. Comando */ /* Claudio Neroni 14-12-2015 Creato. */ /* */ CMD PROMPT('Archives old log') PARM KWD(JOB) TYPE(JOB) SNGVAL((*)) MIN(1) + PROMPT('Job name') JOB: QUAL TYPE(*NAME) QUAL TYPE(*NAME) PROMPT('Job user') QUAL TYPE(*CHAR) LEN(6) RANGE('000001' '999999') + SPCVAL((' ')) PROMPT('Job number') PARM KWD(FROMTAG) TYPE(*CHAR) LEN(10) + DFT(JOLDLOGFRM) PROMPT('From tag in log') PARM KWD(RQSID) TYPE(*CHAR) LEN(12) + DFT('Richiesta') PROMPT('Request ide in + printed log') PARM KWD(OUTFILE) TYPE(OUTFILE) PROMPT('Output + file') OUTFILE: QUAL TYPE(*NAME) DFT(JOLDLOGT) QUAL TYPE(*NAME) DFT(QTEMP) PROMPT('Library') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JOLDLOG.) FILETYPE(*SRC) ENDCHAR('//ENDSRC') //BCHJOB JOB(JOLDLOG.) JOBD(NERONI2/NERONI2) OUTQ(QPRINTS) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) CCSID(280) jmy /* Claudio Neroni 14-12-2015 Creato. */ /* JOLDLOG */ /* Archives old log. */ /* Prerequisiti: JRSNMSG, JRQS, JWSF */ /* Imposta la lista librerie. */ CHGLIBL LIBL(QTEMP QGPL) ADDLIBLE LIB(NERONI2) POSITION(*AFTER QTEMP) /* Cancella il file messaggi preesistente. */ DLTMSGF MSGF(NERONI2/JOLDLOG) /* Cancella i testi d'aiuto preesistenti. */ DLTPNLGRP PNLGRP(NERONI2/JOLDLOGP) /* Cancella i logici preesistenti. */ /* Cancella i fisici preesistenti. */ /* Cancella gli oggetti preesistenti. */ /* Cancella i comandi preesistenti. */ DLTCMD CMD(NERONI2/JOLDLOG) /* Cancella i programmi preesistenti. */ DLTPGM PGM(NERONI2/JOLDLOGC) DLTPGM PGM(NERONI2/JOLDLOGD) DLTPGM PGM(NERONI2/JOLDLOGE) /* Crea i comandi. */ CRTCMD CMD(NERONI2/JOLDLOG) PGM(JOLDLOGC) SRCFILE(JOLDLOG) + HLPPNLGRP(JOLDLOGP) HLPID(CMD) PRDLIB(NERONI2) /* Duplica i comandi in QGPL. */ CRTPRXCMD CMD(QGPL/JOLDLOG) TGTCMD(NERONI2/JOLDLOG) AUT(*USE) + REPLACE(*YES) /* Crea i programmi. */ CRTBNDCL PGM(NERONI2/JOLDLOGC) SRCFILE(JOLDLOG) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDRPG PGM(NERONI2/JOLDLOGD) SRCFILE(JOLDLOG) DBGVIEW(*ALL) + TGTRLS(*CURRENT) CRTBNDRPG PGM(NERONI2/JOLDLOGE) SRCFILE(JOLDLOG) DBGVIEW(*ALL) + TGTRLS(*CURRENT) /* Crea il file messaggi. */ CRTMSGF MSGF(NERONI2/JOLDLOG) TEXT('Archives old log. Msgf') /* Fotografia comandi (xxxA001). */ /* Messaggi comuni a pgm di comandi diversi (xxx0001). */ ADDMSGD MSGID(JLG0001) MSGF(NERONI2/JOLDLOG) MSG('Nome &1 per + file di output non e'' permesso.') SECLVL('Il nome + "&1" richiesto per il file di output e'' riservato + all''uso interno del tool. Usa un nome diverso.') + FMT((*CHAR 10)) ADDMSGD MSGID(JLG0002) MSGF(NERONI2/JOLDLOG) MSG('Archivia il log + dopo l''ultima label &1') FMT((*CHAR 10)) /* Messaggi nei pgm del Cmd 1 (xxx0101). */ /* Messaggi nei pgm del Cmd 2 (xxx0201). */ /* Messaggi dei Cmd (xxx1001). */ /* Crea i testi d'aiuto. */ CRTPNLGRP PNLGRP(NERONI2/JOLDLOGP) SRCFILE(JOLDLOG) //ENDBCHJOB //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JOLDLOGC) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Archives old log. Cpp */ /* Archivia vecchio log. Cpp */ /* Claudio Neroni 29-10-2015 Creato. */ /* Derivato da JLOG che fa lo stesso recupero di log sul job in cui */ /* viene eseguito. */ /* Richiede che il job in esame abbia stampato il log, */ /* anche se su stampe multiple, e che le stampe siano ancora presenti */ /* come spool file sul sistema. */ /* Recuperandolo dalle stampe, archivia in un file fisico */ /* una copia della stampa del log del job richiesto. */ /* L'archiviazione parte dalla riga di richiesta che precede la riga ove */ /* giace l'ultima ricorrenza della stringa contenuta in &FROMTAG e */ /* arriva fino alla fine del log disponibile su stampa. */ /* La costante di identificazione della riga di richiesta e' esplicitata */ /* nel parametro &RQSID al solo scopo di permettere l'uso del comando */ /* anche in altri release e in altre lingue. */ /* */ PGM PARM(&JOB &FROMTAG &RQSID &OUTFILEQ) /* Riceve Lavoro. */ DCL VAR(&JOB) TYPE(*CHAR) LEN(26) /* Riceve From Tag in Log. */ DCL VAR(&FROMTAG) TYPE(*CHAR) LEN(10) /* Riceve Request Identification in Printed Log. */ DCL VAR(&RQSID) TYPE(*CHAR) LEN(12) /* Riceve Nome qualificato del file di emissione. */ DCL VAR(&OUTFILEQ) TYPE(*CHAR) LEN(20) /* Job name. */ DCL VAR(&JOBNAM) TYPE(*CHAR) LEN(10) /* Job user. */ DCL VAR(&JOBUSR) TYPE(*CHAR) LEN(10) /* Job number. */ DCL VAR(&JOBNBR) TYPE(*CHAR) LEN(6) /* File di emissione. */ DCL VAR(&OUTFILE) TYPE(*CHAR) LEN(10) /* Libreria del File di emissione. */ DCL VAR(&OUTLIB) TYPE(*CHAR) LEN(10) /* Nome del work file temporaneo. */ DCL VAR(&WRKF) TYPE(*CHAR) LEN(10) VALUE(JOLDLOG_T) /* Flag di Trovato FromTag. */ DCL VAR(&FOUND) TYPE(*LGL) /* Prenotazione del CPF0001. */ DCL VAR(&CPF0001) TYPE(*LGL) /* Elenco degli spool del job. */ DCLF FILE(JWSF1) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Trascrive il job nei suoi componenti. */ CHGVAR VAR(&JOBNAM) VALUE(%SST(&JOB 1 10)) CHGVAR VAR(&JOBUSR) VALUE(%SST(&JOB 11 10)) CHGVAR VAR(&JOBNBR) VALUE(%SST(&JOB 21 6)) /* Estrae parametri. */ CHGVAR VAR(&OUTFILE) VALUE(%SST(&OUTFILEQ 1 10)) CHGVAR VAR(&OUTLIB) VALUE(%SST(&OUTFILEQ 11 10)) /* Se scelto nome di outfile coincidente con un nome riservato, errore. */ IF COND((&OUTFILE *EQ JOLDLOG_T) *OR (&OUTFILE + *EQ JOLDLOG_W)) THEN(DO) SNDPGMMSG MSGID(JLG0001) MSGF(JOLDLOG) MSGDTA(&OUTFILE) + MSGTYPE(*DIAG) GOTO CMDLBL(CPF0001) ENDDO /* Messaggia. */ SNDPGMMSG MSGID(JLG0002) MSGF(JOLDLOG) MSGDTA(&FROMTAG) + TOPGMQ(*EXT) MSGTYPE(*STATUS) /* Crea un fisico temporaneo di comodo. */ DLTF FILE(QTEMP/&WRKF) MONMSG MSGID(CPF0000 MCH0000) CRTPF FILE(QTEMP/JOLDLOG_T) RCDLEN(133) + TEXT('Archives Log. Temporary Outfile') + SIZE(*NOMAX) /* Aggiusta parametri se scelto job corrente. */ IF COND(&JOBNAM *EQ '*') THEN(DO) CHGVAR VAR(&JOBUSR) VALUE('*N') CHGVAR VAR(&JOBNBR) VALUE('*N') ENDDO /* Elenca gli spool gia' generati dal job SCELTO. */ JWSF JOB(&JOBNBR/&JOBUSR/&JOBNAM) OUTFILE(JOLDLOG_W) /* Reindirizza il file da leggere. */ OVRDBF FILE(JWSF1) TOFILE(QTEMP/JOLDLOG_W) /* Cicla lettura record. */ DOWHILE COND(1 = 1) /* Legge un record dall'elenco spool del job. */ RCVF /* Se non ce ne sono altri, abbandona. */ MONMSG MSGID(CPF0864) EXEC(LEAVE) /* Se la stampa non e' piu' sul sistema, ricicla. */ IF COND(&WSFSSD *EQ FIN) THEN(ITERATE) /* Se corre una stampa di log. */ IF COND(&WSFSNA *EQ QPJOBLOG) THEN(DO) /* Aggiunge la stampa nel comodo. */ CPYSPLF FILE(&WSFSNA) TOFILE(QTEMP/&WRKF) + JOB(&JOBNBR/&JOBUSR/&JOBNAM) + SPLNBR(&WSFSNU) MBROPT(*ADD) CTLCHAR(*FCFC) /* Aggiunge una riga di separazione nel comodo. */ OVRDBF FILE(&WRKF) TOFILE(QTEMP/&WRKF) CALL PGM(JOLDLOGE) DLTOVR FILE(&WRKF) /* Se corre una stampa di log. */ ENDDO /* Cicla lettura record. */ ENDDO /* Pulisce dal comodo i record indesiderati. */ OVRDBF FILE(&WRKF) TOFILE(QTEMP/&WRKF) CALL PGM(JOLDLOGD) PARM(&FROMTAG &RQSID &FOUND) DLTOVR FILE(&WRKF) /* Comprime il comodo. */ RGZPFM FILE(QTEMP/&WRKF) /* Cancella l'outfile. */ DLTF FILE(&OUTLIB/&OUTFILE) MONMSG MSGID(CPF0000 MCH0000) /* Crea l'outfile. */ CRTPF FILE(&OUTLIB/&OUTFILE) RCDLEN(133) + TEXT('Archives Log. Outfile') SIZE(*NOMAX) MONMSG MSGID(CPF0000 MCH0000) /* Copia il comodo nell'outfile. */ CPYF FROMFILE(QTEMP/&WRKF) + TOFILE(&OUTLIB/&OUTFILE) MBROPT(*ADD) + FMTOPT(*NOCHK) /* Scrive il prototipo di richiesta di esplorazione del risultato. */ JRQT CMD(DSPPFM FILE(&OUTLIB/&OUTFILE)) REFPGM(*PRV) /* Label di esecuzione delle attivita' finali. */ RCLRSC: /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Se richiesto, rilascia il CPF0001. */ IF COND(&CPF0001) THEN(DO) SNDPGMMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JOLDLOG) + MSGTYPE(*ESCAPE) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Restituisce i messaggi al chiamante, */ /* trasformando eventuali escape in diagnostici. */ JRSNMSG MONMSG MSGID(CPF0000 MCH0000) /* Label di prenotazione del CPF0001. */ CPF0001: /* Prenota il CPF0001. */ CHGVAR VAR(&CPF0001) VALUE('1') MONMSG MSGID(CPF0000 MCH0000) /* Salta alle attivita' finali. */ GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JOLDLOGD) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Archives old log. PrunesOutfile * Archivia vecchio log. Pota il File di emissione * Claudio Neroni 30-10-2015 Creato. * Toglie le righe indesiderate dal log scaricato nel fisico. * *--------------------------------------------------------------------------------------------- * Archives Log. Outfile FJOLDLOG_T uf a f 133 disk infds(fids) *--------------------------------------------------------------------------------------------- * File Information Data Structure. D fids ds * Relative Record Number in Data Member. D fidsrr 397 400b 0 * Definisce il numero relativo del record iniziale dell'intervallo * da conservare. D okfrom s like(fidsrr) * Definisce numeri relativi di record estremi dell'intervallo * da cancellare. D dltfrom s like(fidsrr) D dltto s like(fidsrr) * Definisce numero relativo di record in cancellazione. D rrn s like(fidsrr) * Riga da emettere D out ds D outdata 2 133 * Identificazione delle prime quattro righe di ogni pagina di log. D qua s 33 dim(4) *--------------------------------------------------------------------------------------------- * Legge campi dal record. IJOLDLOG_T no 01 * Campo identificativo per individuare le prime quattro righe * di ogni pagina del log. I 1 33 int * Campo in cui puo' giacere il tipo messaggio. I 13 24 typ * Campo in cui puo' giacere il tag cercato. I 59 68 tag *--------------------------------------------------------------------------------------------- C START TAG *--------------------------------------------------------------------------------------------- * Prenota chiusura. C seton lr *--------------------------------------------------------------------------------------------- * Accantona i primi 33 caratteri delle prime quattro righe. C 1 do 4 rrn * Cerca senza update il record. C rrn chain(n) JOLDLOG_T * Trascrive i caratteri nella schiera. C eval qua(rrn) = int * Accantona i primi 33 caratteri delle prime quattro righe. C enddo *--------------------------------------------------------------------------------------------- * Annota il primo record da cancellare. C eval dltfrom = 5 *--------------------------------------------------------------------------------------------- * Trova il record che porta l'ultimo FromTag. C if 1=1 * Si posiziona a fine log. C *hival setgt JOLDLOG_T * Cicla all'infinito. C dow 1=1 * Legge senza update il record precedente. C readp(n) JOLDLOG_T * Se non ce ne sono altri, abbandona. C if %eof(JOLDLOG_T) C leave C endif * Se il record letto porta il FromTag nella posizione prevista, * annota Trovato FromTag e abbandona. C if tag = fromtag C eval fromtagfound = *on C leave C endif * Cicla all'infinito. C enddo * Trova il record che porta l'ultimo FromTag. C endif *--------------------------------------------------------------------------------------------- * Trova il record che porta il messaggio di richiesta * precedente a quello che porta l'ultimo FromTag. C if 1=1 * E' gia' posizionato sul record che porta l'ultimo FromTag. C* ... * Cicla all'infinito. C dow 1=1 * Legge senza update il record precedente. C readp(n) JOLDLOG_T * Se non ce ne sono altri, abbandona. C if %eof(JOLDLOG_T) C leave C endif * Se il record letto porta il tipo messaggio "Richiesta", * abbandona. C if typ = rqsid C leave C endif * Cicla all'infinito. C enddo * Trova il record che porta il messaggio di richiesta * precedente a quello che porta l'ultimo FromTag. C endif * Accantona tale record come primo record da conservare. C eval okfrom = fidsrr * Calcola l'ultimo record da cancellare. C eval dltto = fidsrr - 1 *--------------------------------------------------------------------------------------------- * Se Primo e Ultimo record da cancellare sono congruenti. C if dltto >= dltfrom * Cancella tutti i record tra primo e ultimo. C dltfrom do dltto rrn C rrn delete JOLDLOG_T C enddo * Se Primo e Ultimo record da cancellare sono congruenti. C endif *--------------------------------------------------------------------------------------------- * Cancella dai record da conservare le righe di intestazione * di ogni pagina C if 1=1 * Se primo record da conservare e' valorizzato. C if okfrom > *zero * Si posiziona prima del primo record da conservare. C okfrom setll JOLDLOG_T * Cicla all'infinito. C dow 1=1 * Legge senza update il record successivo. C read(n) JOLDLOG_T * Se non ce ne sono altri, abbandona. C if %eof(JOLDLOG_T) C leave C endif * Se l'identificazione del record non e' tra quelle accantonate,. * ricicla. C if %lookup(int:qua) = *zero C iter C endif * Cancella il record corrente riconosciuto come * intestazione di pagina di log. C fidsrr delete JOLDLOG_T * Cicla all'infinito. C enddo * Se primo record da conservare e' valorizzato. C endif * Cancella dai record da conservare le righe di intestazione * di ogni pagina C endif *--------------------------------------------------------------------------------------------- * Scrive una riga di fine log come separazione da log successivi. C** clear out C** eval outdata = *all'<<<>>> ' C** eval %subst(outdata:7:1) = '-' C** write JOLDLOG_T out *--------------------------------------------------------------------------------------------- * Inizializza. C *inzsr begsr * Scambia parametri. C *entry plist * Riceve il Tag che identifica il record di partenza * della parte da conservare del log. C parm fromtag 10 I From Tag * Riceve la costante che identifica un messaggio di richiesta * sulla stampa del log. C parm rqsid 12 I Request Identif * Ritorna Flag di Trovato From Tag. C parm fromtagfound 1 O From Tag Found * Inizializza Flag di Trovato From Tag. C eval fromtagfound = *off C endsr *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JOLDLOGE) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Archives old log. Separator * Archivia vecchio log. Separatore * Claudio Neroni 16-07-2016 Creato. * Scrive un record separatore in fondo alla trascrizione * di ogni spool file di log. *--------------------------------------------------------------------------------------------- * Archives Log. Outfile FJOLDLOG_T o f 133 disk *--------------------------------------------------------------------------------------------- * Riga da emettere D out ds D outdata 2 133 *--------------------------------------------------------------------------------------------- C START TAG *--------------------------------------------------------------------------------------------- * Prenota chiusura. C seton lr *--------------------------------------------------------------------------------------------- * Scrive una riga di fine log come separazione da log successivi. C clear out C eval outdata = *all'<<<>>> ' C eval %subst(outdata:7:1) = '-' C write JOLDLOG_T out *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JOLDLOGP) FILETYPE(*SRC) ENDCHAR('//ENDSRC') :PNLGRP. .*------------------------------------------------------------------------------ :HELP NAME=CMD. :H3.Comando JOLDLOG :H2.Archives old log :P.Archivia un vecchio log stampato :P.Trascrive in un file fisico le stampe di log di un lavoro preferibilmente gia' concluso. :P.Derivato dal comando :HP2.JLOG:EHP2. che fa lo stesso recupero di log sul lavoro in cui viene eseguito. :PC.Richiede che il lavoro in esame abbia stampato il log, anche se su stampe multiple, e che le stampe siano ancora presenti come spool file sul sistema. :PC.Recuperandolo dalle stampe, archivia in un file fisico una copia della stampa del log del lavoro richiesto. :PC.L'archiviazione parte dalla riga di richiesta che precede la riga ove giace l'ultima ricorrenza della stringa contenuta nel parametro FROMTAG e arriva fino alla fine del log disponibile su stampa. :PC.La costante di identificazione della riga di richiesta e' esplicitata nel parametro RQSID al solo scopo di permettere l'uso del comando JOLDLOG anche in altri release e in altre lingue. :P.A fine recupero, emette un promemoria di invito ad eseguire un DSPPFM (Display phisical file member) per esaminare il log trascritto traendo beneficio dalla ricerca case insensitive di tale visualizzazione. :P.Le stampe di log del lavoro possono essere una o molte. Alla fine di ogni stampa di log trascritta nel file fisico di emissione viene inserita una riga di separazione che inizia con: :PC."<<<>>>-<<<>>> <<<>>> <<<>>> ". :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/JOB'. :H3.Job (JOB) - name :P.Nome del lavoro. Obbligatorio. :P.:HP3.Valori permessi::EHP3. :PARML. :PT.nome-lavoro :PD.Nome del lavoro di cui si vuole ottenere la trascrizione del log. :PT.* :PD.Il lavoro e' quello corrente. :EPARML. :H3.Job (JOB) - user :P.Utente del lavoro. :P.:HP3.Valori permessi::EHP3. :PARML. :PT.nome-utente :PD.Nome dell'utente del lavoro di cui si vuole ottenere la trascrizione del log. :EPARML. :H3.Job (JOB) - number :P.Numero del lavoro. :P.:HP3.Valori permessi::EHP3. :PARML. :PT.numero-lavoro :PD.Numero del lavoro di cui si vuole ottenere la trascrizione del log. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/FROMTAG'. :H3.From tag in log (FROMTAG) :P.Etichetta di partenza della trascrizione del log. :P.L'etichetta da cercare nel log da trascrivere per identificare la riga di partenza della trascrizione. I caratteri cercati sono i primi dieci della trascrizione nel log di un testo messaggio. :P.Se l'etichetta non vieve trovata nel log, la trascrizione e' totale. :P.Se l'etichetta e' presente piu' volte nel log, la trascrizione inizia dall'ultima ricorrenza. :P.:HP3.Valori permessi::EHP3. :PARML. :PT.etichetta :PD.Stringa di caratteri da cercare. :EPARML. :P.:HP3.Valori speciali::EHP3. :PARML. :PT.:PK DEF.JOLDLOGFRM:EPK. :PD.Valore da cercare. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/RQSID'. :H3.Request ide in printed log (RQSID) :P.Identificazione dei messaggi di richiesta nel log. :P.:HP3.Valori permessi::EHP3. :PARML. :PT.stringa :PD.Stringa di caratteri che identifica le righe che portano i messaggi di richiesta presenti nel log. :EPARML. :P.:HP3.Valori speciali::EHP3. :PARML. :PT.:PK DEF.'Richiesta':EPK. :PD.Valore da cercare. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/OUTFILE'. :H3.Output file (OUTFILE) - file :P.Nome del file in cui scaricare il log trascritto. :P.Il file eventualmente preesistente viene cancellato e ricreato. :P.:HP3.Valori permessi::EHP3. :PARML. :PT.nome-file :PD.Nome del file in cui scaricare il log trascritto. :EPARML. :P.:HP3.Valori speciali::EHP3. :PARML. :PT.:PK DEF.JOLDLOGT:EPK. :PD.Nome di difetto del file in cui scaricare il log trascritto. :EPARML. :H3.Output file (OUTFILE) - library :P.Nome della libreria del file in cui scaricare il log trascritto. :P.:HP3.Valori permessi::EHP3. :PARML. :PT.nome-libreria :PD.Il file contenente il log trascritto si trova nella libreria richiesta. :EPARML. :P.:HP3.Valori speciali::EHP3. :PARML. :PT.:PK DEF.QTEMP:EPK. :PD.La libreria temporanea del lavoro. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/COMMAND/EXAMPLES'. :XH3.Esempi per JOLDLOG :P.:HP2.Esempio 1: Trascrive in un file fisico il log di un lavoro.:EHP2. :P.Si riportano comandi e log. :XMP. :HP2. > JOLDLOG JOB(231329/UFNERONI/JCMPLIB.) :EHP2. > /**/DSPPFM FILE(QTEMP/JOLDLOGT) :EXMP. :P.Anche con i parametri di default: :XMP. :HP2. > JOLDLOG JOB(231329/UFNERONI/JCMPLIB.) FROMTAG(JOLDLOGFRM) RQSID('Richiesta') OUTFILE(QTEMP/JOLDLOGT) :EHP2. > /**/DSPPFM FILE(QTEMP/JOLDLOGT) :EXMP. :P.Questo comando esegue la trascrizione nel file fisico il log del lavoro richiesto e propone un comando per la visualizzazione e la scansione del log trascritto. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/ERROR/MESSAGES'. .*--------------------- :XH3.Messaggi informativi e di completamento :P.:HP3.Messaggi *INFO, *COMP e *STATUS:EHP3. :DL COMPACT. :DT.JLG0002 :DD.&MSG(JLG0002,JOLDLOG,*LIBL,nosub). :EDL. .*--------------------- :XH3.Messaggi di errore :P.:HP3.Messaggi *DIAG seguiti da *ESCAPE CPF0001:EHP3. :DL COMPACT. :DT.JLG0001 :DD.&MSG(JLG0001,JOLDLOG,*LIBL,nosub). :EDL. .*--------------------- :EHELP. .*------------------------------------------------------------------------------ :EPNLGRP. //ENDSRC //ENDBCHJOB