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
Nonena ação.
Material adicional
Para mais informações, consulte o documento de design: Grupos de execução automática para cadeias de ferramentas.