

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](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html).

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 comandos
<a name="system-commands-utilities"></a>

Esta seção está relacionada aos programas utilitários cuja função é manipular os comandos do usuário, fornecidos por meio de cartões de controle.

## IKJEFT1A/IKJEFT1B/KEQEFT01/IKJEFT01/DSNDBTCH
<a name="ikjeft1a-ikjeft1b-keqeft01-ikjeft01-dsndbtch"></a>

### IKJEFT1Um propósito
<a name="ikjeft1a-purpose"></a>

IKJEFT1A e seus aliases executam comandos TSO (**T** time **S** Sharing **O** Option) em trabalhos em lotes sem exigir uma sessão de TSO interativa, unindo ambientes de TSO não interativos e ambientes de TSO interativos.

Imita o comportamento legado IKJEFT1 A com diferenças específicas do ambiente: por exemplo, os comandos DB2 TERM (inate) são ignorados em ambientes modernos (registrados como informativos).

**nota**  
Sintaxe de comando não detalhada aqui - A usa conjuntos IKJEFT1 de dados de comandos legados inalterados. Consulte a documentação da plataforma antiga para obter detalhes sobre os comandos do TSO.

### IKJEFT1Uma assinatura
<a name="ikjeft1a-signature"></a>

Usa o `SYSTSIN` conjunto de dados para entrada de comando (definido por meio da `DD` diretiva JCL). A versão modernizada usa o mesmo conjunto de dados inalterado. Invocado somente em scripts de trabalhos do Groovy modernizados.

### IKJEFT1Um parâmetro de configuração relacionado
<a name="ikjeft1a-configuration"></a>

O comportamento do utilitário é influenciado pelo seguinte parâmetro de configuração:
+ `systin.encoding`

Consulte [Propriedades disponíveis para aplicações web opcionais](ba-runtime-key-value.md#ba-runtime-key-value-web) para obter detalhes sobre a configuração desse parâmetro.

### IKJEFT1Um Checks/Error manuseio
<a name="ikjeft1a-error-handling"></a>

Quando um comando não suportado está presente no conjunto de dados SYSTSIN, um `RuntimeException` é lançado.

### IKJEFT1Uma amostra de usos
<a name="ikjeft1a-sample-usages"></a>

O script JCL legado (que usa um conteúdo embutido do `SYSTSIN` conjunto de dados, usando a diretiva) `DD *`

```
//*********************************************************************         
//* READ THE TEMPORARY INPUT FILE                                     *         
//*********************************************************************         
// IF IDCM00032.RC = 1 THEN                                                    
//067FILEKEY  EXEC PGM=IKJEFT01,DYNAMNBR=20                                     
//SYSTSIN   DD *                                                                
 DSN SYSTEM(DB2P)                                                               
 RUN  PROGRAM(067-fileKey) PLAN(FILEKEYPLAN)    PARM('RT')                      
 END                                                                            
/*                                                                              
//TEMPVSAM  DD DSN=IDXVIDEO.TEMPVSAM,DISP=SHR                                   
//FKOUT     DD DSN=output(out067.txt),DISP=(NEW,CATLG)                          
// ENDIF                                                                        
//*********************************************************************
```

e o script modernizado correspondente (no groovy) -- o conteúdo embutido do `SYSTSIN` conjunto de dados é representado por um “stream” --

```
// STEP 067FILEKEY - PGM - IKJEFT01***********************************************
def step067FILEKEY(Object shell, Map params, Map programResults){
    shell.with {
        if (checkValidProgramResults(programResults)) {
            return execStep("067FILEKEY", "IKJEFT01", programResults, {
                mpr
                    .withFileConfigurations(new FileConfigurationUtils()
                        .withJobContext(jobContext)
                        .fileSystem("SYSTSIN")
                        .stream(
""" DSN SYSTEM(DB2P)                                                               
 RUN  PROGRAM(067-fileKey) PLAN(FILEKEYPLAN)    PARM('RT')                      
 END
""", getEncoding())
                        .build()
                        .bluesam("TEMPVSAM")
                        .dataset("IDXVIDEO.TEMPVSAM")
                        .disposition("SHR")
                        .build()
                        .fileSystem("FKOUT")
                        .path("output(out067.txt)")
                        .disposition("NEW")
                        .normalTermination("CATLG")
                        .build()
                        .getFileConfigurations())
                    .withParameters(params)
                    .runProgram("IKJEFT01")
                })
        }
    }
}
```

## QCMDEXC
<a name="qcmdexc"></a>

### Objetivo do QCMDEXC
<a name="qcmdexc-purpose"></a>

Esse programa utilitário emula o comportamento do utilitário de sistema AS/400 QCMDEXC, usado para executar comandos do sistema de forma dinâmica em tempo de execução.

Recursos:
+ Analisa e executa comandos dinamicamente.
+ Suporta formatos de parâmetros nomeados e posicionais.

### Assinatura QCMDEXC
<a name="qcmdexc-signature"></a>

Aceita 1-2 parâmetros:
+ Primeiro: dados alfanuméricos contendo comandos a serem executados
+ Segundo (opcional): comprimento em bytes a ser lido do primeiro parâmetro (o padrão é tamanho total)

### Manipulação de QCMDEXC Checks/Error
<a name="qcmdexc-error-handling"></a>

Nos seguintes casos, um `RuntimeException` será lançado:
+ Quando o número de argumentos fornecidos não é um ou dois;
+ Se o argumento do comando estiver vazio ou se o comando a ser executado não for reconhecido;
+ Se a execução do comando falhar por qualquer motivo, além disso, o código de retorno do programa será definido como 1.

### Exemplos de usos do QCMDEXC
<a name="qcmdexc-sample-usages"></a>

Aqui está um exemplo de uso de um programa COBOL legado: o item de dados `CL-COMMANDX` é equipado com comandos antes de ser usado como argumento para a chamada do programa QCMDEXC:

```
       INITIALIZE CL-COMMANDX.                                      
                                                               
       STRING                                                       
           "CPYF FROMFILE(PLAYERS) TOFILE(" DELIMITED BY SIZE,            
           "NEWFILE"                      DELIMITED BY SIZE,        
           ") MBROPT(*REPLACE) FMTOPT(*NOCHK) CRTFILE(*YES)"        
                                          DELIMITED BY SIZE         
           INTO CL-COMMANDX                                         
       END-STRING.                                                  
                                                               
       CALL "QCMDEXC"                  USING CL-COMMANDX            
                                             CLENGTHX.
```

Uma vez modernizado em código java, isso se torna:

```
    DataUtils.initialize(ctx.getClCommandx().getClCommandxReference());
    StringConcatenationBuilder.newInstance(ctx.getClCommandx().getClCommandxReference())
        .addDelimitedBySize("CPYF FROMFILE(PLAYERS) TOFILE(")
        .addDelimitedBySize("NEWFILE")
        .addDelimitedBySize(") MBROPT(*REPLACE) FMTOPT(*NOCHK) CRTFILE(*YES)")
        .end();
    ctrl.callSubProgram("QCMDEXC", CallBuilder.newInstance()
        .byReference(ctx.getClCommandx().getClCommandxReference())
        .byReference(ctx.getClengthx().getClengthxReference())
        .getArguments(), ctx);
```

Observe que o conteúdo dos comandos antigos está sendo usado “como está” no código modernizado, sem nenhuma modificação.