AWS O Mainframe Modernization Service (experiência em Managed Runtime Environment) não está mais aberto a novos clientes. Para recursos semelhantes ao AWS Mainframe Modernization Service (experiência em Managed Runtime Environment), explore o AWS Mainframe Modernization Service (experiência autogerenciada). Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte Alteração na disponibilidade AWS da modernização do mainframe.
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
Utilitários de conjuntos de dados
BLUESAMCOPY/BLUESAMCREATE/BLUESAMDELETE/BLUESAMCLEAR
Esses programas utilitários fornecem funções essenciais de manipulação de conjuntos de dados em conjuntos de dados Blusam.
O bypassBluesamStatus sinalizador (armazenado em JobContext) determina se a validação normal do status do conjunto de dados deve ser ignorada, o que evita conflitos de acesso simultâneo entre processos on-line e em lote.
Quando bypassBluesamStatus for verdadeiro:
Ignora as verificações normais do status do conjunto de dados durante as operações
Permite acesso a conjuntos de dados que normalmente podem ser bloqueados
SAMCOPIA AZUL
O programa BLUESAMCOPY copia dados e estrutura de metadados de um conjunto de dados Bluesam para outro.
Parâmetros
O programa BLUESAMCOPY usa dois parâmetros:
FROM=<source dataset name>- Conjunto de dados de origem do qual copiarTO=<target dataset name>- Conjunto de dados de destino para o qual copiar
Comportamento
Se o conjunto de dados de destino não existir, crie-o com a estrutura de metadados da fonte
Se o destino existir, limpe-o antes de copiar (sobrescreve os dados existentes)
A operação prossegue quando os conjuntos de dados não estão em uso por processos on-line ou quando
bypassBluesamStatussão definidos como verdadeirosPreserva chaves, compactação, tamanho do registro e outras propriedades de metadados
Tratamento de erros
Retorna o código 1 se o conjunto de dados de origem não existir ou se um dos conjuntos de dados estiver sendo usado por processos on-line.
Uso da amostra
import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // copy bluesam dataset res = mpr.withArguments("FROM=MYBLUESAMTABLE","TO=MYBLUESAMTABLE2").runProgram("BLUESAMCOPY")
BLUESAM CREATE
O programa BLUESAMCREATE cria um conjunto de dados Bluesam com os parâmetros especificados.
Parâmetros
O programa BLUESAMCREATE usa sete parâmetros:
name=<dataset name>- Conjunto de dados a ser criado (obrigatório)compress=<true/false>- Ativar compressão (opcional, padrão: false)fixedLength=<true/false>- Status de registros de tamanho fixo (opcional, padrão: falso)recordLength=<integer>- Tamanho do registro em bytes (opcional, padrão: -1)primaryKey=<key id>,duplicates=<true/false>,fields=<offset,length,...>- Especificação da chave primária (opcional)key=<altkey id>,duplicates=<true/false>,fields=<offset,length,...>- Chave alternativa (pode ter várias ou 0)clearExisting=true/false- Limpar o conjunto de dados existente (padrão opcional: verdadeiro)
Explicações específicas dos parâmetros-chave:
duplicates: se valores duplicados são permitidos ou não para a chave fornecida;fields: Posições de campo (baseadas em 1) e comprimentos que definem a chave;
Comportamento
Se o conjunto de dados não existir, crie-o com parâmetros especificados
Se o conjunto de dados existir, limpa-o se
clearExisting=trueA operação prossegue quando os conjuntos de dados não estão em uso por processos on-line ou quando
bypassBluesamStatusestão definidos comotrue
Condições de erro
Retorna o código 0 em todos os casos.
Uso da amostra
import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // create bluesam dataset mpr.withArguments( "name=MYBLUESAMTABLE", "compress=FALSE", "fixedLength=true", "recordLength=54", "primaryKey=MYKEY_PK,duplicates=FALSE,fields=0,6") .runProgram("BLUESAMCREATE")
BLUESAMDELETE
O programa BLUESAMDELETE exclui os conjuntos de dados do Bluesam.
Parâmetros
O programa BLUESAMDELETE usa 1 ou mais parâmetros:
<dataset name>- conjunto de dados a ser excluído (pode ter vários)
Comportamento
A operação prossegue quando os conjuntos de dados não estão em uso por processos on-line ou quando
bypassBluesamStatusestão definidos comotrueSe o conjunto de dados existir, exclua-o
Condições de erro
Retorna o código 0 em todos os casos.
Uso da amostra
import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // delete bluesam datasets res = mpr.withArguments("MYBLUESAMTABLE","MYBLUESAMTABLE2","MYBLUESAMTABLE3").runProgram("BLUESAMDELETE")
AZUL SAM TRANSPARENTE
O programa BLUESAMCLEAR remove todos os dados dos conjuntos de dados existentes, preservando sua estrutura e metadados.
Parâmetros
O programa BLUESAMCLEAR usa 1 ou mais parâmetros:
<dataset name>- conjunto de dados para limpar (pode ter vários)
Comportamento
A operação prossegue quando os conjuntos de dados não estão em uso por processos on-line ou quando
bypassBluesamStatusestão definidos comotrueSe o conjunto de dados existir, limpe-o
Condições de erro
Retorna o código 0 em todos os casos.
Uso da amostra
import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // clear bluesam datasets res = mpr.withArguments("MYBLUESAMTABLE","MYBLUESAMTABLE2").runProgram("BLUESAMCLEAR")
BPXWDYN
Esse programa utilitário simula o serviço z/OS BPXWDYN para alocação e desalocação dinâmica de conjuntos de dados. Em aplicativos modernos, as alocações de arquivos são feitas em scripts Groovy por meio FileConfigurationUtils da API do construtor. Esse programa permite o gerenciamento dinâmico dessas alocações sem o Groovy, o que é essencial para o processamento interativo ou condicional de arquivos em aplicativos modernizados.
Parâmetros
O formato do argumento legado é preservado. Espera um único argumento contendo um cabeçalho de 2 bytes seguido pela string de comando.
formato de cadeia de comando para alocação: ALLOC DD(<name>) DSN('<dsn>') SHR?
formato de cadeia de comando para desalocação: FREE DD(<name>)
Tratamento de erros
Defina o código de erro 0 para sucesso, 1 para falha
Lança RuntimeException comandos ou parâmetros inválidos
Uso da amostra
Aqui está um exemplo de uso do programa BPXWDYN em Java, resultante de uma modernização do COBOL por meio da transformação da AWS:
O código COBOL:
01 WK-AREA. 03 DS-ALLOC-STRING. 05 DS-LENGTH PIC S9(004) COMP VALUE 100. 05 DS-TEXT PIC X(100) VALUE "ALLOC DD(INFILE) DSN('A.B.JCLLIB(XYZ470)') SHR". ... 01 RC-RETURN-CODE-AREA. 03 RC-RETURN-CODE PIC S9(008) COMP. ... CALL 'BPXWDYN' USING DS-ALLOC-STRING RETURNING RC-RETURN-CODE.
e a modernização correspondente do Java:
private final Group dsAllocString = new Group(root).named("DS-ALLOC-STRING"); private final Elementary dsLength = new Elementary(dsAllocString,new BinaryType(4, 0, "STD", false, false, true),Short.valueOf("100")).named("DS-LENGTH"); private final Elementary dsText = new Elementary(dsAllocString,new AlphanumericType(100),"ALLOC DD(INFILE) DSN('A.B.JCLLIB(XYZ470)') SHR").named("DS-TEXT"); ... private final Group root = new Group(getData()).named("RC-RETURN-CODE-AREA"); private final Elementary rcReturnCode = new Elementary(root,new BinaryType(8, 0, "STD", false, false, true)).named("RC-RETURN-CODE"); ... // Call to utility program BPXWDYN ctrl.callSubProgram( "BPXWDYN", CallBuilder.newInstance().byReference(ctx.getWkArea().getDsAllocStringReference()).getArguments(), ctx); ctx.getRcReturnCodeArea().setRcReturnCode(NumberUtils.convert(ctx.getProgramReturned()).intValue());
GDGU TILS
GDGs (Generation Data Group) permite que os aplicativos trabalhem com conjuntos de dados versionados em que cada execução cria uma nova geração enquanto mantém o acesso às gerações anteriores. Esse utilitário cria e gerencia essas gerações de conjuntos de dados. Esse utilitário deve ser chamado em scripts groovy.
Parâmetros
a ordem dos parâmetros não importa
action=<create|refreshevents>- Operação a ser executada (obrigatória)gdgname=<name>- Nome da base do GDG (obrigatório)storageProvider=<filesystem|bluesam>- Backend de armazenamentorelativeGeneration=<+integer>- Número relativo da geração (por exemplo, +1 para a próxima)absoluteGeneration=integer- Número absoluto de geraçãorecordLength=<integer>- Tamanho do registro no conjunto de dadosfixedLength=<true/false>- Especifica que os registros têm um tamanho fixo no conjunto de dadosownerPath=<File system path>- O caminho para armazenar o conjunto de dados (específico do sistema de arquivos, obrigatório para esse caso)compress=<true/false>- Indica que os dados devem permanecer compactados na memória se forem compactados no armazenamento de dados (específico do bluesam) (opcional, false é o valor padrão)catalog- Especifica que o conjunto de dados deve ser catalogado (opcional)warmUp- Indica que o conjunto de dados deve ser carregado na memória quando aberto (específico para bluesam) (opcional)
RelativeGeneration ou AbsoluteGeneration: uma dessas propriedades precisa ser definida.
Operações
criar: cria uma nova geração de conjunto de dados GDG de acordo com os metadados do GDG (lida com o sistema de arquivos e o armazenamento Bluesam)
refreshevents: ajusta o número de geração (metadados Gdg) sem criar novos conjuntos de dados (usado ao reiniciar trabalhos com falha que já criaram conjuntos de dados)
Tratamento de erros
Defina o código de erro 0 para sucesso, 1 para falha
Lança RuntimeException comandos ou parâmetros inválidos
Uso da amostra
Operação de criação de Gdg: o código a seguir cria uma geração bluesam (43) para o conjunto de dados IC.PLI.GDGTEST
import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) Map params = new Hashtable() params.put("jobContext", jobContext) Object[] args =["action=create","gdgname=IC.PLI.GDGTEST","absoluteGeneration=43","storageProvider=bluesam","recordLength=80"] mpr.withParameters(params).withArguments(args).runProgram("GDGUTILS")
Operação Gdg refreshevents: somente RelativeGeneration é relevante para esta operação. O código a seguir atualiza o número da geração (+1 em comparação com a geração atual) do IC.PLI.GDGTEST conjunto de dados
import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) Map params = new Hashtable() params.put("jobContext", jobContext) Object[] args =["action=refreshevents","gdgname=IC.PLI.GDGTEST","relativeGeneration=1","storageProvider=bluesam"] mpr.withParameters(params).withArguments(args).runProgram("GDGUTILS")
ICEGENER/SYNCGEN
Este programa utilitário imita o comportamento do utilitário de z/OS sistema ICEGENER, ele copia conjuntos de dados da entrada (conjunto de dados) para a saída (SYSUT1 conjunto de dados). SYSUT2 Essa implementação Java fornece funcionalidade equivalente, suportando tanto o sistema de arquivos quanto o armazenamento Bluesam.
Parâmetros
Sem discussão
Conjuntos de dados necessários
SYSUT1: conjunto de dados/arquivo de entrada
SYSUT2: conjunto de dados/arquivo de saída
Tratamento de disposição para conjunto de dados SYSUT2
NOVO: Crie um novo conjunto de dados/arquivo
OLD/SHR: Use existing dataset/file(deve existir)
MOD: Modifique, crie se estiver faltando, anexe se existir
Tratamento de erros
Defina o código de erro 0 se a cópia for bem-sucedida, 1 se falhar
Lança
IllegalStateExceptionpor uso inválido do conjunto de dados Bluseam
Uso da amostra
Aqui está um exemplo do uso do programa ICEGENER pelo Groovy, resultante de uma modernização da JCL por meio da transformação da AWS:
O código JCL:
//STEP01 EXEC PGM=ICEGENER //SYSUT1 DD DSN=POI.INPUT,DISP=SHR //SYSUT2 DD DSN=POI.OUTPU, // DISP=(,CATLG,DELETE), // UNIT=3490, // DCB=(RECFM=FB,LRECL=100) /*
e a modernização correspondente do Groovy:
mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("SYSUT1") .dataset("POI.INPUT") .disposition("SHR") .build() .bluesam("SYSUT2") .dataset("POI.OUTPU") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("ICEGENER")
IDCAMS/KQCAMS
Esse programa utilitário imita o comportamento dos programas legados IDCAMS, que é uma ferramenta de gerenciamento de dados de mainframe usada para operações de arquivos VSAM (Virtual Storage Access Method). Ele processa os comandos IDCAMS antigos, mantendo a mesma sintaxe das entradas SYSIN originais.
Contexto
O comportamento do programa pode ser configurado por dois parâmetros definidos emapplication-utility-pgm.yml:
JCLType: identificador do tipo JCL (vse ou mvs). Os PRINT/REPRO comandos do utilitário IDCAMS retornam 4 se o arquivo estiver vazio para não-vse jcl
forcedCharsetIdcams: Substituição opcional do conjunto de caracteres para processamento de IDCAMS
Parâmetros
Sem discussão. As operações são passadas pelo conjunto de dados SYSIN.
Conjuntos de dados necessários
SYSIN - Contém instruções de comando IDCAMS
Conjuntos de dados de entrada/saída - conforme referenciado nos comandos IDCAMS (dependendo da declaração IDCAMS)
Principais características/Comandos suportados
Os detalhes sobre os comandos IDCAMS encontrados na placa de controle SYSIN não são fornecidos aqui, mas devem ser obtidos nas documentações de plataformas legadas relevantes existentes.
DEFINE - Cria clusters e conjuntos de dados VSAM
EXCLUIR - Remove conjuntos de dados (suporta curingas)
REPRO - Copia dados entre conjuntos de dados
IMPRIMIR - Exibe o conteúdo do conjunto de dados
VERIFY - Valida a existência e a integridade do conjunto de dados
ALTER - Modifica os atributos do conjunto de dados (renomeação)
ALLOC - Aloca conjuntos de dados dinamicamente
SET - Gerencia códigos de condição (LASTCC/MAXCC)
IF-THEN-ELSE - Execução condicional de comandos
CANCELAR - Encerra a execução do trabalho
Tratamento de erros
Defina o código de erro 0 se o último comando for bem-sucedido, -1 se falhar
Os comandos SET (LASTCC) podem ser usados para substituir o código de erro, por exemplo
SET LASTCC = 0
Uso da amostra
Aqui está um exemplo do uso do programa IDCAMS pelo Groovy, resultante de uma modernização da JCL por meio da transformação da AWS:
O código JCL:
//STEP15 EXEC PGM=IDCAMS //SYSPRINT DD SYSOUT=* //ACCTDATA DD DISP=SHR, // DSN=AWS.M2.CARDDEMO.ACCTDATA.PS //ACCTVSAM DD DISP=SHR, // DSN=AWS.M2.CARDDEMO.ACCTDATA.VSAM.KSDS //SYSIN DD * REPRO INFILE(ACCTDATA) OUTFILE(ACCTVSAM) /*
e a modernização correspondente do Groovy:
mpr.withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .systemOut("SYSPRINT") .output("*") .build() .bluesam("ACCTDATA") .dataset("AWS.M2.CARDDEMO.ACCTDATA.PS") .disposition("SHR") .build() .bluesam("ACCTVSAM") .dataset("AWS.M2.CARDDEMO.ACCTDATA.VSAM.KSDS") .disposition("SHR") .build() .fileSystem("SYSIN") .stream("REPRO INFILE(ACCTDATA) OUTFILE(ACCTVSAM)", getEncoding()) .build() .getFileConfigurations()) .withParameters(params) .runProgram("IDCAMS")
IEBGENER/JSDGENER
Este programa replica o utilitário IEBGENER. É usado para copiar e manipular conjuntos de dados sequenciais. Essa implementação amplia a funcionalidade básica de cópia ao oferecer suporte às instruções de controle do IEBGENER para operações avançadas de processamento de dados.
Parâmetros
Sem discussão. As operações são passadas pelo conjunto de dados SYSIN.
Conjuntos de dados necessários
SYSIN: contém instruções de controle (opcional, se não definido, o programa IEBGENER é idêntico ao ICEGENER)
SYSUT1: conjunto de dados/arquivo de entrada
SYSUT2: conjunto de dados/arquivo de saída
Principais características/Declarações de controle IEBGENER suportadas
Os detalhes sobre a declaração de controle do IEBGENER encontrados nos cartões de controle SYSIN não são fornecidos aqui, mas devem ser obtidos nas documentações de plataformas legadas relevantes existentes.
GENERATE - define a estrutura geral do processo de manipulação de dados especificando o número máximo de tipos de registro (MAXNAME) e campos (MAXFLDS) a serem processados
REGISTRO - define o layout e o conteúdo reais de cada tipo de registro especificando a posição, o comprimento e o formato dos campos individuais que serão copiados do conjunto de dados de entrada ou gerados com valores específicos
LABEL/MEMBER/EXITnão são suportados
exemplo:
GENERATE MAXNAME=3,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name */ FIELD=(12,8,CH), /* Birth date */ FIELD=(20,8,CH,VALUE='ACTIVE') RECORD TYPE=3, FIELD=(1,1,CH,VALUE='F'), FIELD=(2,30,CH,VALUE='END OF REPORT ')
Tratamento de erros
Defina o código de erro 0 se a cópia for bem-sucedida, 1 se falhar.
Uso da amostra
Aqui está um exemplo do uso do programa IEBGENER pelo Groovy, resultante de uma modernização da JCL por meio da transformação da AWS:
O código JCL:
//GENDATA EXEC PGM=IEBGENER //SYSUT1 DD DSN=INPUT.EMPLOYEE.DATA, // DISP=SHR //SYSUT2 DD DSN=OUTPUT.EMPLOYEE.FILE, // DISP=(NEW,CATLG,DELETE), // SPACE=(TRK,(1,1)), // DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920) //SYSIN DD * GENERATE MAXNAME=2,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE SALARY REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name from input */ FIELD=(12,8,CH), /* Birth date from input */ FIELD=(20,8,CH), /* Dept from input */ FIELD=(28,8,CH) /* Salary from input */ /*
e a modernização correspondente do Groovy:
mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .systemOut("SYSPRINT") .output("*") .build() .bluesam("SYSUT1") .dataset("INPUT.EMPLOYEE.DATA") .disposition("SHR") .build() .bluesam("SYSUT2") .dataset("OUTPUT.EMPLOYEE.FILE") .disposition("NEW") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .fileSystem("SYSIN") .stream( """GENERATE MAXNAME=2,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE SALARY REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name from input */ FIELD=(12,8,CH), /* Birth date from input */ FIELD=(20,8,CH), /* Dept from input */ FIELD=(28,8,CH) /* Salary from input */""", getEncoding()) .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEBGENER")
IEFBR14
IEFBR14 é um programa de “não fazer nada” que simplesmente retorna com um código de retorno de 0 (zero). Seu uso principal é para alocação, exclusão ou manutenção de catálogos de conjuntos de dados por meio de instruções DD, sem realizar nenhum processamento real de dados.
Parâmetros
Sem discussão
Tratamento de erros
Defina sempre o código de erro 0.
Uso da amostra
Aqui está um exemplo do uso do IEFBR14 programa pelo Groovy, resultante de uma modernização da JCL por meio da transformação da AWS:
O código JCL para criar um novo conjunto de dados sequencial:
//STEP1 EXEC PGM=IEFBR14 //NEWSEQ DD DSN=USER.NEW.SEQ.DATA, // DISP=(NEW,CATLG,DELETE), // SPACE=(TRK,(10,5)), // DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920)
e a modernização correspondente do Groovy:
mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("NEWSEQ") .dataset("USER.NEW.SEQ.DATA") .disposition("NEW") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEFBR14")
O código JCL para excluir um conjunto de dados existente:
//STEP3 EXEC PGM=IEFBR14 //DELDD DD DSN=USER.OLD.DATASET, // DISP=(OLD,DELETE,DELETE)
e a modernização correspondente do Groovy:
mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("DELDD") .dataset("USER.OLD.DATASET") .disposition("OLD") .normalTermination("DELETE") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEFBR14")
JCLBCICS
Este programa gerencia o status dos conjuntos de dados, define enables/disables conjuntos de dados com base na configuração, suportando arquivos individuais e padrões curinga: ele altera o campo STATUS na tabela JICS file_table.
Parâmetros
Sem discussão. As operações são passadas por um DatasetsConfiguration objeto, por exemplo
mpr.withDatasetsConfiguration(new DatasetsConfiguration().close(<Dataset Name>)
Contexto
O comportamento do programa pode ser configurado por dois parâmetros:
Em application-utility-pgm.yml:
jclbcics.ddname.size(o padrão é 8): configura globalmente o tamanho do nome do conjunto de dados; se esse valor for definido e o tamanho do nome do conjunto de dados for menor que esse valor, o nome do conjunto de dados será truncado.
Na etapa individual do arquivo Groovy chamando o programa
JCLBCICS_OVERRIDDEN_SIZE: ele substitui o tamanho do nome do conjunto de dados global:
TreeMap stepMapTransfo = [:] Map stepParams = ["MapTransfo":stepMapTransfo] stepParams["MapTransfo"]["JCLBCICS_OVERRIDDEN_SIZE"] = '6'
Se o tamanho do nome dd ajustado (após o truncamento) for menor que 8, o nome dd será considerado um curinga e a função funcionará para todos os conjuntos de dados que começam com esse nome dd.
Recursos principais
As operações suportadas são:
ABERTO: define conjuntos de dados para o status HABILITADO
FECHAR: define os conjuntos de dados para o status DESATIVADO
Essas operações são declaradas por meio da classe DatasetsConfiguration builder:
new DatasetsConfiguration().close(<DD name>).open(<DD name>)
Nome do DD: nome do conjunto de dados, o caractere curinga * é aceito se o tamanho do nome dd for menor que o tamanho máximo do nome dd (8).
Tratamento de erros
Definir código de erro 0
Uso da amostra
Aqui está um exemplo do uso do programa JCLBCICS pelo Groovy:
ele desativa o conjunto de dadosUFOLJ3P, habilita todos os conjuntos de dados começando com AX, habilita todos os conjuntos de dados começando com DX
import com.netfective.bluage.gapwalk.rt.call.MainProgramRunner import com.netfective.bluage.gapwalk.rt.call.ProgramExecutionResult import com.netfective.bluage.gapwalk.rt.io.support.DatasetsConfiguration MainProgramRunner mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) def TreeMap stepMapTransfo = [:] def Map stepParams = ['MapTransfo':stepMapTransfo] stepParams['MapTransfo']['JCLBCICS_OVERRIDDEN_SIZE'] = '7' ProgramExecutionResult res = mpr .withDatasetsConfiguration(new DatasetsConfiguration().close("UFOLJ3P").open("AX*").open("DX")) .withParameters(stepParams) .runProgram("JCLBCICS")
