Pesquisar este blog

Mostrando postagens com marcador Z/Os. Mostrar todas as postagens
Mostrando postagens com marcador Z/Os. Mostrar todas as postagens

quinta-feira, 30 de novembro de 2023

The End of an Era - Last Mainframe Shutdown at Petrobras

Resumo: Buga comenta a desativação do mainframe da Petrobras há um ano, discutindo COBOL, legado, tentativas de migração e o futuro dos mainframes no setor bancário.

Desligando o Mainframe da Petrobras: Reflexões sobre Legado e Tecnologia

Há 1 ano a Petrobras tirava de operação seu mainframe!

Contexto e Histórico

Desde que comecei a trabalhar com cartão de crédito ouço falar que o mainframe está morrendo.

Existiram algumas tentativas em meados de 90 que deram em nada, quer dizer, giraram a economia, mas não atingiram o resultado pretendido. De uns 10 anos pra cá está rolando uma conversão automática de código COBOL pra Java, a própria IBM e no momento a Kyndryl tem projetos e oferece mão de obra e serviços para essa demanda, mas, na real, não funciona satisfatoriamente. A Cielo chegou a comprar um adquirente americano que rodava fora do ambiente mainframe pra incorporar a tecnologia, mas não deu certo.

Tentativas de Migração e Limitações

O que vai acabar com o mainframe não são as novas tecnologias, longe disso, até porque a maioria das tecnologias disruptivas que vemos atualmente nada mais são que usos de ideias e conceitos que já existem nos mainframes há décadas, mas isso é discussão acalorada e pra outra ocasião.

Atualmente, no setor bancário/cartão só existe 1 pilar que ainda sustenta o mainframe vivo, o legado!

De um sistema aqui, outro ali, vão migrando, convertendo, desligando algumas siglas, criando um novo sistema em baixa plataforma pra prover a mesma solução, movimento esse que nunca entendi creio que é mais seguir a onda, não ficar para trás porque tem gente fazendo assim preciso fazer também. Igual tantas outras modas como as metodologias ágeis ou ainda tentar aplicar testes de completude ou automatizados, que sequer fazem sentido pro COBOL.

Voltando ao legado, dependendo da aplicação, não dá pra reescrever, seja automaticamente ou não, não há pessoas que embarquem na ideia, o risco é inaceitável.

O Futuro dos Mainframes

Daria pros bancos continuarem pro resto da vida trabalhando com mainframes, sério!

O mainframe se adaptou, evoluiu mas demorou muito pra levar isso aos clientes, a IBM errou e errou feio ao não mudar seu modelo de negócio, restringir o acesso a tecnologia ao invés de incentivar como todos os players da computação em nuvem sempre fizeram, enfim agora é tarde, o estrago já foi feito e é irreparável.

O IBM mainframe continua evoluindo, o hardware está no limiar da tecnologia atual, os compiladores estão mais robustos e otimizados, os gerenciadores de transações, seja ela o tupiniquim GRI do Itaú Unibanco e do Banco do Brasil CICS continua uma obra de arte o IMS idem, seu banco de dados, o DB2 nem se fala e o Z/Os, seu sistema operacional é um espetáculo à parte!

O que decretará o fim da computação centralizada em hardwares Z da IBM será a migração de saldos, mas isso vai demorar um bocado, se é que acontecerá de verdade. Ainda não vi movimentação grande de nenhum banco nesse sentido (banco aqui leia-se, Santander Brasil, CAIXA, Banco Bradesco, Itaú Unibanco e Banco do Brasil).

Longa vida ao mainframe!

Escrito e revisto meia boca, porque to na hora do almoço!

Foto com a tela de shutdown do mainframe da Petrobras
Figura 1: Desligando pra sempre o mainframe da Petrobras

terça-feira, 10 de agosto de 2021

TSO ISRDDN MEMBER(xpto) - Achar onde um determinado carga esta!


Por vezes precisei procurar onde um maldito carga executado, CLIST, REXX ou que seja que era excutado direto via TSO estava .

O comando em epigrafe resolve o mistério!

Mainframe, mega dica boa



Atualizacao em 11.06.2025, via IA

Como usar o ISRDDN no Mainframe TSO/ISPF

O que é o ISRDDN?

O ISRDDN é uma ferramenta diagnóstica do z/OS, fundamental para quem trabalha com TSO/ISPF no mainframe. Ela permite listar todos os DDNAMEs (datasets, bibliotecas, arquivos) alocados na sua sessão TSO, facilitando a localização de módulos, cargas e bibliotecas em uso no momento.

Principais funcionalidades

  • Lista todos os DDNAMEs e datasets alocados na sessão TSO/ISPF.
  • Mostra em quais bibliotecas estão os módulos executáveis (load modules).
  • Ajuda a identificar duplicidades, conflitos e bibliotecas vazias.
  • Permite examinar, editar, navegar e executar comandos sobre os datasets listados.
  • Exibe a ordem de busca de módulos (STEPLIB, ISPLLIB, LINKLIST, LPA, etc.).

