Grupos de execução automática (AEGs, na sigla em inglês)

Os grupos de execução automática selecionam uma plataforma de execução para cada tipo de cadeia de ferramentas. Em outras palavras, um destino pode ter várias plataformas de execução sem definir grupos de execução.

Resumo

Os grupos de execução automática estão intimamente conectados às cadeias de ferramentas. Se você estiver usando cadeias de ferramentas, adicione o parâmetro toolchain às ações afetadas (ações que usam um executável ou uma ferramenta de uma cadeia de ferramentas). Por exemplo:

ctx.actions.run(
    ...,
    executable = ctx.toolchain['@bazel_tools//tools/jdk:toolchain_type'].tool,
    ...,
    toolchain = '@bazel_tools//tools/jdk:toolchain_type',
)

Se a ação não usar uma ferramenta ou executável de uma cadeia de ferramentas e o Blaze não detectar isso (o erro será gerado), defina toolchain = None.

Se você precisar usar várias cadeias de ferramentas em uma única plataforma de execução (uma ação usa executáveis ou ferramentas de duas ou mais cadeias de ferramentas), defina manualmente exec_groups (confira Quando devo usar um exec_group personalizado? a seção).

Histórico

Antes dos AEGs, a plataforma de execução era selecionada no nível da regra. Por exemplo:

my_rule = rule(
    _impl,
    toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
)

A regra my_rule registra dois tipos de cadeia de ferramentas. Isso significa que a resolução da cadeia de ferramentas usada para encontrar uma plataforma de execução que ofereça suporte aos dois tipos de cadeia de ferramentas. A plataforma de execução selecionada foi usada para cada ação registrada na regra, a menos que especificado de forma diferente com exec_groups. Em outras palavras, todas as ações dentro da regra costumavam ter uma única plataforma de execução , mesmo que usassem ferramentas de cadeias de ferramentas diferentes (a plataforma de execução é selecionada para cada destino). Isso resultou em falhas quando não havia uma plataforma de execução que oferecesse suporte a todas as cadeias de ferramentas.

Estado atual

Com os AEGs, a plataforma de execução é selecionada para cada tipo de cadeia de ferramentas. A função de implementação do exemplo anterior, my_rule, seria assim:

def _impl(ctx):
    ctx.actions.run(
      mnemonic = "First action",
      executable = ctx.toolchain['//tools:toolchain_type_1'].tool,
      toolchain = '//tools:toolchain_type_1',
    )

    ctx.actions.run(
      mnemonic = "Second action",
      executable = ctx.toolchain['//tools:toolchain_type_2'].tool,
      toolchain = '//tools:toolchain_type_2',
    )

Essa regra cria duas ações: a First action, que usa executáveis de um //tools:toolchain_type_1, e a Second action, que usa executáveis de um //tools:toolchain_type_2. Antes dos AEGs, essas duas ações eram executadas em uma única plataforma de execução que oferecia suporte aos dois tipos de cadeia de ferramentas. Com os AEGs, ao adicionar o parâmetro toolchain às ações, cada ação é executada na plataforma de execução que fornece a cadeia de ferramentas. As ações podem ser executadas em plataformas de execução diferentes.

O mesmo é eficaz com ctx.actions.run_shell, em que o toolchain parâmetro precisa ser adicionado quando as tools são de uma cadeia de ferramentas.

Diferença entre grupos de execução personalizados e grupos de execução automáticos

Como o nome sugere, os AEGs são grupos de execução criados automaticamente para cada tipo de cadeia de ferramentas registrado em uma regra. Não é necessário especificá-los manualmente, ao contrário dos grupos de execução "clássicos".

Quando devo usar um exec_group personalizado?

Os exec_groups personalizados são necessários apenas quando várias cadeias de ferramentas precisam ser executadas em uma única plataforma de execução. Em todos os outros casos, não é necessário definir exec_groups personalizados. Por exemplo:

def _impl(ctx):
    ctx.actions.run(
      ...,
      executable = ctx.toolchain['//tools:toolchain_type_1'].tool,
      tools = [ctx.toolchain['//tools:toolchain_type_2'].tool],
      exec_group = 'two_toolchains',
    )

my_rule = rule(
    _impl,
    exec_groups = {
        "two_toolchains": exec_group(
            toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
        ),
    }
)

Migração de AEGs

Internamente no google3, o Blaze já está usando AEGs. Externamente para o Bazel, a migração está em processo. Algumas regras já estão usando esse recurso (por exemplo, regras Java e C++).

Quais versões do Bazel oferecem suporte a essa migração?

Os AEGs são totalmente compatíveis com o Bazel 7.

Como ativar os AEGs?

Defina --incompatible_auto_exec_groups como verdadeiro. Mais informações sobre a flag em o problema do GitHub (em inglês).

Como ativar os AEGs em uma regra específica?

Defina o atributo _use_auto_exec_groups em uma regra.

my_rule = rule(
    _impl,
    attrs = {
      "_use_auto_exec_groups": attr.bool(default = True),
    }
)

Isso ativa os AEGs apenas em my_rule, e as ações começam a usar a nova lógica ao selecionar a plataforma de execução. A flag incompatível é substituída por esse atributo.

Como desativar os AEGs em caso de erro?

Defina --incompatible_auto_exec_groups como falso para desativar completamente os AEGs em seu projeto (problema do GitHub da flag) ou desative uma regra específica definindo o atributo _use_auto_exec_groups como False (mais detalhes sobre o atributo).

Mensagens de erro ao migrar para AEGs

Não foi possível identificar se as ferramentas são de dependências implícitas ou de uma cadeia de ferramentas. Defina o parâmetro da cadeia de ferramentas. Se você não estiver usando uma cadeia de ferramentas, defina-a como "Nenhuma".

• Nesse caso, você recebe uma pilha de chamadas antes do erro e pode ver claramente qual ação exata precisa do parâmetro da cadeia de ferramentas. Verifique qual cadeia de ferramentas é usada para a ação e defina-a com o parâmetro da cadeia de ferramentas. Se nenhuma cadeia de ferramentas for usada na ação para ferramentas ou executáveis, defina-a como None.

Ação declarada para a cadeia de ferramentas inexistente "[toolchain_type]".

• Isso significa que você definiu o parâmetro da cadeia de ferramentas na ação, mas não o registrou na regra. Registre a cadeia de ferramentas ou defina None na ação.

Material adicional

Para mais informações, consulte o documento de design: Grupos de execução automática para cadeias de ferramentas.