JCL ABDISPCC na prática em z/OS

ABDISPCC é uma adição recente ao JCL porque resolve um problema operacional real: um passo pode terminar normalmente, mas com um código de retorno suficientemente elevado para que a sua saída deixe de ser fiável. Em JCL mais antigo, isso normalmente significava lógica extra de cleanup em passos seguintes ou trabalho procedural fora do job.

Este artigo é deliberadamente prático. Usa pequenos jobs IDCAMS que terminam com códigos de retorno controlados e mostra exatamente como ABDISPCC altera o resultado de disposition de um data set recém-alocado.

1. Objetivos do laboratório

No fim deste laboratório deverá ser capaz de:

• Explicar o que faz ABDISPCC na instrução EXEC
• Distinguir controlo de disposition de controlo de fluxo entre passos
• Provar o comportamento de base sem ABDISPCC
• Usar ABDISPCC=(8,GE) para impedir que saída suspeita seja catalogada
• Compreender a diferença entre GT e GE

2. Ambiente necessário

Para este laboratório, use:

• z/OS 2.5 ou posterior
• JES2
• acesso TSO/ISPF com permissão para submeter jobs batch
• um ID de utilizador que possa alocar data sets de teste catalogados com o prefixo &SYSUID

Nota importante:

• A IBM documenta ABDISPCC como uma palavra-chave mais recente de EXEC e refere também que não é suportada em ambientes JES3
• A função foi entregue pelo APAR OA63081 para HBB77C0 e superiores
• Nível mínimo prático:
• z/OS 2.5 com PTF UJ93787
• z/OS 3.1 com PTF UJ93788
• z/OS 3.2 com PTF UJ93785

Se o seu sistema não reconhecer a palavra-chave ABDISPCC, a causa mais provável é a ausência da manutenção necessária.

3. O que ABDISPCC altera

Sem ABDISPCC, um passo que termina normalmente usa sempre a disposition de fim normal definida em DISP ou PATHDISP, mesmo que o código de retorno seja indesejável.

Com ABDISPCC, pode escrever:

//STEP1 EXEC PGM=program-name,ABDISPCC=(code,operator)

O sistema compara o código de conclusão do passo atual com a condição:

Quando a condição corresponde, o z/OS aplica a lógica de disposition de fim anormal às instruções DD desse passo, mesmo que o passo tenha terminado normalmente.

Esse é todo o valor de ABDISPCC: permite dizer, em JCL, “um RC 8 ou superior é suficientemente mau para que a saída seja tratada como saída de falha.”

4. Distinção importante: controlo de disposition não é controlo de fluxo

ABDISPCC não controla se o passo seguinte é executado. Afeta apenas o processamento de disposition das DD do passo atual.

Use os seguintes mecanismos para finalidades diferentes:

5. Como o laboratório funciona

Vamos submeter quatro pequenos jobs:

Os quatro jobs alocam um novo data set sequencial com:

DISP=(NEW,CATLG,DELETE)

O passo executa depois IDCAMS e define um código de retorno controlado com SET MAXCC=8 ou SET MAXCC=12.

Isto torna o resultado fácil de observar:

• se a disposition normal se aplicar, o data set é catalogado
• se a disposition anormal se aplicar, o data set é eliminado

6. Job 1: comportamento de base sem ABDISPCC

Crie um membro JCL como ABDNOCC com o seguinte conteúdo:

