# Block Execution

O **Block Execution** declara um trecho de *pipeline* para um fim específico. Ele pode ser usado para:

* separar logicamente trechos de um *pipeline* extenso de maneira que o seu comportamento se torne mais fácil de entender;
* permitir que os diferentes caminhos criados por componentes de desvio de fluxo possam se unir ao final do trecho declarado (mais detalhes adiante);
* declarar um trecho de *pipeline* para tratamento de erros específicos.

## Parâmetros

O **Block Execution** não possui nenhuma configuração específica para o seu funcionamento, bastando apenas construir os *subpipelines onProcess* e *onException*.

## Subpipelines

O **Block Execution** faz parte de um conjunto de componentes que trabalham com *subpipelines* para executar as suas funções. Para mais informações, [leia a documentação sobre Subpipelines](https://app.gitbook.com/s/cO0A6g1dOsu8BiHYqO67/development-cycle/build-overview/pipelines/subpipelines). 

Para trabalhar com este tipo de componente, você precisa levar em consideração 2 conceitos importantes:

* **Subpipeline definido no bloco onProcess:** o *pipeline* definido nesse bloco é o trecho de execução do componente.
* **Subpipeline definido no bloco onException:** o *pipeline* definido nesse bloco é executado sempre que ocorrer uma falha no bloco *onProcess*. Veja mais detalhes abaixo.

## Definindo o subpipeline executado como parte do bloco <a href="#definindo-o-subpipeline-executado-como-parte-do-bloco" id="definindo-o-subpipeline-executado-como-parte-do-bloco"></a>

Para definir o *subpipeline* a ser executado, basta clicar no ícone **onProcess** do componente:

<figure><img src="https://content.gitbook.com/content/SKBJ6ZiEWBU93x170HH4/blobs/DeiziWRRAdEn4QHi3ruj/block%20exec%20example%20nov%2023.png" alt=""><figcaption><p>O ícone <em>onProcess</em> fica destacado acima do componente</p></figcaption></figure>

Ao clicar nesse ícone, um *subpipeline* será criado (ou exibido, caso já exista). Então basta construir o fluxo desejado conforme a necessidade de execução.

{% hint style="info" %}
A entrada desse *subpipeline* será alimentada com a mensagem imediatamente anterior ao **Block Execution**.
{% endhint %}

## Utilizando o Block Execution para unir caminhos diferentes de um componente de desvio de fluxo <a href="#utilizando-o-block-execution-para-unir-caminhos-diferentes-de-um-componente-de-desvio-de-fluxo" id="utilizando-o-block-execution-para-unir-caminhos-diferentes-de-um-componente-de-desvio-de-fluxo"></a>

Quando um componente de desvio de fluxo é utilizado, assim como o [**Choice**](https://docs.digibee.com/documentation/connectors-and-triggers/pt-br/connectors/logic/choice), múltiplos caminhos são criados no *pipeline* para atender ao desvio de fluxo desejado. Por exemplo:

<figure><img src="https://content.gitbook.com/content/SKBJ6ZiEWBU93x170HH4/blobs/jkaUKSnTd3Hf0rgRjmmT/block%20exec%20ex2%20nov%2023.png" alt=""><figcaption><p>Exemplo de <em>pipeline</em> usando múltiplos caminhos</p></figcaption></figure>

No caso acima, você pode ver 2 desvios de fluxo: **path 1** e **path 2**, que levam a caminhos completamente diferentes no *pipeline*. Suponha que seja necessário unir esses caminhos para continuar a execução do *pipeline*. O componente **Block Execution** tem a função de realizar esse agrupamento de caminhos diferentes em um bloco de execução separado. Quando um dos caminhos terminar, o controle volta para o **Block Execution** que, por sua vez, é seguido pelo próximo componente. Veja:

<figure><img src="https://content.gitbook.com/content/SKBJ6ZiEWBU93x170HH4/blobs/307npR5EAPVaoZxugiTw/block%20exec%20ex3%20nov%2023.png" alt=""><figcaption><p>Exemplo do Block Execution sendo usado para agrupar caminhos diferentes</p></figcaption></figure>

Nesse outro exemplo acima, o **Block Execution** é seguido pelo [**JSON Generator**](https://docs.digibee.com/documentation/connectors-and-triggers/pt-br/connectors/tools/json-generator). Dentro do *subpipeline onProcess* do **Block Execution**, foi utilizado um componente **Choice** com desvios.

Quando os desvios chegam ao final, eles encerram o **Block Execution**, que retorna ao *pipeline* principal e executa o componente seguinte - nesse caso, o **JSON Generator**.

Dessa forma, é possível unir e organizar *subpipelines* que contenham fluxos com ramificações.

## Tratamento de erros <a href="#tratamento-de-erros" id="tratamento-de-erros"></a>

Assim como todos os outros componentes que possuem os *subpipelines* *onProcess* e *onException*, o **Block Execution** também faz o tratamento de erros por meio da execução do *subpipeline* *onException*.

Um erro pode ser ocasionado por outros componentes quando eles identificam situações adversas. Geralmente os componentes possuem uma propriedade de configuração denominada **Fail On Error**, que controla se você deseja ou não gerar um erro que possa ser tratado em fluxos *onException*.

Assim, quando um componente "lança" um erro e está com a propriedade **Fail On Error** ativada, o **Block Execution** intercepta o erro e o envia para tratamento no *subpipeline* *onException*.

Estas são as situações especiais que você deve levar em consideração:

* se um fluxo *onException* não for definido, o **Block Execution** simplesmente repassa o erro adiante para que outro componente com execução por *subpipeline* o trate. Por outro lado, se o fluxo principal do *pipeline* for utilizado, então o *pipeline* é encerrado com o erro;
* se um novo erro ocorre durante o *subpipeline onException*, o **Block Execution** também repassa o erro adiante para que outro componente com execução por *subpipeline* o trate. Mas se o fluxo principal do *pipeline* for utilizado, o *pipeline* é igualmente encerrado com o erro.