Como acessar o ISRDDN

  1. No ISPF, digite TSO ISRDDN ou DDLIST na linha de comando e pressione Enter.
  2. Será exibida uma tela com todos os DDNAMEs e datasets alocados na sua sessão.
  3. Você pode pesquisar, navegar, editar ou examinar qualquer dataset diretamente dessa lista.

Exemplo de uso prático

  • Descobrir de onde um programa está sendo carregado: Procure pelo nome do módulo nas bibliotecas LOAD listadas (STEPLIB, ISPLLIB, LINKLIST, etc.).
  • Verificar se uma atualização está ativa: Veja se o módulo atualizado está na biblioteca correta e em uso.
  • Diagnóstico de problemas: Identifique bibliotecas duplicadas, vazias ou conflitos de datasets.
  • Análise de ambiente: Veja todas as bibliotecas que sua sessão está usando, incluindo as do sistema e pessoais.

Recursos avançados

  • Visualizar ENQs (locks) e contendas.
  • Navegar na memória (útil para suporte avançado).
  • Adicionar bibliotecas do sistema à visualização para checar se um módulo está em LPA ou LINKLIST.

Resumo

O ISRDDN é uma ferramenta essencial para suporte, análise e troubleshooting em ambientes mainframe. Com ele, você descobre exatamente de onde está vindo qualquer módulo ou carga em uso na sua sessão, facilitando o diagnóstico e a administração do ambiente z/OS.

segunda-feira, 6 de julho de 2020

Manuais Changeman - Controle de versao mainframe

Manuais Changeman - Controle de Versão Mainframe

Manuais Changeman - Controle de Versão Mainframe

Atualização em 11/06/2025:

Este post foi revisado hoje com a ajuda do Perplexity AI (e quem sabe mais alguma IA que eu nem conhecia até agora!).

Fiquei lembrando da Borland, que era simplesmente o máximo nos anos 90 para qualquer dev (Delphi, Turbo Pascal, C++ Builder, etc).

Se você curte história de tecnologia, vale a pena ler In Search of Stupidity: Over 20 Years of High-Tech Marketing Disasters, que explica como a Borland colapsou: basicamente, uma sequência de decisões de marketing ruins, briga de egos, aquisições malucas e a concorrência feroz da Microsoft.

Depois, a Micro Focus dominou com o Mainframe Express e, agora, apareceu até a Rocket Software com documentação nova do Changeman, que eu nunca tinha ouvido falar.

A propósito, segue um link novo e funcional da documentação Changeman (Rocket Software):

https://docs.rocketsoftware.com/pt-BR/bundle?cluster=true&labelkey=prod_changeman_zmf


Vamos ver o que a IA gerou... olha, não gostei não. Demora muito, cria narrativa que não tem fundamento, baseia-se em uma fonte e essa fonte você não acha. Não segue uma linha cronológica de acontecimentos, não pega os fatos que levaram de A a D, simplesmente ignora o B e o C. Sei lá, ainda não está bom a ponto de deixar seguir a vida sozinha, mas já está muito, muito melhor que o bom e velho Watson que tive meu primeiro contato lá pelos idos de 2014, se não me engano.

À época fiquei deveras impressionado. Não avançou muito nesses últimos 10 anos. A IBM é incomparável na arte de inovar/criar um negócio totalmente doido, disruptivo de verdade e não conseguir/saber vender. E aí, depois de uns 5-10 anos, aparece algum gatuno, 'rouba' a ideia e faz dinheiro com isso. Sempre foi assim, desde os primórdios! Eu gosto muito, respeito a Big Blue, já passei por lá em duas ocasiões, mas olha, dá dó!

Não lembro direito, mas no livro que citei no comecinho deve ter! Não tudo, porque daria um livro só de grandes big fails da IBM, mas um ou outro deve ter sim.

Enfim, bora colocar o que a IA gerou e seguir com a vida...


Atualização em 11/06/2025:

Este post foi revisado hoje com a ajuda do Perplexity AI — e, sinceramente, é incrível como as inteligências artificiais vêm transformando a forma de pesquisar, cruzar informações e atualizar conteúdos técnicos e históricos. Ferramentas como essa permitem que a gente conecte fatos, datas e curiosidades que antes exigiam horas de garimpo manual.

No meio dessa atualização, acabei embarcando numa viagem nostálgica ao lembrar da Borland — uma verdadeira lenda para quem viveu o auge do desenvolvimento de software nos anos 80 e 90. Para muitos devs, Borland era sinônimo de inovação e produtividade: nomes como Delphi, Turbo Pascal, C++ Builder e Paradox marcaram época e criaram padrões de facilidade e qualidade em programação. Não à toa, muita gente dizia que “quem usava Borland, programava sorrindo