//ABDNOCC  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//TESTOUT  DD  DSN=&SYSUID..ABDISPCC.NOCC,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=8
/*

Submeta o job e inspecione a saída:

• o passo deve terminar normalmente
• o código de conclusão do passo deve ser 8

Agora verifique se o data set existe. Pode fazê-lo em ISPF 3.4, ou com um pequeno job IDCAMS de verificação como este:

//ABDCHK1  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  LISTCAT ENTRIES('&SYSUID..ABDISPCC.NOCC')
/*

Resultado esperado:

• &SYSUID..ABDISPCC.NOCC existe

Porquê:

• o passo terminou normalmente
• não existia ABDISPCC
• por isso o z/OS usou a disposition normal, que é CATLG

Este é o comportamento base que frequentemente surpreende: um job pode devolver RC 8 e mesmo assim catalogar a saída.

7. Job 2: usar ABDISPCC=(8,GE)

Crie um segundo membro chamado ABDGE8:

//ABDGE8   JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS,ABDISPCC=(8,GE)
//TESTOUT  DD  DSN=&SYSUID..ABDISPCC.GE8,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=8
/*

Submeta-o e observe o resultado:

• o passo deve voltar a terminar normalmente com código de conclusão 8

Agora verifique o estado no catálogo:

//ABDCHK2  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  LISTCAT ENTRIES('&SYSUID..ABDISPCC.GE8')
/*

Resultado esperado:

• o data set não deve ser encontrado

Porquê:

• o passo terminou normalmente com RC 8
• ABDISPCC=(8,GE) teve correspondência
• o z/OS aplicou então a disposition de fim anormal
• o terceiro subparâmetro de DISP é DELETE

Este é o padrão de produção mais imediatamente útil:

DISP=(NEW,CATLG,DELETE)

combinado com:

ABDISPCC=(8,GE)

Isto quer dizer: “catalogue a saída apenas se o passo tiver realmente concluído com qualidade suficiente.”

8. Job 3: GT é diferente de GE

Agora crie ABDGT8:

//ABDGT8   JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS,ABDISPCC=(8,GT)
//TESTOUT  DD  DSN=&SYSUID..ABDISPCC.GT8,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=8
/*

Submeta o job e verifique:

//ABDCHK3  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  LISTCAT ENTRIES('&SYSUID..ABDISPCC.GT8')
/*

Resultado esperado:

• o data set existe

Porquê:

• RC 8 não é superior a 8
• ABDISPCC=(8,GT) não tem correspondência
• o z/OS continua a usar a disposition normal

Esta é a diferença exata:

9. Job 4: ABDISPCC=(8,GT) com um código de retorno superior

Crie um último membro, ABDGT12:

//ABDGT12  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS,ABDISPCC=(8,GT)
//TESTOUT  DD  DSN=&SYSUID..ABDISPCC.GT12,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=12
/*

Verifique-o:

//ABDCHK4  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  LISTCAT ENTRIES('&SYSUID..ABDISPCC.GT12')
/*

Resultado esperado:

• o data set não é encontrado

Porquê:

• RC 12 é superior a 8
• ABDISPCC=(8,GT) tem correspondência
• o z/OS aplica a disposition anormal e elimina o data set

10. Onde ABDISPCC é mais útil

Os casos de uso mais práticos são:

• passos batch que alocam um novo data set de saída e só o devem catalogar para códigos de retorno aceitáveis
• passos de geração de relatórios em que RC 4 pode ser aceitável mas RC 8 deve descartar a saída
• passos de unload, extração ou transformação que podem terminar normalmente mas ainda assim produzir resultados inutilizáveis
• processamento de ficheiros z/OS UNIX com PATHDISP, porque a mesma lógica também se aplica aí

Em termos de desenho, ABDISPCC permite manter a política de código de retorno perto do passo que cria a saída.

11. Erro comum a evitar

Não trate ABDISPCC como substituto de COND ou IF/THEN/ELSE.

Esta é a forma errada de pensar:

• “Usei ABDISPCC, por isso os passos seguintes não vão executar.”

Esta é a forma correta de pensar:

• “Usei ABDISPCC, por isso a saída deste passo será eliminada em vez de catalogada quando o código de retorno for demasiado elevado.”

Se também precisar de parar ou ignorar passos seguintes, adicione separadamente a lógica normal de controlo de fluxo em JCL.

12. Cleanup

Se quiser remover quaisquer data sets criados durante o laboratório, submeta:

//ABDCLN   JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  DELETE '&SYSUID..ABDISPCC.NOCC'
  IF LASTCC = 8 THEN SET MAXCC = 0
  DELETE '&SYSUID..ABDISPCC.GE8'
  IF LASTCC = 8 THEN SET MAXCC = 0
  DELETE '&SYSUID..ABDISPCC.GT8'
  IF LASTCC = 8 THEN SET MAXCC = 0
  DELETE '&SYSUID..ABDISPCC.GT12'
  IF LASTCC = 8 THEN SET MAXCC = 0
/*

Resumo

ABDISPCC é pequeno, mas muito útil do ponto de vista operacional. Permite transformar um limiar de código de retorno normal numa decisão de disposition sem passos extra de cleanup.

O padrão prático principal é:

//STEP1   EXEC PGM=program-name,ABDISPCC=(8,GE)
//OUTDD   DD   DSN=...,DISP=(NEW,CATLG,DELETE)

Isto significa:

• catalogar a saída apenas quando o passo termina com qualidade suficiente
• caso contrário, eliminá-la, mesmo que o passo tenha terminado normalmente

Documentação IBM útil

• Parâmetro ABDISPCC
• Instrução EXEC
• Resumo das alterações no z/OS 3.1
• Resumo do processamento de disposition
• Comando IDCAMS SET
• Comando LISTCAT
• APAR OA63081 - nova função para ABDISPCC