Ciclo de Vida do Nó Input Definido pelo Usuário

Este tópico o orienta pelos vários estágios na vida de um nó de entrada definido pelo usuário criado utilizando as linguagens de programação C ou Java. Ele cobre os seguintes estágios no ciclo de vida de um nó de entrada:

Ciclo de Vida do Nó de Entrada C

Registro

Durante a fase de registro, o intermediário descobre quais recursos, neste caso nós, estão disponíveis e quais lils podem fornecê-los. A fase inicia quando um grupo de exceções inicia. As lils são carregadas na inicialização de um grupo de execução e o intermediário as consulta para descobrir que recursos elas podem fornecer.

Uma estrutura CciFactory é criada durante a fase de registro, quando o nó definido pelo usuário chama cniCreateNodeFactory.

APIs chamadas pelo intermediário durante este estágio:
  • biGetMessageflowNodeFactory
  • bipGetParserFactory
APIs chamadas pelo nó definido pelo usuário durante este estágio:
  • cniCreateNodeFactory

Instanciação

Uma instância de um nó Input definido pelo usuário é criada quando a comando mqsistart inicia ou inicia novamente o processo do grupo de execução ou quando um fluxo de mensagens associado ao nó é implementado.

As seguintes APIs são chamadas durante essa fase:
  • cniCreateNodeContext. Esta API aloca memória para a criação da instância do nó definido pelo usuário para conter os valores para os atributos configurados. Esta API é chamada uma vez para cada fluxo de mensagens que esteja utilizando o nó Input definido pelo usuário.
  • cniCreateInputTerminal. Esta API é chamada dentro da API cniCreateNodeContext, e é utilizada para instruir ao intermediário quais terminais de entrada tem, se existirem, o nó de entrada definido pelo usuário.
    Nota: O nó de entrada definido pelo usuário terá terminais de entrada somente se estiver agindo também como um nó de processamento de mensagem. Se esse for o caso, em geral é melhor utilizar um nó de processamento de mensagem definido pelo usuário separado para executar o processamento de mensagens, em vez de combinar ambas as operações em um nó mais complexo.
  • cniCreateOutputTerminal. Esta API é chamada dentro da API cniCreateNodeContext, e é utilizada para instruir ao intermediário quais terminais de saída seu nó de entrada definido pelo usuário tem.
  • cniSetAttribute. Esta API é chamada pelo intermediário para estabelecer os valores para os atributos configurados do nó definido pelo usuário.

Durante essa fase uma estrutura CciTerminal é criada. Essa estrutura é criada quando cniCreateTerminal é chamado.

Processamento

A fase de processamento começa quando a funçãocniRun é chamada pelo intermediário. O intermediário utiliza a função cniRun para determinar como processar uma mensagem, incluindo a determinação do domínio no qual uma mensagem está definida e a chamada do analisador relevante para esse domínio.

Um encadeamento é pedido do conjunto de encadeamentos do fluxo de mensagens e é iniciado no método run do nó de entrada. O encadeamento se conecta ao gerenciador de filas do intermediário e retém essa conexão por seu ciclo de vida. Quando um encadeamento tiver sido alocado, o nó entrará em um loop de processamento de mensagem enquanto aguarda receber uma mensagem, repetindo até que uma mensagem seja recebida. Se o fluxo de mensagens for configurado para utilizar vários encadeamentos, o dispatch de encadeamentos será ativado.

Os dados da mensagem podem agora ser propagados downstream.

As seguintes APIs são chamadas pelo intermediário durante esta fase:
  • cniRun. Esta função é chamada pelo intermediário para determinar como processar a mensagem de entrada.
  • cniSetInputBuffer. Esta função fornece um buffer de entrada ou instrui ao intermediário onde o buffer de entrada está, e o associa a um objeto de mensagem.

Destruição

Um nó de entrada definido pelo usuário é destruído quando o fluxo de mensagens é reimplementado, ou quando mqsistop é utilizado para parar o processo do grupo de execução. É possível destruir o nó implementando a função cniDeleteNodeContext.

Quando um nó de entrada definido pelo usuário é destruído de uma dessas maneiras, deve-se liberar qualquer memória utilizada pelo nó e liberar quaisquer recursos retidos, tais como soquetes.

As seguintes APIs são chamadas pelo intermediário durante esta fase:
  • cniDeleteNodeContext. Esta função é chamada pelo intermediário para destruir a instância do nó de entrada.

Ciclo de Vida do Nó de Entrada Java

Registro

Durante a fase de registro um nó Input definido pelo usuário escrito em Java torna-se conhecido ao intermediário. O nó é registrado com o intermediário através do método estático getNodeName. Sempre que um intermediário inicia, ele carrega todas as classes java relevantes. O método estático getNodeName é chamado nesse ponto e o intermediário registra o nó de entrada com o nome de nó especificado no método getNodeName. Se não for especificado um nome de nó, o intermediário criará automaticamente um nome para o nó com base no pacote onde ele está contido.