Mas, como tantas gigantes da tecnologia, a Borland também teve seus dias difíceis. O livro In Search of Stupidity: Over 20 Years of High-Tech Marketing Disasters conta em detalhes como decisões de marketing desastrosas, brigas internas e a concorrência implacável da Microsoft acabaram levando a Borland do topo ao declínio. No mundo tech, não basta ter o melhor produto: estratégia, timing e humildade para ouvir o mercado são fundamentais.

Linha do tempo do ChangeMan ZMF:

  • Serena Software: O ChangeMan ZMF nasceu e foi desenvolvido pela Serena, tornando-se referência em controle de versão para mainframe.
  • Micro Focus: Em 2016, a Micro Focus comprou a Serena e passou a controlar o ChangeMan ZMF, além de já ser dona de ferramentas como o Mainframe Express (cuja origem remonta à Merant, outra fusão histórica do mundo COBOL).
  • OpenText: Em 2023, a OpenText adquiriu a Micro Focus, levando junto o portfólio de produtos mainframe e ALM.
  • Rocket Software:Em 2024, a Rocket Software comprou da OpenText toda a divisão de Application Modernization and Connectivity (AMC), incluindo o ChangeMan ZMF, RUMBA, Reflection, ferramentas COBOL e outros clássicos do universo mainframe.

Ou seja, o ChangeMan já passou pelas mãos de Serena, Micro Focus, OpenText e agora está sob o guarda-chuva da Rocket Software, que tem histórico forte em soluções para mainframe, integração, modernização e automação de ambientes z/OS.

O universo mainframe, que muitos consideram “antigo”, segue se reinventando. Ferramentas clássicas como o ChangeMan continuam evoluindo, mostrando que tradição e inovação podem andar juntas — e que o legado dessas empresas ainda faz diferença para quem trabalha com missão crítica.

Fica aqui o convite para quem quiser explorar mais: segue um link novo e funcional da documentação Changeman (Rocket Software), que pode ser uma mão na roda para quem está lidando com controle de versão em ambientes z/OS ou simplesmente quer matar a curiosidade sobre como essas ferramentas evoluíram.


Conteúdo original do post permanece abaixo, eram só essas 2 linhas aqui abaixo! uauauauaua

Acho que nem lembrava que a Borland, sic, Microfocus tinha comprado o changeman.

https://www.microfocus.com/documentation/changeman-zmf/changemanzmf813/

quinta-feira, 14 de maio de 2020

Teclado Buga pro PCOMM - Personal Comunications - Emulador de terminal 3270 da IBM

Teclado Buga pro PCOMM - Personal Comunications - Emulador de terminal 3270 da IBM



Atualizacao em 06.06.2025
To aqui ressucitando velhos fantasmas!




-------------------------------------------------------------------------------------------------------------------

Aqui ó que maravilha - teclado do buga.kmp
Figura -1 : Teclado do buga.kmp

Captura de onde tem que ir pra configurar/apontar pro teclado personalizado
Figura 0: pcsws.exe em execucao









 Quem é das antigas igual eu, curte uma customizada no teclado do seu 3270, cada um trabalha de um jeito e sua produtividade aumenta bem quando esta trabalhando em algo que voce esta acostumado.


Estou usando o

Figura 1: pcomm 6.0


Devo ter algum mais novo ou mesmo um que nao seja Trial, mas enfim, vamos seguir com esse splash Screen que foi o que encontrei.


O teclado esta aqui.


https://drive.google.com/file/d/0B59qH6QDRq_uRDRCMGViTTV2bG8/view?usp=sharing



Que eu lembre onde deixei num futuro proximo que venha a precisar, porque hoje procurei e demorei pra achar!



Segue ultima configuração do Personal Communications que fiz aqui pra testar com o Zowe.


Se um dia perder o 3270 da IBM, tem desse cara aqui que da conta do recado para brincar.

Vista TN3270 - Tom Brennan

http://www.tombrennansoftware.com/download.html

http://www.tombrennansoftware.com/vista127_2014-11-12.exe

em todos os casos, vamos deixar o link aqui pra download da versao que baixei hoje (06.06.2025) 
https://drive.google.com/file/d/1cUnMYzfzCeKlJxkPI4E1VC0aP-U_DS9t/view?usp=sharing

quinta-feira, 14 de fevereiro de 2019

REXX para localizar string em pacotes do Changeman

Atualizado em 2025 06 11 - Reescreve o post com ajuda do perplexity, nao testei o fonte e nem comparei pra ver se ele mudou alguma coisa, mas bonito devo dizer que ficou!


REXX para localizar string em pacotes do Changeman

Este script REXX realiza uma busca por uma string em todos os membros de um pacote do Changeman, gerando um relatório com os resultados encontrados. Útil para quem precisa localizar rapidamente trechos de código ou referências em ambientes mainframe integrados ao ChangeMan.

Exemplo de uso

Execute o script informando a sigla do sistema, o número do pacote e a string a ser pesquisada.

Código REXX

