JCL - Processamento Condicional
O Job Entry System usa duas abordagens para realizar o processamento condicional em um JCL. Quando um trabalho é concluído, um código de retorno é definido com base no status de execução. O código de retorno pode ser um número entre 0 (execução bem-sucedida) e 4095 (diferente de zero mostra a condição de erro). Os valores convencionais mais comuns são:
0 = Normal - tudo OK
4 = Aviso - pequenos erros ou problemas.
8 = Erro - erros ou problemas significativos.
12 = Erro grave - erros ou problemas graves, os resultados não são confiáveis.
16 = Erro de terminal - problemas muito sérios, não use os resultados.
A execução de uma etapa de trabalho pode ser controlada com base no código de retorno da (s) etapa (s) anterior (es) usando o COND parâmetro e IF-THEN-ELSE construção, que foi explicada neste tutorial.
Parâmetro COND
UMA CONDO parâmetro pode ser codificado na instrução JOB ou EXEC do JCL. É um teste do código de retorno das etapas anteriores do trabalho. Se o teste for avaliado como verdadeiro, a execução da etapa do trabalho atual será ignorada. Ignorar é apenas omissão da etapa de trabalho e não um encerramento anormal. Pode haver no máximo oito condições combinadas em um único teste.
Sintaxe
A seguir está a sintaxe básica de um parâmetro JCL COND:
COND=(rc,logical-operator)
or
COND=(rc,logical-operator,stepname)
or
COND=EVEN
or
COND=ONLYAqui está a descrição dos parâmetros usados:
rc : Este é o código de retorno
logical-operator : Pode ser GT (maior que), GE (maior que ou igual a), EQ (igual a), LT (menor que), LE (menor que ou igual a) ou NE (diferente a).
stepname : Esta é a etapa do trabalho cujo código de retorno é usado no teste.
As duas últimas condições (a) COND = EVEN e (b) COND = ONLY, foram explicadas abaixo neste tutorial.
O COND pode ser codificado dentro da instrução JOB ou EXEC e, em ambos os casos, se comporta de maneira diferente conforme explicado a seguir:
COND dentro da instrução JOB
Quando COND é codificado na instrução JOB, a condição é testada para cada etapa do trabalho. Quando a condição é verdadeira em qualquer etapa específica do trabalho, ela é ignorada junto com as etapas seguintes. A seguir está um exemplo:
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID,COND=(5,LE)
//*
//STEP10 EXEC PGM=FIRSTP
//* STEP10 executes without any test being performed.
//STEP20 EXEC PGM=SECONDP
//* STEP20 is bypassed, if RC of STEP10 is 5 or above. //* Say STEP10 ends with RC4 and hence test is false. //* So STEP20 executes and lets say it ends with RC16.
//STEP30 EXEC PGM=SORT
//* STEP30 is bypassed since 5 <= 16.COND dentro da instrução EXEC
Quando COND é codificado na instrução EXEC de uma etapa de trabalho e é considerado verdadeiro, apenas essa etapa de trabalho é ignorada e a execução continua a partir da próxima etapa.
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.
//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)
//* In STP02, condition evaluates to TRUE and step bypassed.
//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),(10,GT,STP02))
//* In STP03, first condition fails and hence STP03 executes. //* Since STP02 is bypassed, the condition (10,GT,STP02) in //* STP03 is not tested.COND = EVEN
Quando COND = EVEN é codificado, a etapa do trabalho atual é executada, mesmo se qualquer uma das etapas anteriores terminar de forma anormal. Se qualquer outra condição RC for codificada junto com COND = EVEN, a etapa do trabalho será executada se nenhuma das condições RC for verdadeira.
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.
//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)
//* In STP02, condition evaluates to TRUE and step bypassed.
//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),EVEN)
//* In STP03, condition (10,LT,STP01) evaluates to true, //* hence the step is bypassed.COND = SÓ
Quando COND = ONLY é codificado, a etapa do trabalho atual é executada, apenas quando qualquer uma das etapas anteriores termina de forma anormal. Se qualquer outra condição RC for codificada junto com COND = ONLY, a etapa do trabalho será executada se nenhuma das condições RC for verdadeira e qualquer uma das etapas anteriores falhar de forma anormal.
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.
//STP02 EXEC PGM=MYCOBB,COND=(4,EQ,STP01)
//* In STP02, condition evaluates to FALSE, step is executed //* and assume the step abends.
//STP03 EXEC PGM=IEBGENER,COND=((0,EQ,STP01),ONLY)
//* In STP03, though the STP02 abends, the condition //* (0,EQ,STP01) is met. Hence STP03 is bypassed.Construção IF-THEN-ELSE
Outra abordagem para controlar o processamento do trabalho é usando construções IF-THEN-ELSE. Isso dá mais flexibilidade e uma maneira amigável de processamento condicional.
Sintaxe
A seguir está a sintaxe básica de uma construção JCL IF-THEN-ELSE:
//name IF condition THEN
list of statements //* action to be taken when condition is true
//name ELSE
list of statements //* action to be taken when condition is false
//name ENDIFA seguir está a descrição dos termos usados na construção IF-THEN-ELSE acima:
name : Isso é opcional e um nome pode ter de 1 a 8 caracteres alfanuméricos começando com alfabeto, #, $ ou @.
Condition : Uma condição terá um formato: KEYWORD OPERATOR VALUE, Onde KEYWORDSpode ser RC (código de retorno), ABENDCC (código de conclusão do sistema ou usuário), ABEND, RUN (etapa iniciada execução). AOPERATOR pode ser operador lógico (AND (&), OR (|)) ou operador relacional (<, <=,>,> =, <>).
Exemplo
A seguir está um exemplo simples que mostra o uso de IF-THEN-ELSE:
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//PRC1 PROC
//PST1 EXEC PGM=SORT
//PST2 EXEC PGM=IEBGENER
// PEND
//STP01 EXEC PGM=SORT
//IF1 IF STP01.RC = 0 THEN
//STP02 EXEC PGM=MYCOBB1,PARM=123
// ENDIF
//IF2 IF STP01.RUN THEN
//STP03a EXEC PGM=IEBGENER
//STP03b EXEC PGM=SORT
// ENDIF
//IF3 IF STP03b.!ABEND THEN
//STP04 EXEC PGM=MYCOBB1,PARM=456
// ELSE
// ENDIF
//IF4 IF (STP01.RC = 0 & STP02.RC <= 4) THEN
//STP05 EXEC PROC=PRC1
// ENDIF
//IF5 IF STP05.PRC1.PST1.ABEND THEN
//STP06 EXEC PGM=MYABD
// ELSE
//STP07 EXEC PGM=SORT
// ENDIFVamos tentar examinar o programa acima para entendê-lo com um pouco mais de detalhes:
O código de retorno de STP01 é testado em IF1. Se for 0, então STP02 é executado. Caso contrário, o processamento vai para a próxima instrução IF (IF2).
Em IF2, se STP01 iniciou a execução, então STP03a e STP03b são executados.
Em IF3, se STP03b não ABEND, então STP04 é executado. Em ELSE, não há declarações. É chamado de instrução NULL ELSE.
Em IF4, se STP01.RC = 0 e STP02.RC <= 4 forem TRUE, então STP05 é executado.
Em IF5, se a etapa proc PST1 em PROC PRC1 na etapa de trabalho STP05 ABEND, então STP06 é executado. Caso contrário, STP07 é executado.
Se IF4 for avaliado como falso, então STP05 não é executado. Nesse caso, IF5 não são testados e as etapas STP06, STP07 não são executadas.
O IF-THEN-ELSE não será executado no caso de término anormal do trabalho, como o cancelamento do trabalho pelo usuário, a expiração do tempo do trabalho ou um conjunto de dados retrocedido para uma etapa que é ignorada.
Definir pontos de verificação
Você pode definir o conjunto de dados do ponto de verificação dentro do seu programa JCL usando SYSCKEOV, que é uma instrução DD.
UMA CHKPTé o parâmetro codificado para conjuntos de dados QSAM de vários volumes em uma instrução DD. Quando um CHKPT é codificado como CHKPT = EOV, um ponto de verificação é gravado no conjunto de dados especificado na instrução SYSCKEOV no final de cada volume do conjunto de dados multivolume de entrada / saída.
//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=MYCOBB
//SYSCKEOV DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1 DD DSN=SAMPLE.IN,DISP=SHR
//OUT1 DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
// CHKPT=EOV,LRECL=80,RECFM=FBNo exemplo acima, um ponto de verificação é escrito no conjunto de dados SAMPLE.CHK no final de cada volume do conjunto de dados de saída SAMPLE.OUT.
Reiniciar o processamento
Você pode reiniciar o processamento do éter de forma automatizada usando o RD parameter ou manual usando o RESTART parameter.
RD parameter é codificado na instrução JOB ou EXEC e ajuda na reinicialização JOB / STEP automatizada e pode conter um dos quatro valores: R, RNC, NR ou NC.
RD=R permite reinicializações automatizadas e considera o ponto de verificação codificado no parâmetro CHKPT da instrução DD.
RD=RNC permite reinicializações automatizadas, mas substitui (ignora) o parâmetro CHKPT.
RD=NRespecifica que o trabalho / etapa não pode ser reiniciado automaticamente. Mas quando ele é reiniciado manualmente usando o parâmetro RESTART, o parâmetro CHKPT (se houver) será considerado.
RD=NC não permite reinicialização automatizada e processamento de ponto de verificação.
Se houver um requisito para fazer o reinício automatizado apenas para códigos de abend específicos, ele pode ser especificado no SCHEDxx membro da biblioteca parmlib do sistema IBM.
RESTART parameterestá codificado na instrução JOB ou EXEC e ajuda na reinicialização manual do JOB / STEP após a falha do trabalho. RESTART pode ser acompanhado por um checkid, que é o checkpoint escrito no conjunto de dados codificado na instrução SYSCKEOV DD. Quando um checkid é codificado, a instrução SYSCHK DD deve ser codificada para fazer referência ao conjunto de dados do ponto de verificação após a instrução JOBLIB (se houver), caso contrário, após a instrução JOB.
//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID,RESTART=(STP01,chk5)
//*
//SYSCHK DD DSN=SAMPLE.CHK,DISP=OLD
//STP01 EXEC PGM=MYCOBB
//*SYSCKEOV DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1 DD DSN=SAMPLE.IN,DISP=SHR
//OUT1 DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
// CHKPT=EOV,LRECL=80,RECFM=FBNo exemplo acima, chk5 é o checkid, ou seja, STP01 é reiniciado no checkpoint5. Observe que uma instrução SYSCHK foi adicionada e a instrução SYSCKEOV foi comentada no programa anterior explicado na seção Configurando o ponto de verificação.