Utilizar um método estático aqui significa que o método pode ser chamado pelo intermediário antes que o próprio nó seja instanciado.

Instanciação

Um nó de entrada Java definido pelo usuário é instanciado quando um intermediário implementa um fluxo de mensagens contendo o nó de entrada definido pelo usuário. Quando o nó é instanciado, o construtor da classe de nó de entrada é chamado.

Quando um nó é instanciado, quaisquer terminais que tenham sido especificados utilizando os métodos relevantes são criados. Um nó Input não tem nenhum terminal de entrada associado a ele mas pode ter qualquer número de nós de saída. Os terminais de saída incluem terminais out, failure e catch. Utilize o método createOutputTerminal dentro do construtor da classe do nó para criar o número de terminais de saída necessário.

Se deseja lidar com exceções passadas de volta para seu nó de entrada, utilize createOutputTerminal para criar um terminal de captura para seu nó de entrada. Quando o nó de entrada capturar um erro, o terminal catch o processará da mesma maneira que um nó MQInput regular o faria. Porém, você pode permitir que a maioria das exceções, como exceções causadas por problemas de implementação, sejam transmitidas de volta ao intermediário, o qual avisará o usuário sobre quaisquer possíveis erros de configuração.

Como um mínimo, a classe do construtor somente necessita criar esses terminais de saída no nó de entrada. Contudo, se precisar inicializar valores de atributos, tais como definir o analisador que fará a análise inicial de uma mensagem transmitida do nó de entrada, você deve incluir também esse código neste ponto no nó de entrada.

Processamento

O processamento de mensagens para um nó de entrada começa quando o intermediário chama o método run. O método run cria a mensagem de entrada, e deve conter a função de processamento para o nó de entrada.

O método run é definido em MbInputNodeInterface, que é a interface utilizada em um nó de entrada definido pelo usuário que o define como nó de entrada. É preciso incluir um método run no nó. Se um método run não for incluído no nó de entrada definido pelo usuário, o código fonte do nó não será compilado.

Quando um fluxo de mensagens contendo um nó de entrada definido pelo usuário é implementado com êxito, o intermediário chama o método de implementação run do nó, e continua a chamar esse método enquanto aguarda o processo das mensagens.

Quando um fluxo de mensagens é iniciado, um único encadeamento é despachado pelo intermediário e é chamado para o método run do nó de entrada. Se o método dispatchThread for chamado, mais encadeamentos podem também ser criados no mesmo método run. Esses novos encadeamentos chamam imediatamente para o método run do nó de entrada, e podem ser tratados da mesma forma que o encadeamento original. O número de novos encadeamentos que podem ser criados é definido pelo atributo additionalInstances. Certifique-se de que os encadeamentos são despachados após a criação de uma mensagem e antes que ela seja propagada. Isso assegura que somente um encadeamento por vez esteja aguardando por uma nova mensagem.

Um usuário que esteja implementando um fluxo de mensagens utilizando um nó de entrada definido pelo usuário pode especificar que vários encadeamentos possam ser utilizados para servir o fluxo de mensagens. O nó de entrada é responsável por implementar o modelo de encadeamento escolhido, mas não é possível impor restrições a essa capacidade no código. Em vez disso, você deve garantir que seu código seja completamente reentrante e que quaisquer funções que o código chame também o sejam.

Para obter informações adicionais sobre o modelo de encadeamento para nós Input definidos pelo usuário, consulte Encadeamentos.

Destruição

Um nó de entrada Java definido pelo usuário é destruído quando o nó é excluído ou o intermediário é encerrado. Você não necessita incluir algo em seu código que especifique que o nó deve ser excluído fisicamente, porque isso pode ser tratado pelo coletor de lixo.

Contudo, se quiser ser notificado de que um nó está prestes a ser excluído, você pode utilizar o método onDelete. Você pode querer fazer isso se existirem recursos além dos que serão coletados como lixo que você deseje excluir. Por exemplo, se você tiver aberto um soquete, este não será, novamente, fechado corretamente quando o nó for excluído automaticamente. Você pode incluir essa instrução no método onDelete para assegurar que o soquete seja fechado corretamente.

Conceitos relacionados
Analisadores Definidos pelo Usuário
Extensões Definidas pelo Usuário

Tarefas relacionadas
Criando um Nó de Entrada em Java
Criando um Nó de Entrada em C

Referências relacionadas
cniCreateInputTerminal
cniCreateNodeContext
cniCreateNodeFactory
cniRun
cniSetInputBuffer