FINDCHG.REXX

/**  REXX  **/                                                        
arg sigla pacote texto                                                
call valida_parametros;                                                
call verifica_se_pacote_existe;                                        
/* aqui a magica acontece! */                                          
call outtrap "mbrs."                                                  
"LISTD" "'"pdsname"'" "MEMBERS"                                        
call outtrap "off"                                                    
                                                                       
do ndx=1 to mbrs.0                                                    
   if mbrs.ndx = "--MEMBERS--" then leave                              
end                                                                    
ndx=ndx+1                                                              
qtd_membros = mbrs.0 - ndx + 1                                        
say 'Procuraremos a string em ' qtd_membros ' membros.'                
/* "ALLOC FI(RELAT) DA('WALBUGA.OUTDD.SAIDA') MOD REUSE" */            
log = USERID()'.OUTDD.SAIDA'                                          
say log                                                                
/* "ALLOC FI(RELAT) DA(log) MOD REUSE"                                
   "ALLOC F(SYS010) DS('"particionado"("membro")') SHR REUSE"          
   "ALLOC FI(RELAT) DA('WALBUGA.OUTDD.SAIDA') MOD REUSE"  */          
 "ALLOC FI(RELAT) DA('"log"') MOD REUSE"                              
IF RC \= 0 THEN                                                        
   DO                                                                  
      say "----------------------------------------"                  
      say "Erro na alocacao do arquivo de relatorio"                  
      say "----------------------------------------"                  
     EXIT 0                                                            
   END                                                                
/* aqui a magica acontece 2! */                                        
call listdsi "'"pdsname"'"                                            
particionado=sysdsname                                                
/**-----------------------------------------------------------------**/
linha.1="------------------------------------------------"            
linha.2="Inicio do processamento ------------------------"            
linha.3="------------------------------------------------"              
linha.4="Procurando " pdsname " por <" texto ">"                        
linha.5="------------------------------------------------"              
linha.0=5                                                              
"EXECIO" linha.0 "DISKW RELAT (STEM linha."                            
do curmbr = ndx to mbrs.0                                              
   parse value mbrs.curmbr with membro                                  
   membro=strip(membro)                                                
   flag=1                                                              
/* say "member="particionado"("membro")" */                            
/* assim sai o membro */                                                
/* aqui =  'particionadome' ||(membro) */                              
/* aqui = "'"(membro)"'" */                                            
/* say aqui */                                                          
/* "ALLOC F(SYS010) DS('"particionado"("membro")') SHR REUSE" */        
   "ALLOC F(SYS010) DS('"particionado"("membro")') SHR REUSE"          
/* "ALLOC F(SYS010) DS("'"aqui"'") SHR REUSE" */                        
   "EXECIO * DISKR SYS010 (FINIS STEM in."                              
   "FREE F(SYS010)"                                                    
   fnd=0                                                                
   do recid=1 to in.0                                                  
      if pos(texto,in.recid) > 0 then                                  
        do                                                              
           if flag = 1 then                                            
             do                                                        
              linha.1="------------------------------------------------"
              linha.2="----> " membro " contem <" texto ">"            
              say linha.2                                              
              linha.3 = in.recid                                        
              linha.0=3                                                
              "EXECIO" linha.0 "DISKW RELAT (STEM linha."              
              flag=0                                                    
             end                                                        
           linha.1 = in.recid                                          
           linha.0=1                                                    
           "EXECIO" linha.0 "DISKW RELAT (STEM linha."                  
        end                                                            
   end                                                                  
end                                                                    
say '*** Pesquisa finalizada com sucesso ***'                          
linha.1="////////////////////////////////////////////////"            
linha.2="////////////////////////////////////////////////"            
linha.3="////////////////////////////////////////////    "            
linha.4="//////////////////////////////////////////// FIM"            
linha.5="////////////////////////////////////////////////"            
linha.0=5                                                              
"EXECIO" linha.0 "DISKW RELAT (STEM linha."                            
"EXECIO 0 DISKW RELAT (FINIS"                                          
"FREE F(RELAT)"                                                        
exit 0                                                                
                                                                       
/*----------------------- */                                          
valida_parametros:                                                    
/*----------------------- */                                          
if sigla = "" | pacote = "" | texto = "" then                          
 do                                                                    
   clear                                                              
   say ""                                                              
   say "Bem vindo "  USERID()                                          
   say ""                                                              
   say  "Informe: "                                                    
   say  " - sigla do sistema"                                          
   say  " - numero do pacote "                                        
   say  " - string a ser pesquisada"                                  
   say ""                                                              
   say  "Como não foi informado abrirei a opcao de informar abaixo."  
   say ""                                                              
   say  "Digite SAI para sair, tecle ENTER para continuar..."          
   pull ok                                                            
   say ""                                                              
   /* if parse upper (ok) = 'SAI' then         -- VER USO DO UPPER */  
   if ok = 'SAI' then                                                  
    do                                                                
      exit 0                                                          
    end                                                                
 end                                                                  
if sigla = "" then                                                    
   do                                                                  
      say "----------------------------------------------------"      
      say "Erro: Informe a sigla do sistema com duas posicoes"        
      say "----------------------------------------------------"      
      say ""                                                          
      say 'Digite a sigla:'                                            
      pull sigla                                                      
   end                                                                
if pacote = "" then                                                    
   do                                                                  
      say "--------------------------------"                          
      say "Erro: Não foi informado o pacote"                          
      say "--------------------------------"                          
      say ""                                                          
      say "Procuraremos em DESICBIB.CHGMAN.STG.NG0I.#pacote.SRC"      
      say ""                                                          
      say 'Digite o numero do pacote com 6 numeros :'                  
      pull pacote                                                      
   end                                                                
if texto = "" then                                                    
   do                                                                  
      say "-----------------------------------------------------------"
      say "Erro: Não foi informada a string a ser pesquisada no pacote"
      say "-----------------------------------------------------------"
      say ""                                                          
      say 'Digite a string:'                                          
      pull texto                                                      
   end                                                                
return                                                                
                                                                       
                                                                       
/*------------------------------------- */                            
verifica_se_pacote_existe:                                            
/*------------------------------------- */                            
                                                                       
/*         DESICBIB.CHGMAN.STG.NG0I.#000651.SRC */                    
pdsname = 'DESICBIB.CHGMAN.STG.'sigla'0I.#'pacote'.SRC'                
    say '---------------------------------------------------------------'
    say 'Procurando' texto ' em 'pdsname''                                
    say '---------------------------------------------------------------'
    x = SYSDSN("'"pdsname"'")      /* só pros feras!!! ODEIO ISSO */      
    say x ', vamos em frente que o pacote ta lá!'                        
    say '---------------------------------------------------------------'
    if x <> "OK" then                                                    
       do                                                                
          say "Erro: Não conseguimos localizar o pacote #" pacote        
          say "Erro: Não conseguimos localizar o pacote:" pdsname        
          say "Error: " pdsname " > " sysdsn(pdsname)                    
          say "Press Enter to continue"                                  
          pull uresp                                                      
          exit 8                                                          
       end                                                                
    return                                            

Como funciona

  • Valida os parâmetros de entrada (sigla, pacote, texto).
  • Verifica se o pacote existe no Changeman.
  • Lista todos os membros do pacote e busca a string informada em cada um.
  • Gera um relatório de saída com os membros e linhas onde a string foi encontrada.

Observações

  • O script pode ser adaptado para outros padrões de pacotes ou ambientes.
  • Certifique-se de ter as permissões necessárias para executar comandos de alocação e leitura de membros no ambiente mainframe.

quinta-feira, 24 de janeiro de 2019

REXX para bom dia! - Gera arquivos de configuração do Debug Tool - Submete Hrecall para todos os membros

Scripts REXX e JCL para Automação no z/OS

Scripts REXX e JCL para Automação no z/OS

Script REXX para Automação no z/OS

BOM#DIA.REXX

/* REXX */                                                    
trace off;                                                    
CLEAR                                                          
SAY 'Ola Buga!'                                                
SAY ' '                                                        
SAY 'Seja vem vindo...'                                        
SAY ' '                                                        
SAY ' '                                                        
parse PULL rola                                                
/******************************/                              
call verifica_primeira_vez_do_dia                              
say flag                                                      
if flag = 'S' then                                            
 do                                                            
    call grava_ja_rodamos;                                    
    call aloca_debug_tool_files;                              
    call hrecall_de_tudo;                                      
 end;                                                          
ISPF                                                          
exit 0                                                        
/******************************/                              
grava_ja_rodamos:                                              
/******************************/                              
dsname = 'walbuga.apagador'                                    
"ALLOC FI(Pdsout) DA('"dsname"') new                          
    tracks space(10 10) dir(01)                                
    Recfm(F B) LRECL(80)"                                      
"FREE  FI(Pdsout)"                                            
"allocate dataset('walbuga.apagador(#15)') fi(#15) shr reuse"  
"execio 0 diskw #15 (stem o. open)"                            
o.1 = 'CEBOLA '                                                
"execio * diskw #15 (stem o. finis)"                          
"free fi(#15)"                                                
return                                                        
/******************************/                              
/******************************/                              
dsname = 'walbuga.apagador'                                    
"ALLOC FI(Pdsout) DA('"dsname"') new                          
    tracks space(10 10) dir(01)                                
    Recfm(F B) LRECL(80)"                                      
"FREE  FI(Pdsout)"                                            
"allocate dataset('walbuga.apagador(#15)') fi(#15) shr reuse"  
"execio 0 diskw #15 (stem o. open)"                            
o.1 = 'CEBOLA '                                                
"execio * diskw #15 (stem o. finis)"                          
"free fi(#15)"                                                
return                                                        
/******************************/                              
verifica_primeira_vez_do_dia:                                  
/******************************/                              
"allocate dataset('walbuga.apagador(#15)') fi(#15) shr reuse"  
"execio * diskr #15 (stem oia. finis)"                        
   if pos('CEBOLA',oia.1) > '0' then                          
      do                                                      
         say 'TSO te derrubou, neh amigao ?'                  
         flag = 'N'                                            
      end                                                      
   else                                                        
      do                                                      
         say 'Divirta-se Buga'                                
         flag = 'S'                                            
      end                                                      
return                                                        
/******************************/                              
aloca_debug_tool_files:                                        
/******************************/                              
debug_tool = "'WALBUGA.G#NG.SEMANA09(DEBUG#01)'"              
SUBMIT debug_tool                                              
return                                                        
/******************************/                              
hrecall_de_tudo:                                              
recall = "'WALBUGA.G#R0.DATA(JCL#0004)'"                      
SUBMIT recall                                                  
return                                

JCL para Alocação de Arquivos de Debug (DEBUG#01)

WALBUGA.G#NG.SEMANA09(DEBUG#01)

DEBUG#01.JCL

//WALBUGA2 JOB NG,BUGA,CLASS=K      RESTART=STEP#002                  
/*NOTIFY WALBUGA                                                      
//*--------------------------------------------------------------------
//* Aloca arquivos utilizados pelo debug tool no z/OS                  
//*--------------------------------------------------------------------
//STEP#001  EXEC PGM=IEFBR14                                          
//SAVINGS      DD DSN=WALBUGA.DBGTOOL.SAVESETS,                        
//             DISP=(NEW,CATLG,DELETE),                                
//             UNIT=SYSDA,SPACE=(CYL,(20,10)),                        
//             DCB=(LRECL=3204,BLKSIZE=0,DSORG=PS,RECFM=VB)            
//SETTINGS      DD DSN=WALBUGA.DBGTOOL.SAVEBPS,                        
//             DISP=(NEW,CATLG,DELETE),                                
//             UNIT=SYSDA,SPACE=(CYL,(20,10)),                        
//             DCB=(LRECL=3204,BLKSIZE=0,DSORG=PO,RECFM=VB),          
//             DSNTYPE=LIBRARY                                        
//*--------------------------------------------------------------------
//* Carrega configuracoes que o Buga gosta!                            
//*--------------------------------------------------------------------
//STEP#002  EXEC PGM=IEBGENER                                          
//SYSIN    DD DUMMY                                                    
//SYSPRINT DD SYSOUT=X                                                
//SYSUT1   DD *                                                        
      COMMENT YES
      SET ASSEMBLER OFF;                                              
      SET ASSEMBLER STEPOVER EXTONLY;                                  
      SET AUTOMONITOR ON NOLOG CURRENT;                                
      SET CHANGE STATEMENT;                                            
      SET COLOR TURQUOISE NONE      HIGH TITLE HEADERS;                
      SET COLOR GREEN     NONE      LOW  TITLE FIELDS;                
      SET COLOR TURQUOISE REVERSE   LOW  MONITOR AREA;                
      SET COLOR TURQUOISE REVERSE   LOW  MONITOR LINES;                
      SET COLOR WHITE     REVERSE   LOW  SOURCE AREA;                  
      SET COLOR TURQUOISE REVERSE   LOW  SOURCE PREFIX;                
      SET COLOR YELLOW    REVERSE   LOW  SOURCE SUFFIX;                
      SET COLOR RED       REVERSE   HIGH SOURCE CURRENT;              
      SET COLOR GREEN     NONE      LOW  SOURCE BREAKPOINTS;          
      SET COLOR TURQUOISE NONE      HIGH PROGRAM OUTPUT;              
      SET COLOR YELLOW    NONE      LOW  TEST INPUT;                  
      SET COLOR GREEN     NONE      HIGH TEST OUTPUT;                  
      SET COLOR BLUE      REVERSE   HIGH LOG LINES;                    
      SET COLOR WHITE     NONE      HIGH COMMAND LINE;                
      SET COLOR GREEN     REVERSE   HIGH WINDOW HEADERS;              
      SET COLOR BLUE      REVERSE   HIGH TOFEOF MARKER;                
      SET COLOR RED       NONE      HIGH TARGET FIELD;                
      SET DEFAULT LISTINGS;                                            
      SET DEFAULT DBG;                                                
      SET DEFAULT MDBG;                                                
      SET DEFAULT SCROLL PAGE;                                        
      SET DEFAULT VIEW STANDARD;                                      
      SET DEFAULT WINDOW SOURCE;                                      
      SET DISASSEMBLY OFF;                                            
      SET DYNDEBUG ON;                                                
      SET ECHO ON;                                                    
      SET EXECUTE ON;                                                  
      SET EXPLICITDEBUG OFF;                                          
      SET FIND BOUNDS 1 *;                                            
      SET HISTORY ON 100;                                              
      SET IGNORELINK OFF;                                              
      SET LDD SINGLE;                                                  
      SET LIST TABULAR OFF;                                            
      SET LIST BY SUBSCRIPT OFF;                                      
      SET LOG OFF;                                                    
      SET LOG KEEP 1000;                                              
      SET LOG NUMBERS ON;                                              
      SET LONGCUNAME ON;                                              
      SET MONITOR DATATYPE OFF;                                        
      SET MONITOR LIMIT 1000;                                          
      SET MONITOR NUMBERS ON;                                          
      SET MONITOR WRAP ON;                                            
      SET MSGID OFF;                                                  
      SET PACE 2;                                                      
      SET PF1     "?" =    ?;                                          
      SET PF2     "STEP" = STEP;                                      
      SET PF3     "QUIT" = QUIT;                              
      SET PF4     "LIST" = LIST;                              
      SET PF5     "FIND" = IMMEDIATE FIND;                    
      SET PF6     "AT/CLEAR" =AT TOGGLE;                      
      SET PF7     "UP" =   IMMEDIATE UP;                      
      SET PF8     "DOWN" = IMMEDIATE DOWN;                    
      SET PF9     "GO" =   GO;                                
      SET PF10    "ZOOM" = IMMEDIATE ZOOM;                    
      SET PF11    "ZOOM LOG" =IMMEDIATE ZOOM LOG;              
      SET PF12    "RETRIEVE" =IMMEDIATE RETRIEVE;              
      SET PF13    "?" =    ?;                                  
      SET PF14    "STEP" = STEP;                              
      SET PF15    "QUIT" = QUIT;                              
      SET PF16    "LIST" = LIST;                              
      SET PF17    "FIND" = IMMEDIATE FIND;                    
      SET PF18    "AT/CLEAR" =AT TOGGLE;                      
      SET PF19    "UP" =   IMMEDIATE UP;                      
      SET PF20    "DOWN" = IMMEDIATE DOWN;                    
      SET PF21    "GO" =   GO;                                
      SET PF22    "ZOOM" = IMMEDIATE ZOOM;                    
      SET PF23    "ZOOM LOG" =IMMEDIATE ZOOM LOG;              
      SET PF24    "RETRIEVE" =IMMEDIATE RETRIEVE;              
      SET POPUP 15;                                            
      SET PROMPT LONG;                                        
      SET REFRESH OFF;                                        
      SET RESTORE SETTINGS AUTO;                              
      SET RESTORE BPS AUTO;                                    
      SET RESTORE MONITORS AUTO;                              
      SET REWRITE 50;                                          
      SET SAVE SETTINGS AUTO;                                  
      SET SAVE BPS AUTO FILE WALBUGA.DBGTOOL.SAVEBPS;          
      SET SAVE MONITORS AUTO;                                  
      SET SCROLL DISPLAY ON;                                  
      SET SUFFIX ON;                                          
      SET WARNING ON;                                          
      WINDOW SIZE 3 LOG;                                  
      WINDOW SIZE 28 SOURCE;                              
      WINDOW SIZE 8 MONITOR;                              
      SET SCREEN ON;                                                  
      SET SCREEN 1 MONITOR SOURCE LOG;                                
      SET KEYS ON 12;                                      
      SET MONITOR COLUMN ON;                                          
//SYSUT2   DD DSN=WALBUGA.DBGTOOL.SAVESETS,                            
//             DISP=(OLD,CATLG,DELETE),                                
//             UNIT=SYSDA,SPACE=(CYL,(20,10)),                        
//             DCB=(LRECL=3204,BLKSIZE=0,DSORG=PS,RECFM=VB)            
//                                                                    
//*                                                                    
                                                                       
SET SAVE SETTINGS AUTO ;                                              
SET SAVE BPS AUTO ;                                                    
SET SAVE MONITORS AUTO ;                                              
                                                                       
SET RESTORE SETTINGS AUTO ;                                            
SET RESTORE BPS AUTO ;                                                
SET RESTORE MONITORS AUTO ;                                            
                                                                       
SET AUTO ON;                                                          
WINDOW SIZE 30 SOURCE; window size 3 log;

JCL para Recall de Datasets do Usuário

'WALBUGA.G#R0.DATA(JCL#0004)'      

//WALBUGA1 JOB R8,'BUGA',MSGLEVEL=(1,1),CLASS=K,MSGCLASS=1,RD=NC        
//*---------------------------------------------------------------------
//*                                                                    
//*   PROCEDIMENTO PARA RECALL DE TODOS OS DATASETS DE UM USUARIO      
//*                                                                    
//*---------------------------------------------------------------------
/*NOTIFY WALBUGA         ** ME NOTIFIQUE                                
/*XEQ ECA                ** RODAR EM SECA                              
//*---------------------------------------------------------------------
//    EXPORT  SYMLIST=(USUARIO,ESTRELA)                                
//    SET     USUARIO=&SYSUID                                          
//    SET     ESTRELA='*'                                              
//*---------------------------------------------------------------------
//*          SCRATCH TODOS OS ARQUIVOS DE SAIDA                        
//*---------------------------------------------------------------------
//STEP#001 EXEC PGM=IDCAMS                                              
//SYSPRINT DD SYSOUT=*                                                  
//SYSIN    DD *,DLM=FIM,SYMBOLS=JCLONLY                                
  DELETE &USUARIO..LISTCAT.OUTPUT                                      
FIM                                                                    
//*---------------------------------------------------------------------
//*       SOLICITA RECALL DOS ARQUIVOS --- OPS NAO PODE                
//*---------------------------------------------------------------------
//STEP#002 EXEC PGM=IKJEFT01                                            
//SYSTSPRT DD SYSOUT=*                                                  
//SYSTSIN  DD *,SYMBOLS=JCLONLY                                        
 HRECALL &USUARIO..&ESTRELA NOWAIT                                      
//*---------------------------------------------------------------------
//* Entra em ação o plano 'B'                                          
//*       LISTA TODOS OS DATASETS DO USUARIO                            
//*---------------------------------------------------------------------
//STEP#003 EXEC PGM=IDCAMS                                              
//SYSPRINT DD   SYSOUT=*                                                
//SYSIN    DD  *,SYMBOLS=JCLONLY                                        
 LISTCAT LEVEL(&USUARIO) -                                              
   OUTFILE(OUTDD)                                                      
//OUTDD    DD DSN=&USUARIO..LISTCAT.OUTPUT,                            
//         DCB=(RECFM=VBA,LRECL=125,BLKSIZE=629),UNIT=DASD,            
//         SPACE=(CYL,(1,1)),                                          
//         DISP=(NEW,CATLG)                                            
//*---------------------------------------------------------------------
//*    COPIA PARA ARQUIVO TEMPORARIO                                    
//*---------------------------------------------------------------------
//STEP#004 EXEC PGM=IEBGENER                                            
//SYSPRINT DD   SYSOUT=*                                                
//SYSOUT   DD SYSOUT=*                                                  
//SYSIN    DD DUMMY                                                    
//SYSUT1   DD DSN=&USUARIO..LISTCAT.OUTPUT,DISP=SHR                    
//SYSUT2   DD DSN=&&TMP1,                                              
//         DCB=(RECFM=VBA,LRECL=125,BLKSIZE=629),UNIT=DASD,            
//         SPACE=(CYL,(1,1)),                                          
//         DISP=(MOD,PASS)                                              
//*---------------------------------------------------------------------
//*    EXTRAI DO RELATORIO DO IDCAMS QUE LISTOU OS ARQUIVOS O NOME DOS  
//* DATASETS QUE SERÃO RECUPERADOSLOGO NA SEQUENCIA                    
//*---------------------------------------------------------------------
//STEP#005 EXEC  PGM=SORT    ,COND=(0,NE)                              
//SORTIN   DD DSN=&&TMP1,DISP=(OLD,DELETE)                              
//SORTOUT  DD DSN=&&TMP2,                                              
//         RECFM=FB,LRECL=00060,                                        
//         SPACE=(CYL,(10,10),RLSE),                                    
//         DISP=(MOD,PASS)                                              
//SORTIN   DD SYSOUT=*                                                  
//SYSIN    DD *,SYMBOLS=JCLONLY                                        
 SORT FIELDS=COPY                                                      
 INCLUDE COND=(22,7,EQ,C'&USUARIO'),FORMAT=CH     *** 4 BYTES DO RDW    
 OUTFIL FNAMES=SORTOUT,VTOF,                                            
 OUTREC=(C' HRECALL ',22,44,C' NOWAIT')                                
//SYSOUT   DD  SYSOUT=*                                                
//SORTMSG  DD  SYSOUT=*                                                
//*---------------------------------------------------------------------
//*    REALIZA O HRECALL DOS MEMBROS DO USUARIO                        
//*---------------------------------------------------------------------
//STEP#006 EXEC PGM=IKJEFT01                                            
//SYSTSPRT DD SYSOUT=*                                                  
//SYSTSIN  DD *                                                        
 /* Vai que alguem resolveu customizar */                              
 PROFILE NOPREFIX                                                      
//         DD DSN=&&TMP2,DISP=(OLD,DELETE)                              
//*                                                                    
//*---------------------------------------------------------------------
//*    ENVIA MENSAGEM INFORMANDO O FINAL DO PROCESSAMENTO              
//*---------------------------------------------------------------------
//STEP#007 EXEC PGM=IKJEFT01                                            
//SYSPRINT DD SYSOUT=*                                                  
//SYSTSPRT DD SYSOUT=*                                                  
//SYSTSIN  DD *,SYMBOLS=JCLONLY                                        
 SEND 'Processo de Recall de arquivos finalizado!     ' USER(&USUARIO)  
/*