Comandos e opções

Informar um problema Ver código-fonte Nightly · 7.4 . 7.3 · 7.2 · 7.1 · 7.0 · 6.5

Esta página aborda as opções disponíveis com vários comandos do Bazel, como bazel build, bazel run e bazel test. Esta página é complementar à lista de comandos do Bazel em Build with Bazel.

Sintaxe de destino

Alguns comandos, como build ou test, podem operar em uma lista de destinos. Eles usam uma sintaxe mais flexível que os rótulos, documentada em Como especificar os destinos a serem criados.

Opções

As seções abaixo descrevem as opções disponíveis durante um build. Quando --long é usado em um comando de ajuda, as mensagens de ajuda on-line fornecem informações resumidas sobre o significado, o tipo e o valor padrão de cada opção.

A maioria das opções só pode ser especificada uma vez. Quando especificada várias vezes, a última instância vence. As opções que podem ser especificadas várias vezes são identificadas na ajuda on-line com o texto "pode ser usado várias vezes".

Localização do pacote

--package_path

Essa opção especifica o conjunto de diretórios que são pesquisados para encontrar o arquivo BUILD de um determinado pacote.

O Bazel encontra os pacotes pesquisando o caminho deles. Trata-se de uma lista ordenada separada por dois-pontos de diretórios do Bazel, cada um sendo a raiz de uma árvore de origem parcial.

Para especificar um caminho de pacote personalizado usando a opção --package_path:

  % bazel build --package_path %workspace%:/some/other/root

Os elementos do caminho do pacote podem ser especificados em três formatos:

1. Se o primeiro caractere for /, o caminho será absoluto.
2. Se o caminho começar com %workspace%, ele será usado em relação ao diretório do Bazel mais próximo. Por exemplo, se o diretório de trabalho for /home/bob/clients/bob_client/bazel/foo, a string %workspace% no caminho do pacote será expandida para /home/bob/clients/bob_client/bazel.
3. Qualquer outra coisa é tirada em relação ao diretório de trabalho. Isso geralmente não é o que você quer fazer e pode se comportar de forma inesperada se você usar o Bazel em diretórios abaixo do espaço de trabalho do Bazel. Por exemplo, se você usar o elemento de caminho do pacote . e executar cd no diretório /home/bob/clients/bob_client/bazel/foo, os pacotes serão resolvidos no diretório /home/bob/clients/bob_client/bazel/foo.

Se você usar um caminho de pacote não padrão, especifique-o no arquivo de configuração do Bazel para sua conveniência.

O Bazel não exige que nenhum pacote esteja no diretório atual. Portanto, é possível fazer um build em um espaço de trabalho do Bazel vazio se todos os pacotes necessários puderem ser encontrados em outro lugar no caminho do pacote.

Exemplo: criar a partir de um cliente vazio

  % mkdir -p foo/bazel
  % cd foo/bazel
  % touch WORKSPACE
  % bazel build --package_path /some/other/path //foo

--deleted_packages

Essa opção especifica uma lista de pacotes separada por vírgulas que o Bazel precisa considerar excluídos e não tenta carregar de nenhum diretório no caminho do pacote. Isso pode ser usado para simular a exclusão de pacotes sem realmente excluí-los.

Verificação de erros

Essas opções controlam a verificação de erros e/ou avisos do Bazel.

--[no]check_visibility

Se essa opção for definida como falsa, as verificações de visibilidade serão rebaixadas para avisos. O valor padrão dessa opção é "true", então, por padrão, a verificação de visibilidade é feita.

--output_filter=regex

A opção --output_filter vai mostrar apenas avisos de build e compilação para destinos que correspondem à expressão regular. Se um destino não corresponder à expressão regular especificada e a execução for bem-sucedida, a saída padrão e o erro padrão serão descartados.

Confira alguns valores típicos para essa opção:

`--output_filter='^//(first/project|second/project):'`	Mostra a saída dos pacotes especificados.
`--output_filter='^//((?!(first/bad_project|second/bad_project):).)*$'`	Não mostra a saída dos pacotes especificados.
`--output_filter=`	Mostrar tudo.
`--output_filter=DONT_MATCH_ANYTHING`	Não mostrar nada.

Flags de ferramentas

Essas opções controlam quais opções o Bazel vai transmitir para outras ferramentas.

--copt=cc-option

Essa opção recebe um argumento que será transmitido ao compilador. O argumento será transmitido ao compilador sempre que for invocado para pré-processar, compilar e/ou montar código C, C++ ou de montador. Ele não será transmitido durante a vinculação.

Essa opção pode ser usada várias vezes. Exemplo:

  % bazel build --copt="-g0" --copt="-fpic" //foo

vai compilar a biblioteca foo sem depurar tabelas, gerando um código independente de posição.

Observação: mudar as configurações de --copt força uma recriação de todos os arquivos de objeto afetados. Além disso, os valores de copts listados em regras de build específicas de cc_library ou cc_binary serão colocados na linha de comando do compilador após essas opções.

Aviso: opções específicas de C++ (como -fno-implicit-templates) precisam ser especificadas em --cxxopt, não em --copt. Da mesma forma, opções específicas de C (como -Wstrict-prototypes) precisam ser especificadas em --conlyopt, não em copt. Da mesma forma, as opções do compilador que têm efeito apenas no momento da vinculação (como -l) precisam ser especificadas em --linkopt, não em --copt.

--host_copt=cc-option

Essa opção recebe um argumento que será transmitido ao compilador para arquivos de origem compilados na configuração do host. Isso é análogo à opção --copt, mas se aplica apenas à configuração do host.

--host_conlyopt=cc-option

Essa opção recebe um argumento que será transmitido ao compilador para arquivos-fonte C compilados na configuração do host. Isso é análogo à opção --conlyopt, mas se aplica apenas à configuração do host.

--host_cxxopt=cc-option

Essa opção usa um argumento que precisa ser transmitido ao compilador para arquivos de origem C++ compilados na configuração do host. Isso é análogo à opção --cxxopt, mas se aplica apenas à configuração do host.

--host_linkopt=linker-option

Essa opção recebe um argumento que será transmitido ao vinculador para arquivos de origem que são compilados na configuração do host. Isso é análogo à opção --linkopt, mas se aplica apenas à configuração do host.

--conlyopt=cc-option

Essa opção aceita um argumento que deve ser passado ao compilador na compilação de arquivos de origem em C.

Isso é semelhante a --copt, mas se aplica apenas à compilação em C, não à compilação ou vinculação em C++. Assim, é possível transmitir opções específicas do C (como -Wno-pointer-sign) usando --conlyopt.

Observação: os parâmetros copts listados nas regras de build cc_library ou cc_binary específicas são colocados na linha de comando do compilador depois dessas opções.

--cxxopt=cc-option

Essa opção recebe um argumento que será transmitido ao compilador ao compilar arquivos de origem C++.

Isso é semelhante a --copt, mas se aplica apenas à compilação em C++, não à compilação ou vinculação em C. Assim, você pode transmitir opções específicas do C++ (como -fpermissive ou -fno-implicit-templates) usando --cxxopt.

Exemplo:

  % bazel build --cxxopt="-fpermissive" --cxxopt="-Wno-error" //foo/cruddy_code

Observação: os parâmetros copts listados em regras de build específicas de cc_library ou cc_binary são colocados na linha de comando do compilador após essas opções.

--linkopt=linker-option

Essa opção usa um argumento que precisa ser passado ao compilador durante a vinculação.

Isso é semelhante ao --copt, mas se aplica apenas a vinculações, não à compilação. Assim, é possível transmitir opções do compilador que só fazem sentido no momento da vinculação (como -lssp ou -Wl,--wrap,abort) usando --linkopt. Exemplo:

  % bazel build --copt="-fmudflap" --linkopt="-lmudflap" //foo/buggy_code

As regras de build também podem especificar opções de link nos atributos. As configurações dessa opção sempre têm precedência. Consulte também cc_library.linkopts.

--strip (always|never|sometimes)

Essa opção determina se o Bazel vai remover as informações de depuração de todos os binários e bibliotecas compartilhadas, invocando o vinculador com a opção -Wl,--strip-debug. --strip=always significa sempre remover informações de depuração. --strip=never significa nunca remover informações de depuração. O valor padrão de --strip=sometimes significa remover se o --compilation_mode for fastbuild.

  % bazel build --strip=always //foo:bar

vai compilar o destino, removendo as informações de depuração de todos os binários gerados.

Observação: se você quiser informações de depuração, não basta desativar o stripping. Você também precisa garantir que as informações de depuração tenham sido geradas pelo compilador. Para isso, use -c dbg ou --copt -g.

A opção --strip do Bazel corresponde à opção --strip-debug do ld: ela só remove informações de depuração. Se, por algum motivo, você quiser remover todos os símbolos, e não apenas os símbolos de depuração, será necessário usar a opção --strip-all do ld, o que pode ser feito transmitindo --linkopt=-Wl,--strip-all para o Bazel. Além disso, definir a flag --strip do Bazel vai substituir --linkopt=-Wl,--strip-all. Portanto, defina apenas uma ou outra.

Se você estiver criando apenas um binário e quiser remover todos os símbolos, também poderá transmitir --stripopt=--strip-all e criar explicitamente a versão //foo:bar.stripped do destino. Conforme descrito na seção sobre --stripopt, isso aplica uma ação de remoção depois que o binário final é vinculado em vez de incluir a remoção em todas as ações de vinculação do build.

--stripopt=strip-option

Essa é uma opção extra para transmitir ao comando strip ao gerar um binário *.stripped. O padrão é -S -p. Essa opção pode ser usada várias vezes.

Observação: --stripopt não se aplica ao stripping do binário principal com [--strip](#flag--strip)=(always|sometimes).

--fdo_instrument=profile-output-dir

A opção --fdo_instrument permite a geração de saída de perfil de FDO (otimização direcionada por feedback) quando o binário C/C++ criado é executado. Para o GCC, o argumento fornecido é usado como um prefixo de diretório para uma árvore de diretórios de arquivos por objeto de arquivos .gcda que contém informações de perfil para cada arquivo .o.

Depois que a árvore de dados do perfil for gerada, ela precisa ser compactada e fornecida à opção --fdo_optimize=profile-zip do Bazel para ativar a compilação otimizada para FDO.

Para o compilador do LLVM, o argumento também é o diretório em que os arquivos de dados de perfil brutos do LLVM são despejados. Por exemplo: --fdo_instrument=/path/to/rawprof/dir/.

As opções --fdo_instrument e --fdo_optimize não podem ser usadas ao mesmo tempo.

--fdo_optimize=profile-zip

A opção --fdo_optimize permite o uso das informações de perfil de arquivo por objeto para realizar otimizações de FDO (otimização direcionada por feedback) durante a compilação. Para o GCC, o argumento fornecido é o arquivo ZIP que contém a árvore de arquivos gerada anteriormente de arquivos .gcda que contêm informações de perfil para cada arquivo .o.

Como alternativa, o argumento fornecido pode apontar para um perfil automático identificado pela extensão .afdo.

Observação :essa opção também aceita marcadores que são convertidos em arquivos de origem. Talvez seja necessário adicionar uma diretiva exports_files ao pacote correspondente para tornar o arquivo visível para o Bazel.

Para o compilador LLVM, o argumento fornecido precisa apontar para o arquivo de saída do perfil LLVM indexado preparado pela ferramenta llvm-profdata e ter uma extensão .profdata.

As opções --fdo_instrument e --fdo_optimize não podem ser usadas ao mesmo tempo.

--[no]output_symbol_counts

Se ativado, cada link invocado por ouro de um binário executável C++ vai gerar um arquivo de contagem de símbolos (usando a opção --print-symbol-counts ouro). Para cada entrada do vinculador, o arquivo registra o número de símbolos que foram definidos e o número de símbolos que foram usados no binário. Essas informações podem ser usadas para rastrear dependências de links desnecessárias. O arquivo de contagem de símbolos é gravado no caminho de saída do binário com o nome [targetname].sc.

Esta opção é desativada por padrão.

--java_language_version=version

Essa opção especifica a versão das origens do Java. Exemplo:

  % bazel build --java_language_version=8 java/com/example/common/foo:all

compila e permite apenas construções compatíveis com a especificação Java 8. O valor padrão é 11. --> Os valores possíveis são: 8, 9, 10, 11, 14 e 15 e podem ser estendidos registrando cadeias de ferramentas Java personalizadas usando default_java_toolchain.

--tool_java_language_version=version

A versão da linguagem Java usada para criar ferramentas que são executadas durante um build. O valor padrão é 11.

--java_runtime_version=version

Essa opção especifica a versão da JVM a ser usada para executar o código e os testes. Por exemplo:

  % bazel run --java_runtime_version=remotejdk_11 java/com/example/common/foo:java_application

faz o download do JDK 11 de um repositório remoto e executa o aplicativo Java usando esse repositório.

O valor padrão é localjdk. Os valores possíveis são: localjdk, localjdk_version, remotejdk_11 e remote_jdk17. É possível estender os valores registrando uma JVM personalizada usando regras de repositório local_java_repository ou remote_java_repostory.

--tool_java_runtime_version=version

A versão da JVM usada para executar ferramentas necessárias durante um build. O valor padrão é remotejdk_11.

--jvmopt=jvm-option

Essa opção permite que argumentos de opção sejam transmitidos para a VM Java. Ela pode ser usada com um argumento grande ou várias vezes com argumentos individuais. Exemplo:

  % bazel build --jvmopt="-server -Xms256m" java/com/example/common/foo:all

vai usar a VM do servidor para iniciar todos os binários Java e definir o tamanho do heap de inicialização da VM como 256 MB.

--javacopt=javac-option

Essa opção permite que argumentos de opção sejam transmitidos para o javac. Ele pode ser usado com um argumento grande ou várias vezes com argumentos individuais. Exemplo:

  % bazel build --javacopt="-g:source,lines" //myprojects:prog

vai recriar um java_binary com as informações de depuração padrão javac (em vez do padrão do Bazel).

A opção é transmitida para o javac depois das opções padrão integradas do Bazel para javac e antes das opções por regra. A última especificação de qualquer opção para javac vence. As opções padrão do javac são:

  -source 8 -target 8 -encoding UTF-8

Observação: mudar as configurações de --javacopt força a recompilação de todas as classes afetadas. Além disso, os parâmetros javacopts listados nas regras de build java_library ou java_binary específicas serão colocados na linha de comando javac depois dessas opções.

--strict_java_deps (default|strict|off|warn|error)

Essa opção controla se o javac verifica se há dependências diretas ausentes. Os destinos Java precisam declarar explicitamente todos os destinos usados diretamente como dependências. Essa flag instrui o javac a determinar os jars realmente usados para a verificação de tipo de cada arquivo Java e emitir um aviso/erro se eles não forem a saída de uma dependência direta do destino atual.

• off significa que a verificação está desativada.
• warn significa que o javac vai gerar avisos Java padrão do tipo [strict] para cada dependência direta ausente.
• default, strict e error significam que o javac vai gerar erros em vez de avisos, fazendo com que o destino atual falhe na criação se alguma dependência direta estiver faltando. Esse também é o comportamento padrão quando a flag não é especificada.

Semântica de build

Essas opções afetam os comandos de build e/ou o conteúdo do arquivo de saída.

--compilation_mode (fastbuild|opt|dbg) (-c)

A opção --compilation_mode (muitas vezes abreviada para -c, especialmente -c opt) usa um argumento de fastbuild, dbg ou opt e afeta várias opções de geração de código C/C++, como o nível de otimização e a integridade das tabelas de depuração. O Bazel usa um diretório de saída diferente para cada modo de compilação, para que você possa alternar entre os modos sem precisar fazer uma reconstrução completa sempre.

• fastbuild significa criar o mais rápido possível: gere o mínimo de informações de depuração (-gmlt -Wl,-S) e não otimize. Esse é o padrão. Observação: -DNDEBUG não será definido.
• dbg significa build com depuração ativada (-g), para que você possa usar o gdb (ou outro depurador).
• opt significa build com a otimização ativada e com chamadas assert() desativadas (-O2 -DNDEBUG). As informações de depuração não serão geradas no modo opt, a menos que você também transmita --copt -g.

--cpu=cpu

Essa opção especifica a arquitetura de CPU de destino a ser usada para a compilação de binários durante o build.

Observação: uma combinação específica de versão do crosstool, versão do compilador e CPU de destino será permitida somente se tiver sido especificada no arquivo CROSSTOOL usado no momento.

--action_env=VAR=VALUE

Especifica o conjunto de variáveis de ambiente disponível durante a execução de todas as ações. As variáveis podem ser especificadas pelo nome (nesse caso, o valor será retirado do ambiente de invocação) ou pelo par name=value, que define o valor independentemente do ambiente de invocação.

Essa flag --action_env pode ser especificada várias vezes. Se um valor for atribuído à mesma variável em várias sinalizações --action_env, a atribuição mais recente vencerá.

--experimental_action_listener=label

Aviso: as ações extras foram descontinuadas. Em vez disso, use aspects.

A opção experimental_action_listener instrui o Bazel a usar detalhes da regra action_listener especificada por label para inserir extra_actions no gráfico de build.

--[no]experimental_extra_action_top_level_only

Aviso: as ações extras foram descontinuadas. Em vez disso, use aspects.

Se essa opção for definida como verdadeira, as ações extras especificadas pela opção de linha de comando --experimental_action_listener serão programadas apenas para destinos de nível superior.

--experimental_extra_action_filter=regex

Aviso: as ações extras foram descontinuadas. Use aspectos em vez disso.

A opção experimental_extra_action_filter instrui o Bazel a filtrar o conjunto de destinos para programar extra_actions.

Essa flag só é aplicável em combinação com a flag --experimental_action_listener.

Por padrão, todos os extra_actions no fechamento transitivo dos alvos-a-criar solicitados são programados para execução. --experimental_extra_action_filter vai restringir a programação a extra_actions, em que o rótulo do proprietário corresponde à expressão regular especificada.

O exemplo a seguir limita a programação de extra_actions para que seja aplicada apenas a ações em que o rótulo do proprietário contém '/bar/':

% bazel build --experimental_action_listener=//test:al //foo/... \
  --experimental_extra_action_filter=.*/bar/.*

--host_cpu=cpu

Essa opção especifica o nome da arquitetura de CPU que precisa ser usada para criar ferramentas de host.

--fat_apk_cpu=cpu[,cpu]*

As CPUs para criar bibliotecas C/C++ nas regras deps transitivas de android_binary. Outras regras de C/C++ não são afetadas. Por exemplo, se um cc_library aparecer no deps transitivo de uma regra android_binary e uma cc_binary, o cc_library será criado pelo menos duas vezes: uma para cada CPU especificada com --fat_apk_cpu para a regra android_binary e outra para a CPU especificada com --cpu para a regra cc_binary.

O padrão é armeabi-v7a.

Um arquivo .so é criado e empacotado no APK para cada CPU especificada com --fat_apk_cpu. O nome do arquivo .so usa "lib" como prefixo do nome da regra android_binary. Por exemplo, se o nome de android_binary for "foo", o arquivo será libfoo.so.

Observação: é necessário selecionar uma ferramenta cruzada compatível com o Android. Se uma regra android_ndk_repository for definida no arquivo WORKSPACE, uma ferramenta crosstool compatível com Android será selecionada automaticamente. Caso contrário, o crostool pode ser selecionado usando as sinalizações --android_crosstool_top ou --crosstool_top.

--per_file_copt=[+-]regex[,[+-]regex]...@option[,option]...

Quando presente, qualquer arquivo C++ com um rótulo ou um caminho de execução que corresponda a uma das expressões regulares de inclusão e não corresponda a nenhuma das expressões de exclusão será criado com as opções fornecidas. A correspondência de rótulo usa o formato canônico do rótulo (ou seja, //package:label_name).

O caminho de execução é o caminho relativo ao diretório do espaço de trabalho, incluindo o nome de base (incluindo a extensão) do arquivo C++. Ele também inclui todos os prefixos dependentes da plataforma.

Observação: se apenas um dos rótulos ou o caminho de execução corresponder às opções, elas serão usadas.

Para corresponder aos arquivos gerados (como saídas de genrule), o Bazel só pode usar o caminho de execução. Nesse caso, o regexp não pode começar com "//", porque ele não corresponde a nenhum caminho de execução. Os nomes de pacotes podem ser usados da seguinte forma: --per_file_copt=base/.*\.pb\.cc@-g0. Isso vai corresponder a todos os arquivos .pb.cc em um diretório chamado base.

Essa opção pode ser usada várias vezes.

A opção é aplicada independentemente do modo de compilação usado. Por exemplo, é possível compilar com --compilation_mode=opt e compilar seletivamente alguns arquivos com a otimização mais forte ativada ou desativada.

Observação: se alguns arquivos forem compilados seletivamente com símbolos de depuração, os símbolos poderão ser removidos durante a vinculação. Isso pode ser evitado definindo --strip=never.

Sintaxe: [+-]regex[,[+-]regex]...@option[,option]..., em que regex representa uma expressão regular que pode ser prefixada com um + para identificar padrões de inclusão e com - para identificar padrões de exclusão. option significa uma opção arbitrária transmitida para o compilador C++. Se uma opção contiver um ,, ela precisará ser colocada entre aspas, como \,. As opções também podem conter @, já que apenas o primeiro @ é usado para separar expressões regulares de opções.

Exemplo: --per_file_copt=//foo:.*\.cc,-//foo:file\.cc@-O0,-fprofile-arcs adiciona as opções -O0 e -fprofile-arcs à linha de comando do compilador C++ para todos os arquivos .cc em //foo/, exceto file.cc.

--dynamic_mode=mode

Determina se os binários C++ serão vinculados dinamicamente, interagindo com o atributo linkstatic nas regras de build.

Modos:

• auto: é convertido em um modo dependente da plataforma. default para Linux e off para Cygwin.
• default: permite que o Bazel escolha se vai vincular dinamicamente. Consulte linkstatic para mais informações.
• fully: vincula todos os destinos dinamicamente. Isso vai acelerar o tempo de vinculação e reduzir o tamanho dos binários resultantes.
• off: vincula todos os destinos no modo maioritariamente estático. Se -static for definido em linkopts, os destinos vão mudar para totalmente estáticos.

--fission (yes|no|[dbg][,opt][,fastbuild])

Ativa a fissão, que grava informações de depuração do C++ em arquivos .dwo dedicados em vez de arquivos .o, onde elas seriam armazenadas. Isso reduz significativamente o tamanho da entrada para links e pode reduzir os tempos de vinculação.

Quando definida como [dbg][,opt][,fastbuild] (exemplo: --fission=dbg,fastbuild), a fissão é ativada apenas para o conjunto especificado de modos de compilação. Isso é útil para as configurações do bazelrc. Quando definida como yes, a fissão é ativada universalmente. Quando definido como no, a divisão é desativada universalmente. O padrão é no.

--force_ignore_dash_static

Se essa flag estiver definida, todas as opções -static em linkopts de arquivos BUILD de regras cc_* serão ignoradas. Isso é apenas uma solução alternativa para builds de proteção do C++.

--[no]force_pic

Se ativado, todas as compilações C++ vão produzir código independente de posição ("-fPIC"), os links vão preferir bibliotecas pré-compiladas PIC em vez de bibliotecas não-PIC, e os links vão produzir executáveis independentes de posição ("-pie"). O padrão é desativado.

Observação: binários vinculados dinamicamente (por exemplo, --dynamic_mode fully) geram código PIC, independentemente da configuração dessa flag. Essa flag é para casos em que os usuários querem que o código PIC seja gerado explicitamente para links estáticos.

--android_resource_shrinking

Seleciona se quer realizar a redução de recursos para as regras android_binary. Define o padrão para o atributo reduzir_resources nas regras android_binary. Consulte a documentação dessa regra para mais detalhes. O padrão é desativado.

--custom_malloc=malloc-library-target

Quando especificado, sempre use a implementação malloc especificada, substituindo todos os atributos malloc="target", incluindo aqueles destinos que usam o padrão (não especificando malloc).

--crosstool_top=label

Essa opção especifica o local do conjunto de compiladores de crosstool a ser usado para toda a compilação C++ durante um build. O Bazel vai procurar um arquivo CROSSTOOL nesse local e usá-lo para determinar automaticamente as configurações de --compiler.

--host_crosstool_top=label

Se não for especificado, o Bazel usará o valor de --crosstool_top para compilar o código na configuração do host, como ferramentas executadas durante a build. O principal objetivo dessa flag é ativar a compilação cruzada.

--apple_crosstool_top=label

A ferramenta cruzada a ser usada para compilar regras C/C++ no deps transitivo de objc*, ios* e apple*. Para esses destinos, essa flag substitui --crosstool_top.

--android_crosstool_top=label

O crosstool a ser usado para compilar regras C/C++ no deps transitivo das regras android_binary. Isso é útil se outras metas no build exigirem uma ferramenta diferente. O padrão é usar a ferramenta gerada pela regra android_ndk_repository no arquivo ESPAÇO DE TRABALHO. Consulte também --fat_apk_cpu.

--compiler=version

Essa opção especifica a versão do compilador C/C++ (como gcc-4.1.0) a ser usada para a compilação de binários durante o build. Se você quiser criar com uma ferramenta cruzada personalizada, use um arquivo CROSSTOOL em vez de especificar essa flag.

Observação: apenas algumas combinações de versão do crosstool, versão do compilador e CPU de destino são permitidas.

--android_sdk=label

Essa opção especifica o conjunto de ferramentas do SDK/plataforma do Android e a biblioteca de execução do Android que serão usadas para criar qualquer regra relacionada ao Android.

O SDK do Android será selecionado automaticamente se uma regra android_sdk_repository for definida no arquivo WORKSPACE.

--java_toolchain=label

Essa opção especifica o rótulo do java_toolchain usado para compilar arquivos de origem Java.

--host_java_toolchain=label

Se não for especificado, o Bazel vai usar o valor de --java_toolchain para compilar o código na configuração do host, como para ferramentas executadas durante o build. O principal objetivo dessa flag é permitir a compilação cruzada.

--javabase=(label)

Essa opção define o rótulo da instalação Java básica a ser usado para bazel run, bazel test e para binários Java criados por regras java_binary e java_test. As variáveis JAVABASE e JAVA "Make" são derivadas dessa opção.

--host_javabase=label

Essa opção define o rótulo da instalação Java de base a ser usada na configuração do host, por exemplo, para ferramentas de build de host, incluindo JavaBuilder e Singlejar.

Isso não seleciona o compilador Java usado para compilar arquivos de origem Java. O compilador pode ser selecionado definindo a opção --java_toolchain.

Estratégia de execução

Essas opções afetam a forma como o Bazel vai executar o build. Eles não devem ter nenhum efeito significativo nos arquivos de saída gerados pelo build. Normalmente, o efeito principal é a velocidade do build.

--spawn_strategy=strategy

Essa opção controla onde e como os comandos são executados.

• standalone faz com que os comandos sejam executados como subprocessos locais. Esse valor foi descontinuado. Em vez disso, use local
• sandboxed faz com que os comandos sejam executados em um sandbox na máquina local. Isso exige que todos os arquivos de entrada, dependências de dados e ferramentas sejam listados como dependências diretas nos atributos srcs, data e tools. O Bazel ativa o sandbox local por padrão em sistemas que oferecem suporte à execução em sandbox.
• local faz com que os comandos sejam executados como subprocessos locais.
• worker faz com que os comandos sejam executados usando um worker persistente, se disponível.
• docker faz com que os comandos sejam executados em um sandbox do Docker na máquina local. Isso exige que o Docker esteja instalado.
• remote faz com que os comandos sejam executados remotamente. Isso só estará disponível se um executor remoto tiver sido configurado separadamente.

--strategy mnemonic=strategy

Essa opção controla onde e como os comandos são executados, substituindo o --spawn_strategy (e --genrule_strategy com o mnemônico Genrule) em uma base por mnemônico. Consulte --spawn_strategy para conferir as estratégias compatíveis e os efeitos delas.

--strategy_regexp=<filter,filter,...>=<strategy>

Essa opção especifica qual estratégia deve ser usada para executar comandos com descrições que correspondem a um determinado regex_filter. Consulte --per_file_copt para saber mais sobre a correspondência de regex_filter. Consulte --spawn_strategy para conferir as estratégias compatíveis e os efeitos delas.

O último regex_filter que corresponde à descrição é usado. Essa opção substitui outras flags para especificar a estratégia.

• Exemplo: --strategy_regexp=//foo.*\\.cc,-//foo/bar=local significa executar ações usando a estratégia local se as descrições corresponderem a //foo.*.cc, mas não a //foo/bar.
• Exemplo: --strategy_regexp='Compiling.*/bar=local' --strategy_regexp=Compiling=sandboxed executa "Compiling //foo/bar/baz" com a estratégia sandboxed, mas ao reverter a ordem, ela executa local.
• Exemplo: --strategy_regexp='Compiling.*/bar=local,sandboxed' executa 'Compiling //foo/bar/baz' com a estratégia local e volta para sandboxed em caso de falha.

--genrule_strategy=strategy

Esta é uma forma abreviada de --strategy=Genrule=strategy.

--jobs=n (-j)

Essa opção, que recebe um argumento inteiro, especifica um limite no número de jobs que precisam ser executados simultaneamente durante a fase de execução do build.

Observação: o número de jobs simultâneos que o Bazel vai executar é determinado não apenas pela configuração --jobs, mas também pelo programador do Bazel, que tenta evitar a execução de jobs simultâneos que usem mais recursos (RAM ou CPU) do que estão disponíveis, com base em algumas estimativas (muito grosseiras) do consumo de recursos de cada job. O comportamento do programador pode ser controlado pela opção --local_ram_resources.

--progress_report_interval=n

O Bazel imprime periodicamente um relatório de progresso sobre jobs que ainda não foram concluídos (como testes de longa duração). Essa opção define a frequência de relatórios. O progresso será impresso a cada n segundos.

O padrão é 0, o que significa um algoritmo incremental: o primeiro relatório será impresso após 10 segundos, depois 30 segundos e, após esse progresso, será informado uma vez a cada minuto.

Quando o Bazel está usando o controle de cursor, conforme especificado por --curses, o progresso é informado a cada segundo.

--local_{ram,cpu}_resources resources or resource expression

Essas opções especificam a quantidade de recursos locais (RAM em MB e número de núcleos lógicos da CPU) que o Bazel pode considerar ao programar atividades de compilação e teste para execução local. Elas recebem um número inteiro ou uma palavra-chave (HOST_RAM ou HOST_CPUS), opcionalmente seguida por [-|*float] (por exemplo, --local_cpu_resources=2, --local_ram_resources=HOST_RAM*.5, --local_cpu_resources=HOST_CPUS-1). As flags são independentes. Uma ou ambas podem ser definidas. Por padrão, o Bazel estima a quantidade de RAM e o número de núcleos de CPU diretamente da configuração do sistema local.

--[no]build_runfile_links

Essa opção, que é ativada por padrão, especifica se os links simbólicos de arquivos de execução para testes e binários precisam ser criados no diretório de saída. O uso de --nobuild_runfile_links pode ser útil para validar se todos os destinos são compilados sem gerar a sobrecarga para criar as árvores de arquivos de execução.

Quando os testes (ou aplicativos) são executados, as dependências de dados de execução são reunidas em um só lugar. Dentro da árvore de saída do Bazel, essa árvore "runfiles" normalmente tem como base um irmão do binário ou teste correspondente. Durante a execução do teste, os runfiles podem ser acessados usando caminhos do formulário $TEST_SRCDIR/workspace/packagename/filename. A árvore de arquivos de execução garante que os testes tenham acesso a todos os arquivos em que eles têm uma dependência declarada e nada mais. Por padrão, a árvore de arquivos de execução é implementada construindo um conjunto de links simbólicos para os arquivos necessários. À medida que o conjunto de links cresce, o custo dessa operação também aumenta. Para alguns builds grandes, isso pode contribuir significativamente para o tempo geral de build, principalmente porque cada teste (ou aplicativo) individual requer a própria árvore de runfiles.

--[no]build_runfile_manifests

Essa opção, que é ativada por padrão, especifica se os manifestos de runfiles precisam ser gravados na árvore de saída. A desativação implica --nobuild_runfile_links.

Ele pode ser desativado ao executar testes remotamente, já que as árvores de arquivos de execução serão criadas remotamente a partir de manifestos na memória.

--[no]discard_analysis_cache

Quando essa opção está ativada, o Bazel descarta o cache de análise antes do início da execução, liberando mais memória (cerca de 10%) para a fase de execução. A desvantagem é que as próximas builds incrementais serão mais lentas. Consulte também modo de economia de memória.

--[no]keep_going (-k)

Assim como no GNU Make, a fase de execução de um build é interrompida quando o primeiro erro é encontrado. Às vezes, é útil tentar criar o máximo possível, mesmo diante de erros. Essa opção ativa esse comportamento e, quando especificada, o build tenta criar todos os destinos com pré-requisitos que foram criados, mas ignora os erros.

Embora essa opção geralmente seja associada à fase de execução de um build, ela também afeta a fase de análise: se vários destinos forem especificados em um comando de build, mas apenas alguns deles puderem ser analisados, o build será interrompido com um erro, a menos que --keep_going seja especificado. Nesse caso, o build vai prosseguir para a fase de execução, mas apenas para os destinos que foram analisados.

--[no]use_ijars

Essa opção muda a maneira como os destinos java_library são compilados pelo Bazel. Em vez de usar a saída de um java_library para compilar destinos java_library dependentes, o Bazel vai criar jars de interface que contêm apenas as assinaturas de membros não particulares (métodos e campos de acesso públicos, protegidos e padrão (pacote)) e usar os jars de interface para compilar os destinos dependentes. Isso permite evitar a recompilação quando as mudanças são feitas apenas em corpos de método ou membros particulares de uma classe.

Observação: o uso de --use_ijars pode gerar uma mensagem de erro diferente quando você se refere acidentalmente a um membro não visível de outra classe. Em vez de receber um erro informando que o membro não está visível, você vai receber um erro informando que o membro não existe. Mudar a configuração --use_ijars força uma recompilação de todas as classes afetadas.

--[no]interface_shared_objects

Essa opção ativa os objetos compartilhados de interface, o que faz com que os binários e outras bibliotecas compartilhadas dependam da interface de um objeto compartilhado, em vez da implementação dele. Quando apenas a implementação muda, o Bazel pode evitar a reconstrução de destinos que dependem da biblioteca compartilhada alterada desnecessariamente.

Seleção de saída

Essas opções determinam o que será criado ou testado.

--[no]build

Essa opção faz com que a fase de execução do build ocorra. Ela é ativada por padrão. Quando ela é desativada, a fase de execução é ignorada, e apenas as duas primeiras fases, carregamento e análise, ocorrem.

Essa opção pode ser útil para validar arquivos BUILD e detectar erros nas entradas, sem criar nada.

--[no]build_tests_only

Se especificado, o Bazel vai criar apenas o necessário para executar as regras *_test e test_suite que não foram filtradas devido ao tamanho, tempo limite, tag ou idioma. Se especificado, o Bazel ignora outros destinos especificados na linha de comando. Por padrão, essa opção está desativada, e o Bazel cria tudo o solicitado, incluindo regras *_test e test_suite que são filtradas dos testes. Isso é útil porque a execução de bazel test --build_tests_only foo/... pode não detectar todas as falhas de build na árvore foo.

--[no]check_up_to_date

Essa opção faz com que o Bazel não execute um build, mas apenas verifique se todos os destinos especificados estão atualizados. Nesse caso, o build é concluído, como de costume. No entanto, se algum arquivo estiver desatualizado, em vez de ser criado, um erro será relatado e a build vai falhar. Essa opção pode ser útil para determinar se um build foi realizado mais recentemente do que uma edição de origem (por exemplo, para verificações pré-envio) sem incorrer no custo de um build.

Consulte também --check_tests_up_to_date.

--[no]compile_one_dependency

Compila uma única dependência dos arquivos de argumento. Isso é útil para verificar sintaxe de arquivos de origem em IDEs, por exemplo, reconstruindo um único destino que depende do arquivo de origem para detectar erros o mais cedo possível no ciclo de edição/build/teste. Esse argumento afeta a maneira como todos os argumentos sem flag são interpretados: cada argumento precisa ser um rótulo de destino de arquivo ou um nome de arquivo simples relativo ao diretório de trabalho atual, e uma regra que depende de cada nome de arquivo de origem é criada. Para

As fontes C++ e Java são preferencialmente escolhidas, as regras no mesmo espaço de idioma. Para várias regras com a mesma preferência, é escolhida a primeira que aparece no arquivo BUILD. Um padrão de destino nomeado explicitamente que não faz referência a um arquivo de origem resulta em um erro.

--save_temps

A opção --save_temps faz com que as saídas temporárias do compilador sejam salvas. Isso inclui arquivos .s (código assembler), .i (C pré-processado) e .ii (C++ pré-processado). Essas saídas geralmente são úteis para depuração. Os valores temporários só serão gerados para o conjunto de destinos especificado na linha de comando.

Observação: a implementação de --save_temps não usa a flag -save-temps do compilador. Em vez disso, há dois cartões, um com -S e outro com -E. Uma consequência disso é que, se o build falhar, o Bazel pode não ter produzido os arquivos ".i" ou ".ii" e ".s". Se você estiver tentando usar --save_temps para depurar uma compilação com falha, talvez seja necessário usar --keep_going para que o Bazel ainda tente produzir os arquivos pré-processados após a falha na compilação.

No momento, a sinalização --save_temps funciona somente para regras cc_*.

Para garantir que o Bazel imprima o local dos arquivos de saída adicionais, verifique se a configuração --show_result n está alta o suficiente.

--build_tag_filters=tag[,tag]*

Se especificado, o Bazel vai criar apenas destinos que tenham pelo menos uma tag obrigatória (se alguma delas for especificada) e que não tenham tags excluídas. O filtro de tag de build é especificado como uma lista de palavras-chave de tag delimitada por vírgulas, opcionalmente precedida pelo sinal "-" usado para indicar tags excluídas. As tags obrigatórias também podem ter um sinal "+" anterior.

Ao executar testes, o Bazel ignora --build_tag_filters para destinos de teste, que são compilados e executados mesmo que não correspondam a esse filtro. Para evitar a criação, filtre os destinos de teste usando --test_tag_filters ou os excluindo explicitamente.

--test_size_filters=size[,size]*

Se especificado, o Bazel vai testar (ou criar, se --build_tests_only também for especificado) apenas destinos de teste com o tamanho especificado. O filtro de tamanho do teste é especificado como uma lista delimitada por vírgulas de valores de tamanho de teste permitidos (pequeno, médio, grande ou enorme), opcionalmente precedida pelo sinal "-" usado para indicar tamanhos de teste excluídos. Por exemplo,

  % bazel test --test_size_filters=small,medium //foo:all

e

  % bazel test --test_size_filters=-large,-enormous //foo:all

vai testar apenas testes pequenos e médios em //foo.

Por padrão, a filtragem de tamanho de teste não é aplicada.

--test_timeout_filters=timeout[,timeout]*

Se especificado, o Bazel vai testar (ou criar, se --build_tests_only também for especificado) apenas destinos de teste com o tempo limite fornecido. O filtro de tempo limite de teste é especificado como uma lista delimitada por vírgulas de valores de tempo limite de teste permitidos (curtos, moderados, longos ou eternos), opcionalmente precedidos pelo sinal "-" usado para indicar os tempos limite de teste excluídos. Consulte --test_size_filters para conferir um exemplo de sintaxe.

Por padrão, a filtragem de tempo limite do teste não é aplicada.

--test_tag_filters=tag[,tag]*

Se especificado, o Bazel vai testar (ou criar, se --build_tests_only também for especificado) apenas destinos de teste que tenham pelo menos uma tag obrigatória (se alguma delas for especificada) e que não tenham tags excluídas. O filtro de tag de teste é especificado como uma lista delimitada por vírgulas de palavras-chave de tag, opcionalmente precedida pelo sinal "-" usado para indicar tags excluídas. As tags obrigatórias também podem ter um sinal "+" anterior.

Por exemplo,

  % bazel test --test_tag_filters=performance,stress,-flaky //myproject:all

vai testar os destinos que estão marcados com a tag performance ou stress, mas não com a tag flaky.

Por padrão, a filtragem de tags de teste não é aplicada. Também é possível filtrar as tags size e local do teste dessa maneira.

--test_lang_filters=lang[,lang]*

Especifica uma lista de idiomas de teste separados por vírgulas para idiomas com uma regra *_test oficial. Consulte a enciclopédia de build para conferir uma lista completa deles. Cada idioma pode ser precedido por "-" para especificar idiomas excluídos. O nome usado para cada idioma precisa ser o mesmo que o prefixo de idioma na regra *_test, por exemplo, cc, java ou sh.

Se especificado, o Bazel vai testar (ou compilar, se --build_tests_only também for especificado) apenas destinos das linguagens especificadas.

Por exemplo,

  % bazel test --test_lang_filters=cc,java foo/...

vai testar apenas os testes C/C++ e Java (definidos usando as regras cc_test e java_test, respectivamente) em foo/..., enquanto

  % bazel test --test_lang_filters=-sh,-java foo/...

vai executar todos os testes em foo/..., exceto sh_test e java_test.

Por padrão, o filtro de idioma de teste não é aplicado.

--test_filter=filter-expression

Especifica um filtro que o executor de testes pode usar para escolher um subconjunto de testes para execução. Todos os destinos especificados na invocação são criados, mas, dependendo da expressão, apenas alguns deles podem ser executados. Em alguns casos, apenas determinados métodos de teste são executados.

A interpretação específica de filter-expression depende do framework de teste responsável por executar o teste. Pode ser um glob, substring ou regexp. --test_filter é uma conveniência em relação à transmissão de diferentes argumentos de filtro --test_arg, mas nem todos os frameworks oferecem suporte a ela.

Verbosidade

Essas opções controlam o nível de detalhes da saída do Bazel para o terminal ou para outros arquivos de registros.

--explain=logfile

Essa opção, que exige um argumento de nome de arquivo, faz com que o verificador de dependências na fase de execução do bazel build explique, para cada etapa de build, por que ela está sendo executada ou que ela está atualizada. A explicação é gravada no logfile.

Se você encontrar recriações inesperadas, essa opção poderá ajudar a entender o motivo. Adicione-o ao .bazelrc para que o registro ocorra em todos os builds subsequentes e inspecione o registro quando uma etapa de execução for executada inesperadamente. Essa opção pode acarretar uma pequena penalidade de desempenho, portanto, convém removê-la quando não for mais necessária.

--verbose_explanations

Essa opção aumenta o nível de detalhes das explicações geradas quando a opção --explain está ativada.

Em particular, se as explicações detalhadas estiverem ativadas e um arquivo de saída for recriado porque o comando usado para criá-lo mudou, a saída no arquivo de explicação vai incluir todos os detalhes do novo comando (pelo menos para a maioria deles).

O uso dessa opção pode aumentar significativamente o tamanho do arquivo de explicação gerado e a penalidade de desempenho do uso de --explain.

Se --explain não estiver ativado, --verbose_explanations não terá efeito.

--profile=file

Essa opção, que usa um argumento de nome de arquivo, faz com que o Bazel grave dados de perfil em um arquivo. Em seguida, os dados podem ser analisados usando o comando bazel analyze-profile. O perfil de build pode ser útil para entender onde o comando build do Bazel está gastando tempo.

--[no]show_loading_progress

Essa opção faz com que o Bazel gere mensagens de progresso de carregamento de pacotes. Se estiver desativado, as mensagens não serão mostradas.

--[no]show_progress

Essa opção faz com que as mensagens de progresso sejam exibidas. Ela fica ativada por padrão. Quando desativado, as mensagens de progresso são suprimidas.

--show_progress_rate_limit=n

Essa opção faz com que o Bazel mostre no máximo uma mensagem de progresso por n segundos, em que n é um número real. O valor padrão dessa opção é 0,02, o que significa que o Bazel limitará as mensagens de progresso a uma a cada 0,02 segundo.

--show_result=n

Essa opção controla a exibição de informações do resultado no final de um comando bazel build. Por padrão, se um único destino de build for especificado, o Bazel vai mostrar uma mensagem informando se o destino foi atualizado ou não. Se sim, a lista de arquivos de saída que o destino criou. Se vários alvos tiverem sido especificados, as informações do resultado não vão aparecer.

Embora as informações do resultado possam ser úteis para builds de um ou poucos destinos, para builds grandes (como uma árvore de projeto de nível superior inteira), essas informações podem ser sobrecarregadas e causar distrações. Essa opção permite que elas sejam controladas. --show_result usa um argumento inteiro, que é o número máximo de destinos para os quais as informações completas do resultado devem ser impressas. Por padrão, o valor é 1. Acima desse limite, nenhuma informação de resultado é mostrada para metas individuais. Assim, o valor zero faz com que as informações do resultado sejam suprimidas sempre, e um valor muito grande faz com que o resultado seja impresso sempre.

Os usuários podem querer escolher um valor intermediário se alternarem regularmente entre a criação de um pequeno grupo de destinos (por exemplo, durante o ciclo de compilação-edição-teste) e um grande grupo de destinos (por exemplo, ao estabelecer um novo espaço de trabalho ou executar testes de regressão). No primeiro caso, as informações do resultado são muito úteis, enquanto no segundo caso elas são menos úteis. Como em todas as opções, isso pode ser especificado implicitamente pelo arquivo .bazelrc.

Os arquivos são impressos para facilitar a cópia e a colagem do nome do arquivo no shell, para executar executáveis criados. As mensagens "atualizada" ou "falhou" para cada destino podem ser facilmente analisadas por scripts que geram um build.

--sandbox_debug

Essa opção faz com que o Bazel imprima informações de depuração extras ao usar o sandbox para execução de ações. Essa opção também preserva os diretórios do sandbox, para que os arquivos visíveis às ações durante a execução possam ser examinados.

--subcommands (-s)

Essa opção faz com que a fase de execução do Bazel imprima a linha de comando completa para cada comando antes da execução.

  >>>>> # //examples/cpp:hello-world [action 'Linking examples/cpp/hello-world']
  (cd /home/johndoe/.cache/bazel/_bazel_johndoe/4c084335afceb392cfbe7c31afee3a9f/bazel && \
    exec env - \
    /usr/bin/gcc -o bazel-out/local-fastbuild/bin/examples/cpp/hello-world -B/usr/bin/ -Wl,-z,relro,-z,now -no-canonical-prefixes -pass-exit-codes -Wl,-S -Wl,@bazel-out/local_linux-fastbuild/bin/examples/cpp/hello-world-2.params)

Sempre que possível, os comandos são impressos em uma sintaxe compatível com o shell Bourne, para que possam ser facilmente copiados e colados em um prompt de comando do shell. Os parênteses ao redor são fornecidos para proteger o shell das chamadas cd e exec. Não se esqueça de copiá-los. No entanto, alguns comandos são implementados internamente no Bazel, como a criação de árvores de links simbólicos. Para esses casos, não há uma linha de comando para exibir.

--subcommands=pretty_print pode ser transmitido para imprimir os argumentos do comando como uma lista em vez de uma única linha. Isso pode ajudar a tornar linhas de comando longas mais legíveis.

Consulte também --verbose_failures abaixo.

Para registrar subcomandos em um arquivo em um formato compatível com ferramentas, consulte --execution_log_json_file e --execution_log_binary_file.

--verbose_failures

Essa opção faz com que a fase de execução do Bazel imprima a linha de comando completa para comandos que falharam. Isso pode ser muito útil para depurar um build com falha.

Os comandos com falha são impressos em uma sintaxe compatível com o shell Bourne, adequada para copiar e colar em um prompt de shell.

Status do espaço de trabalho

Use estas opções para "carimbar" os binários criados pelo Bazel para incorporar mais informações aos binários, como a revisão de controle de origem ou outras informações relacionadas ao espaço de trabalho. É possível usar esse mecanismo com regras que oferecem suporte ao atributo stamp, como genrule, cc_binary e muito mais.

--workspace_status_command=program

Essa flag permite especificar um binário que o Bazel executa antes de cada build. O programa pode informar informações sobre o status do espaço de trabalho, como a revisão atual do controle de origem.

O valor da flag precisa ser um caminho para um programa nativo. No Linux/macOS, pode ser qualquer executável. No Windows, ele precisa ser um binário nativo, normalmente um arquivo ".exe", ".bat" ou ".cmd".

O programa precisa mostrar zero ou mais pares de chave-valor na saída padrão, uma entrada em cada linha e sair com zero (caso contrário, o build falhará). Os nomes das chaves podem ser qualquer coisa, mas só podem usar letras maiúsculas e sublinhados. O primeiro espaço após o nome da chave a separa do valor. O valor é o restante da linha (incluindo espaços em branco adicionais). Nem a chave nem o valor podem abranger várias linhas. As chaves não podem ser duplicadas.

O Bazel particiona as chaves em dois buckets: "stable" e "volatile". Os nomes "stable" e "volatile" são um pouco contra-intuitivos, então não pense muito neles.

O Bazel grava os pares de chave-valor em dois arquivos:

• bazel-out/stable-status.txt contém todas as chaves e valores em que o nome da chave começa com STABLE_
• bazel-out/volatile-status.txt contém o restante das chaves e os valores delas.

O contrato é:

• Os valores das chaves "estáveis" devem mudar raramente, se possível. Se o conteúdo de bazel-out/stable-status.txt mudar, o Bazel invalida as ações que dependem dele. Em outras palavras, se o valor de uma chave estável mudar, o Bazel vai executar novamente as ações carimbadas. Portanto, o status estável não deve conter coisas como carimbos de data/hora, porque eles mudam o tempo todo e fariam com que o Bazel reexecutasse ações marcadas com carimbos em cada build.

  O Bazel sempre gera as seguintes chaves estáveis:

  • BUILD_EMBED_LABEL: valor de --embed_label
  • BUILD_HOST: o nome da máquina host em que o Bazel está sendo executado
  • BUILD_USER: o nome do usuário em que o Bazel está sendo executado.

• Os valores de chaves "voláteis" podem mudar com frequência. O Bazel espera que elas mudem o tempo todo, como os carimbos de data/hora, e atualiza devidamente o arquivo bazel-out/volatile-status.txt. Para evitar uma nova execução de ações estampadas o tempo todo, o Bazel finge que o arquivo volátil nunca muda. Em outras palavras, se o arquivo de status volátil for o único com conteúdo alterado, o Bazel não invalidará as ações que dependem dele. Se outras entradas das ações tiverem sido alteradas, o Bazel executará novamente essa ação e ela verá o status volátil atualizado, mas apenas a alteração do status volátil por si só não invalidará a ação.

  O Bazel sempre gera as seguintes chaves voláteis:

  • BUILD_TIMESTAMP: tempo do build em segundos desde a Era Unix (o valor de System.currentTimeMillis() dividido por mil)

No Linux/macOS, é possível transmitir --workspace_status_command=/bin/true para desativar a recuperação do status do espaço de trabalho, porque true não faz nada, sai com zero e não imprime nenhuma saída. No Windows, você pode transmitir o caminho do true.exe do MSYS para ter o mesmo efeito.

Se o comando de status do espaço de trabalho falhar (sair com um valor diferente de zero) por qualquer motivo, o build vai falhar.

Exemplo de programa no Linux usando o Git:

#!/bin/bash
echo "CURRENT_TIME $(date +%s)"
echo "RANDOM_HASH $(cat /proc/sys/kernel/random/uuid)"
echo "STABLE_GIT_COMMIT $(git rev-parse HEAD)"
echo "STABLE_USER_NAME $USER"

Transmita o caminho do programa com --workspace_status_command, e o arquivo de status estável vai incluir as linhas STABLE, e o arquivo de status volátil vai incluir o restante das linhas.

--[no]stamp

Essa opção, em conjunto com o atributo de regra stamp, controla se as informações de build serão incorporadas em binários.

A marcação pode ser ativada ou desativada explicitamente de acordo com a regra usando o atributo stamp. Consulte a Enciclopédia de Criação para mais detalhes. Quando uma regra define stamp = -1 (padrão para regras *_binary), essa opção determina se o carimbo de data/hora está ativado.

O Bazel nunca carimba binários criados para a configuração do host, independente dessa opção ou do atributo stamp. Para regras que definem stamp = 0 (o padrão para regras *_test), a impressão é desativada, independentemente de --[no]stamp. Especificar --stamp não força a reconstrução de destinos se as dependências não tiverem mudado.

A configuração --nostamp geralmente é desejável para o desempenho do build, porque ela reduz a volatilidade de entrada e maximiza o armazenamento em cache do build.

Plataforma

Use essas opções para controlar as plataformas de host e de destino que configuram o funcionamento das versões e para controlar quais plataformas e conjuntos de ferramentas de execução estão disponíveis para as regras do Bazel.

Consulte as informações de contexto sobre plataformas e conjuntos de ferramentas.

--platforms=labels

Os rótulos das regras da plataforma que descrevem as plataformas de destino do comando atual.

--host_platform=label

O rótulo de uma regra de plataforma que descreve o sistema de host.

--extra_execution_platforms=labels

As plataformas que estão disponíveis como plataformas de execução para executar ações. As plataformas podem ser especificadas por destino exato ou como um padrão de destino. Essas plataformas serão consideradas antes daquelas declaradas no arquivo WORKSPACE por register_execution_platforms().

--extra_toolchains=labels

As regras do conjunto de ferramentas que serão consideradas durante a resolução do conjunto de ferramentas. As cadeias de ferramentas podem ser especificadas por destino exato ou como um padrão de destino. Esses conjuntos de ferramentas serão considerados antes daqueles declarados no arquivo WORKSPACE por register_toolchains().

--toolchain_resolution_debug=regex

Imprime informações de depuração ao encontrar toolchains se o tipo de toolchain corresponder ao regex. Vários regexes podem ser separados por vírgulas. O regex pode ser negado usando um - no início. Isso pode ajudar os desenvolvedores de regras do Bazel ou Starlark com falhas de depuração devido à ausência de conjuntos de ferramentas.

Diversos

--flag_alias=alias_name=target_path

Uma sinalização de conveniência usada para vincular configurações de build mais longas do Starlark a um nome mais curto. Para mais detalhes, consulte as Configurações do Starlark.

--symlink_prefix=string

Muda o prefixo dos links simbólicos de conveniência gerados. O valor padrão para o prefixo de link simbólico é bazel-, que cria os links simbólicos bazel-bin, bazel-testlogs e bazel-genfiles.

Se não for possível criar os links simbólicos, um aviso será emitido, mas o build ainda será considerado bem-sucedido. Em particular, isso permite que você crie em um diretório somente leitura ou em um que você não tem permissão para gravar. Todos os caminhos impressos em mensagens de informações no final de um build só vão usar a forma curta relativa ao link simbólico se os links apontarem para o local esperado. Em outras palavras, você pode confiar na correção desses caminhos, mesmo que não possa confiar nos links simbólicos que estão sendo criados.

Alguns valores comuns dessa opção:

• Suprimir a criação de links simbólicos: --symlink_prefix=/ fará com que o Bazel não crie nem atualize links simbólicos, incluindo os links simbólicos bazel-out e bazel-<workspace>. Use essa opção para impedir totalmente a criação de links simbólicos.

• Reduzir a desordem:--symlink_prefix=.bazel/ faz com que o Bazel crie links simbólicos chamados bin (etc.) em um diretório oculto .bazel.

--platform_suffix=string

Adiciona um sufixo ao nome abreviado da configuração, que é usado para determinar o diretório de saída. A configuração dessa opção com valores diferentes coloca os arquivos em diretórios diferentes, por exemplo, para melhorar as taxas de acerto do cache para builds que, de outra forma, sobrescreveriam os arquivos de saída uns dos outros ou para manter os arquivos de saída para comparações.

--default_visibility=(private|public)

Sinalização temporária para testar as mudanças de visibilidade padrão do Bazel. Não se destina ao uso geral, mas foi documentado para fins de completude.

--[no]use_action_cache

Esta opção é ativada por padrão. Se desativado, o Bazel não vai usar o cache de ação local. Desativar o cache de ações locais economiza memória e espaço em disco para builds limpos, mas deixa os builds incrementais mais lentos.

--starlark_cpu_profile=_file_

Essa flag, cujo valor é o nome de um arquivo, faz com que o Bazel colete estatísticas sobre o uso da CPU por todas as linhas de execução do Starlark e grave o perfil, no formato pprof, no arquivo nomeado.

Use essa opção para ajudar a identificar funções do Starlark que tornam o carregamento e a análise lentos devido ao excesso de computação. Exemplo:

$ bazel build --nobuild --starlark_cpu_profile=/tmp/pprof.gz my/project/...
$ pprof /tmp/pprof.gz
(pprof) top
Type: CPU
Time: Feb 6, 2020 at 12:06pm (PST)
Duration: 5.26s, Total samples = 3.34s (63.55%)
Showing nodes accounting for 3.34s, 100% of 3.34s total
      flat  flat%   sum%        cum   cum%
     1.86s 55.69% 55.69%      1.86s 55.69%  sort_source_files
     1.02s 30.54% 86.23%      1.02s 30.54%  expand_all_combinations
     0.44s 13.17% 99.40%      0.44s 13.17%  range
     0.02s   0.6%   100%      3.34s   100%  sorted
         0     0%   100%      1.38s 41.32%  my/project/main/BUILD
         0     0%   100%      1.96s 58.68%  my/project/library.bzl
         0     0%   100%      3.34s   100%  main

Para visualizações diferentes dos mesmos dados, tente os comandos pprof svg, web e list.

Como usar o Bazel para lançamentos

O Bazel é usado por engenheiros de software durante o ciclo de desenvolvimento e por engenheiros de lançamento ao preparar binários para implantação na produção. Esta seção apresenta uma lista de dicas para engenheiros de lançamento que usam o Bazel.

Opções significativas

Ao usar o Bazel para builds de lançamento, surgem os mesmos problemas que outros scripts que executam uma compilação. Para mais detalhes, consulte Chamar o Bazel de scripts. Especificamente, as seguintes opções são altamente recomendadas:

• --bazelrc=/dev/null
• --nokeep_state_after_build

Estas opções também são importantes:

• --package_path
• --symlink_prefix: para gerenciar builds de várias configurações, pode ser conveniente distinguir cada build com um identificador distinto, como "64 bits" e "32 bits". Essa opção diferencia os links simbólicos de bazel-bin (etc.).

Como executar testes

Para criar e executar testes com o Bazel, digite bazel test seguido do nome dos destinos de teste.

Por padrão, esse comando executa atividades simultâneas de build e teste, compilando todos os destinos especificados (incluindo aqueles que não sejam de teste especificados na linha de comando) e testando os destinos *_test e test_suite assim que os pré-requisitos são criados, o que significa que a execução do teste é intercalada com a criação. Isso geralmente resulta em ganhos de velocidade significativos.

Opções de bazel test

--cache_test_results=(yes|no|auto) (-t)

Se essa opção estiver definida como "auto" (padrão), o Bazel só vai executar novamente um teste se uma das seguintes condições for aplicada:

• O Bazel detecta mudanças no teste ou nas dependências dele.
• o teste é marcado como external
• várias execuções de teste foram solicitadas com --runs_per_test
• o teste falhou.

Se for "não", todos os testes serão executados incondicionalmente.

Se "sim", o comportamento de armazenamento em cache será o mesmo que o automático, exceto que pode armazenar falhas de teste em cache e execuções de teste com --runs_per_test.

Observação: os resultados do teste são sempre salvos na árvore de saída do Bazel, independente de essa opção estar ativada. Portanto, não é necessário ter usado --cache_test_results nas execuções anteriores de bazel test para receber acertos de cache. A opção só afeta se o Bazel vai usar os resultados salvos anteriormente, não se ele vai salvar os resultados da execução atual.

Os usuários que ativaram essa opção por padrão no arquivo .bazelrc podem achar as abreviações -t (ativada) ou -t- (desativada) convenientes para substituir o padrão em uma execução específica.

--check_tests_up_to_date

Essa opção instrui o Bazel a não executar os testes, mas apenas verificar e informar os resultados armazenados em cache. Se houver testes que não foram criados e executados anteriormente ou cujos resultados estão desatualizados (por exemplo, porque o código-fonte ou as opções de build foram alteradas), o Bazel vai informar uma mensagem de erro ("O resultado do teste não está atualizado"), vai registrar o status do teste como "NÃO TEM STATUS" (em vermelho, se a saída em cores estiver ativada) e vai retornar um código de saída diferente de zero.

Essa opção também implica o comportamento [--check_up_to_date](#check-up-to-date).

Essa opção pode ser útil para verificações de pré-envio.

--test_verbose_timeout_warnings

Essa opção informa ao Bazel para avisar explicitamente o usuário se o tempo limite de um teste for significativamente maior do que o tempo de execução real do teste. Embora o tempo limite de um teste precise ser definido para que não seja instável, um teste com um tempo limite muito generoso pode ocultar problemas reais que surgem inesperadamente.

Por exemplo, um teste que normalmente é executado em um ou dois minutos não deve ter um tempo limite de ETERNAL ou LONGO, já que esses valores são muito generosos.

Essa opção é útil para ajudar os usuários a decidir um bom valor de tempo limite ou verificar a sanidade dos valores de tempo limite atuais.

Observação: cada fragmento de teste recebe o tempo limite de todo o destino XX_test. O uso dessa opção não afeta o valor do tempo limite de um teste, apenas avisa se o Bazel achar que o tempo limite pode ser restrito ainda mais.

--[no]test_keep_going

Por padrão, todos os testes são executados até a conclusão. No entanto, se essa sinalização estiver desativada, a versão será cancelada em qualquer teste sem aprovação. As etapas de build subsequentes e as invocações de teste não são executadas, e as invocações em trânsito são canceladas. Não especifique --notest_keep_going e --keep_going.

--flaky_test_attempts=attempts

Essa opção especifica o número máximo de vezes que um teste precisa ser realizado se ele falhar por qualquer motivo. Um teste que falha inicialmente, mas depois é bem-sucedido, é informado como FLAKY no resumo do teste. No entanto, ele é considerado aprovado quando se trata de identificar o código de saída do Bazel ou o número total de testes aprovados. Os testes que falham em todas as tentativas permitidas são considerados como falhas.

Por padrão (quando essa opção não é especificada ou é definida como padrão), apenas uma tentativa é permitida para testes regulares e 3 para regras de teste com o atributo flaky definido. Você pode especificar um valor inteiro para substituir o limite máximo de tentativas de teste. O Bazel permite no máximo 10 tentativas de teste para evitar abusos do sistema.

--runs_per_test=[regex@]number

Essa opção especifica o número de vezes que cada teste precisa ser executado. Todas as execuções de teste são tratadas como testes separados (a funcionalidade de substituição é aplicada a cada uma delas de forma independente).

O status de um destino com execuções com falha depende do valor da flag --runs_per_test_detects_flakes:

• Se estiver ausente, qualquer execução com falha fará com que todo o teste falhe.
• Se estiver presente e duas execuções do mesmo fragmento retornarem PASS e FAIL, o teste receberá o status de instável, a menos que outras execuções com falhas causem a falha.

Se um único número for especificado, todos os testes serão executados na mesma quantidade de vezes. Como alternativa, é possível especificar uma expressão regular usando a sintaxe regex@number. Isso restringe o efeito de --runs_per_test a destinos que correspondem ao regex (--runs_per_test=^//pizza:.*@4 executa todos os testes em //pizza/ 4 vezes). Esse tipo de --runs_per_test pode ser especificado mais de uma vez.

--[no]runs_per_test_detects_flakes

Se essa opção for especificada (não é o padrão), o Bazel vai detectar fragmentos de teste instáveis usando --runs_per_test. Se uma ou mais execuções de um único fragmento falharem e uma ou mais execuções do mesmo fragmento forem bem-sucedidas, o destino será considerado instável com a flag. Se não for especificado, o destino vai informar um status de falha.

--test_summary=output_style

Especifica como o resumo do resultado do teste será exibido.

• short imprime os resultados de cada teste com o nome do arquivo que contém a saída do teste, caso ele tenha falhado. Esse é o valor padrão.
• terse como short, mas ainda mais curto: mostra apenas informações sobre testes que não foram aprovados.
• detailed imprime cada caso de teste individual que falhou, não apenas cada teste. Os nomes dos arquivos de saída de teste são omitidos.
• none não mostra o resumo do teste.

--test_output=output_style

Especifica como a saída do teste será mostrada:

• summary mostra um resumo de se cada teste foi aprovado ou reprovado. Também mostra o nome do arquivo de registro de saída para testes com falha. O resumo será impresso no final do build. Durante o build, você verá apenas mensagens simples de progresso quando os testes começarem, forem aprovados ou reprovados. Esse é o comportamento padrão.
• O errors envia a saída stdout/stderr combinada de testes com falha apenas para o stdout imediatamente após a conclusão do teste, garantindo que a saída de testes simultâneos não seja intercalada entre si. Imprime um resumo no build de acordo com a saída de resumo acima.
• all é semelhante a errors, mas imprime a saída de todos os testes, incluindo aqueles que foram aprovados.
• streamed transmite a saída stdout/stderr de cada teste em tempo real.

--java_debug

Essa opção faz com que a máquina virtual Java de um teste Java espere uma conexão de um depuração compatível com JDWP antes de iniciar o teste. Essa opção implica --test_output=streamed.

--[no]verbose_test_summary

Por padrão, essa opção está ativada, fazendo com que os tempos de teste e outras informações adicionais (como tentativas de teste) sejam impressas no resumo do teste. Se --noverbose_test_summary for especificado, o resumo do teste vai incluir apenas o nome, o status e o indicador do teste em cache, além de ser formatado para ter até 80 caracteres quando possível.

--test_tmpdir=path

Especifica o diretório temporário para testes executados localmente. Cada teste será executado em um subdiretório separado dentro dele. O diretório será limpo no início de cada comando bazel test. Por padrão, o Bazel vai colocar esse diretório no diretório de saída do Bazel.

Observação: este é um diretório para executar testes, não para armazenar resultados de teste (que são sempre armazenados no diretório bazel-out).

--test_timeout=seconds OU --test_timeout=seconds,seconds,seconds,seconds

Substitui o valor do tempo limite de todos os testes usando o número especificado de segundos como um novo valor de tempo limite. Se apenas um valor for fornecido, ele será usado para todas as categorias de tempo limite de teste.

Como alternativa, quatro valores separados por vírgulas podem ser fornecidos, especificando tempos limite individuais para testes curtos, moderados, longos e eternos (nessa ordem). De qualquer forma, zero ou um valor negativo para qualquer um dos tamanhos de teste será substituído pelo tempo limite padrão das categorias de tempo limite fornecidas, conforme definido na página Como gravar testes. Por padrão, o Bazel usa esses tempos limite em todos os testes inferindo o limite do tempo do teste, independentemente de ele ser definido de maneira implícita ou explícita.

Os testes que declaram explicitamente a categoria de tempo limite como distinta do tamanho vão receber o mesmo valor como se esse tempo limite tivesse sido definido implicitamente pela tag de tamanho. Portanto, um teste de tamanho "pequeno" que declara um tempo limite "longo" terá o mesmo tempo limite eficaz que um teste "grande" sem tempo limite explícito.

--test_arg=arg

Transmite opções/flags/argumentos de linha de comando para cada processo de teste. Essa opção pode ser usada várias vezes para transmitir vários argumentos. Por exemplo, --test_arg=--logtostderr --test_arg=--v=3.

--test_env=variable=_value_ OU --test_env=variable

Especifica outras variáveis que precisam ser injetadas no ambiente de teste para cada teste. Se value não for especificado, ele será herdado do ambiente de shell usado para iniciar o comando bazel test.

O ambiente pode ser acessado em um teste usando System.getenv("var") (Java), getenv("var") (C ou C++),

--run_under=command-prefix

Isso especifica um prefixo que o executor de testes vai inserir na frente do comando de teste antes de executá-lo. O command-prefix é dividido em palavras usando as regras de tokenização do shell Bourne, e a lista de palavras é adicionada ao comando que será executado.

Se a primeira palavra for um rótulo totalmente qualificado (começa com //), ele será criado. Em seguida, o rótulo é substituído pelo local executável correspondente que precede o comando que será executado junto com as outras palavras.

Há algumas ressalvas:

• O PATH usado para executar testes pode ser diferente do PATH no seu ambiente. Portanto, talvez seja necessário usar um caminho absoluto para o comando --run_under (a primeira palavra em command-prefix).
• stdin não está conectado, portanto, --run_under não pode ser usado para comandos interativos.

Exemplos:

        --run_under=/usr/bin/strace
        --run_under='/usr/bin/strace -c'
        --run_under=/usr/bin/valgrind
        --run_under='/usr/bin/valgrind --quiet --num-callers=20'

Seleção de teste

Conforme documentado em Opções de seleção de saída, é possível filtrar testes por tamanho, tempo limite, tag ou idioma. Um filtro de nome geral de conveniência pode encaminhar argumentos de filtro específicos para o executor de teste.

Outras opções para bazel test

A sintaxe e as opções restantes são exatamente como bazel build.

Como executar executáveis

O comando bazel run é semelhante ao bazel build, exceto que é usado para criar e executar um único destino. Esta é uma sessão típica:

  % bazel run java/myapp:myapp -- --arg1 --arg2
  Welcome to Bazel
  INFO: Loading package: java/myapp
  INFO: Loading package: foo/bar
  INFO: Loading complete.  Analyzing...
  INFO: Found 1 target...
  ...
  Target //java/myapp:myapp up-to-date:
    bazel-bin/java/myapp:myapp
  INFO: Elapsed time: 0.638s, Critical Path: 0.34s

  INFO: Running command line: bazel-bin/java/myapp:myapp --arg1 --arg2
  Hello there
  $EXEC_ROOT/java/myapp/myapp
  --arg1
  --arg2

Observação: -- é necessário para que o Bazel não interprete --arg1 e --arg2 como opções do Bazel, mas como parte da linha de comando para executar o binário. (O programa em execução simplesmente diz "hello" e mostra os argumentos dele.)

bazel run é semelhante, mas não idêntico, para invocar diretamente o binário criado pelo Bazel, e o comportamento dele é diferente, dependendo se o binário a ser invocado é um teste ou não.

Quando o binário não é um teste, o diretório de trabalho atual é a árvore de runfiles do binário.

Quando o binário é um teste, o diretório de trabalho atual é a raiz de execução e uma tentativa de boa-fé é feita para replicar os testes do ambiente que geralmente são executados. No entanto, a emulação não é perfeita, e testes com vários fragmentos não podem ser executados dessa maneira (a opção de linha de comando --test_sharding_strategy=disabled pode ser usada para contornar esse problema).

As seguintes variáveis de ambiente extras também estão disponíveis para o binário:

• BUILD_WORKSPACE_DIRECTORY: a raiz do espaço de trabalho em que o build foi executado.
• BUILD_WORKING_DIRECTORY: o diretório de trabalho atual em que o Bazel foi executado.

Elas podem ser usadas, por exemplo, para interpretar nomes de arquivos na linha de comando de uma maneira fácil de usar.

Opções de bazel run

--run_under=command-prefix

Isso tem o mesmo efeito que a opção --run_under para bazel test (consulte acima), exceto que se aplica ao comando executado por bazel run em vez dos testes executados por bazel test e não pode ser executado sob o rótulo.

Como filtrar saídas de geração de registros do Bazel

Ao invocar um binário com bazel run, o Bazel imprime a saída de geração de registros do próprio Bazel e do binário na invocação. Para reduzir o ruído nos registros, é possível suprimir as saídas do próprio Bazel com as flags --ui_event_filters e --noshow_progress.

Exemplo: bazel run --ui_event_filters=-info,-stdout,-stderr --noshow_progress //java/myapp:myapp

Como executar testes

O bazel run também pode executar binários de teste, o que tem o efeito de executar o teste em uma aproximação aproximada do ambiente descrito em Como escrever testes. Nenhum dos argumentos --test_* tem efeito ao executar um teste dessa maneira, exceto --test_arg.

Como limpar saídas de build

O comando clean

O Bazel tem um comando clean, análogo ao do Make. Ele exclui os diretórios de saída de todas as configurações de build realizadas por essa instância do Bazel ou toda a árvore de trabalho criada por essa instância do Bazel e redefine os caches internos. Se for executado sem opções de linha de comando, o diretório de saída de todas as configurações será limpo.

Lembre-se de que cada instância do Bazel está associada a um único espaço de trabalho. Portanto, o comando clean excluirá todas as saídas de todas as compilações que você fez com essa instância do Bazel nesse espaço de trabalho.

Para remover completamente toda a árvore de trabalho criada por uma instância do Bazel, especifique a opção --expunge. Quando executado com --expunge, o comando "clean" simplesmente remove toda a árvore de base de saída que, além da saída de build, contém todos os arquivos temporários criados pelo Bazel. Ele também interrompe o servidor do Bazel após a limpeza, o que é equivalente ao comando shutdown. Por exemplo, para limpar todos os rastros de disco e memória de uma instância do Bazel, você pode especificar:

  % bazel clean --expunge

Como alternativa, você pode excluir em segundo plano usando --expunge_async. É seguro invocar um comando do Bazel no mesmo cliente enquanto a exclusão assíncrona continua sendo executada.

Observação: isso pode causar contenção de E/S.

O comando clean é fornecido principalmente como um meio de recuperar espaço em disco para espaços de trabalho que não são mais necessários. As reconstruções incrementais do Bazel podem não ser perfeitas, então clean pode ser usado para recuperar um estado consistente quando surgem problemas.

O design do Bazel permite que esses problemas sejam corrigidos e esses bugs têm alta prioridade para correção. Se você encontrar um build incremental incorreto, envie um relatório de bug e informe bugs nas ferramentas em vez de usar clean.

Como consultar o gráfico de dependências

O Bazel inclui uma linguagem de consulta para fazer perguntas sobre o gráfico de dependências usado durante o build. A linguagem de consulta é usada por dois comandos: query e cquery. A principal diferença entre os dois comandos é que a consulta é executada após a fase de carregamento e a consulta C é executada após a fase de análise. Essas ferramentas são uma ajuda valiosa para muitas tarefas de engenharia de software.

A linguagem de consulta é baseada na ideia de operações algébricas em gráficos e está documentada em detalhes em

Referência de consulta do Bazel. Consulte esse documento para referência, exemplos e opções de linha de comando específicas para consultas.

A ferramenta de consulta aceita várias opções de linha de comando. --output seleciona o formato de saída. --[no]keep_going (desativado por padrão) faz com que a ferramenta de consulta continue progredindo em caso de erros. Esse comportamento pode ser desativado se um resultado incompleto não for aceitável em caso de erros.

A opção --[no]tool_deps, ativada por padrão, faz com que as dependências em configurações não-alvo sejam incluídas no gráfico de dependências em que a consulta opera.

A opção --[no]implicit_deps, ativada por padrão, faz com que as dependências implícitas sejam incluídas no gráfico de dependências em que a consulta opera. Uma dependência implícita não é especificada explicitamente no arquivo BUILD, mas é adicionada pelo Bazel.

Exemplo: "Mostrar os locais das definições (em arquivos BUILD) de todas as regras gerais necessárias para criar todos os testes na árvore PEBL".

  bazel query --output location 'kind(genrule, deps(kind(".*_test rule", foo/bar/pebl/...)))'

Como consultar o gráfico de ações

Atenção: o comando aquery ainda é experimental, e a API dele vai mudar.

O comando aquery permite consultar ações no gráfico de build. Ele opera no gráfico de destino configurado após a análise e expõe informações sobre ações, artefatos e as relações deles.

A ferramenta aceita várias opções de linha de comando. --output seleciona o formato de saída. O formato de saída padrão (text) é legível por humanos. Use proto ou textproto para formato legível por máquina. O comando aquery é executado sobre uma versão comum do Bazel e herda o conjunto de opções disponíveis durante uma compilação.

Ele oferece suporte ao mesmo conjunto de funções que também está disponível para query tradicional, mas siblings, buildfiles e tests.

Para mais detalhes, consulte Consulta de gráfico de ação.

Comandos e opções diversas

help

O comando help oferece ajuda on-line. Por padrão, ele mostra um resumo dos comandos e tópicos de ajuda disponíveis, conforme mostrado em Como criar com o Bazel. Especificar um argumento mostra ajuda detalhada para um tópico específico. A maioria dos tópicos são comandos do Bazel, como build ou query, mas há alguns outros tópicos de ajuda que não correspondem a comandos.

--[no]long (-l)

Por padrão, bazel help [topic] mostra apenas um resumo das opções relevantes para um tópico. Se a opção --long for especificada, o tipo, o valor padrão e a descrição completa de cada opção também serão mostrados.

shutdown

Os processos do servidor do Bazel podem ser interrompidos usando o comando shutdown. Esse comando faz com que o servidor do Bazel saia assim que ficar inativo (por exemplo, após a conclusão de builds ou outros comandos que estão em andamento). Para mais detalhes, consulte Implementação de cliente/servidor.

Os servidores do Bazel param automaticamente após um tempo limite de inatividade. Portanto, esse comando raramente é necessário. No entanto, ele pode ser útil em scripts quando se sabe que nenhum outro build vai ocorrer em um determinado espaço de trabalho.

shutdown aceita uma opção, --iff_heap_size_greater_than _n_, que requer um argumento inteiro (em MB). Se especificado, isso faz com que o desligamento seja condicionado à quantidade de memória já consumida. Isso é útil para scripts que iniciam muitos builds, porque qualquer vazamento de memória no servidor do Bazel pode causar falhas ocasionais. A realização de uma reinicialização condicional evita essa condição.

info

O comando info imprime vários valores associados à instância do servidor do Bazel ou a uma configuração de build específica. Eles podem ser usados por scripts que geram um build.

O comando info também permite um único argumento (opcional), que é o nome de uma das chaves na lista abaixo. Nesse caso, bazel info key vai imprimir apenas o valor dessa chave. Isso é especialmente conveniente ao criar scripts do Bazel, porque evita a necessidade de canalizar o resultado por sed -ne /key:/s/key://p:

Dados independentes da configuração

• release: o rótulo de lançamento para essa instância do Bazel ou "versão de desenvolvimento" se não for um binário lançado.
• workspace é o caminho absoluto para o diretório base do espaço de trabalho.

• install_base: o caminho absoluto para o diretório de instalação usado por essa instância do Bazel para o usuário atual. O Bazel instala os executáveis necessários internamente abaixo desse diretório.

• output_base: o caminho absoluto para o diretório de saída base usado por essa instância do Bazel para a combinação atual de usuário e espaço de trabalho. Ele coloca todo o resto e a saída de build abaixo desse diretório.

• execution_root: o caminho absoluto para o diretório raiz de execução em output_base. Esse diretório é a raiz de todos os arquivos acessíveis aos comandos executados durante o build e é o diretório de trabalho desses comandos. Se o diretório do espaço de trabalho for gravável, um símbolo de link com nome bazel-<workspace> será colocado ali apontando para esse diretório.

• output_path: o caminho absoluto para o diretório de saída abaixo da raiz de execução usado para todos os arquivos realmente gerados como resultado de comandos de build. Se o diretório do espaço de trabalho for gravável, um link simbólico chamado bazel-out será colocado ali apontando para esse diretório.

• server_pid: o ID do processo do servidor do Bazel.

• server_log: o caminho absoluto para o arquivo de registro de depuração do servidor do Bazel. Esse arquivo contém informações de depuração para todos os comandos durante a vida útil do servidor do Bazel e é destinado ao consumo humano por desenvolvedores e usuários avançados do Bazel.

• command_log: o caminho absoluto para o arquivo de registro de comando. Ele contém os fluxos stdout e stderr intercalados do comando Bazel mais recente. Observe que executar bazel info substituirá o conteúdo desse arquivo, já que ele se tornará o comando mais recente do Bazel. No entanto, o local do arquivo de registro de comando não vai mudar, a menos que você mude a configuração das opções --output_base ou --output_user_root.

• used-heap-size, committed-heap-size, max-heap-size: informa vários parâmetros de tamanho de heap da JVM. Respectivamente: memória usada no momento, memória garantida no momento para estar disponível para a JVM no sistema, a alocação máxima possível.

• gc-count, gc-time: a contagem cumulativa de coleções de lixo desde o início deste servidor do Bazel e o tempo gasto para realizá-las. Esses valores não são redefinidos no início de cada build.

• package_path: uma lista separada por dois-pontos de caminhos que seriam pesquisados por pacotes pelo Bazel. Tem o mesmo formato que o argumento de linha de comando de build --package_path.

Exemplo: o ID do processo do servidor do Bazel.

% bazel info server_pid
1285

Dados específicos da configuração

Esses dados podem ser afetados pelas opções de configuração transmitidas para bazel info, por exemplo --cpu, --compilation_mode etc. O comando info aceita todas as opções que controlam a análise de dependência, já que algumas delas determinam a localização do diretório de saída de um build, a escolha do compilador etc.

• bazel-bin, bazel-testlogs e bazel-genfiles: informa o caminho absoluto para os diretórios bazel-* em que os programas gerados pelo build estão localizados. Isso geralmente é igual aos links simbólicos bazel-* criados no diretório do espaço de trabalho de base após uma compilação bem-sucedida. No entanto, se o diretório do espaço de trabalho for somente leitura, nenhum link simbólico bazel-* poderá ser criado. Os scripts que usam o valor informado por bazel info, em vez de presumir a existência do link simbólico, serão mais robustos.
• O ambiente "Make" completo. Se a flag --show_make_env for especificada, todas as variáveis no ambiente "Make" da configuração atual também serão exibidas (como CC, GLIBC_VERSION etc.). Estas são as variáveis acessadas usando a sintaxe $(CC) ou varref("CC") nos arquivos BUILD.

Exemplo: o compilador C++ para a configuração atual. Essa é a variável $(CC) no ambiente "Make", portanto, a flag --show_make_env é necessária.

  % bazel info --show_make_env -c opt COMPILATION_MODE
  opt

Exemplo: o diretório de saída bazel-bin para a configuração atual. Isso é garantido mesmo em casos em que o link simbólico bazel-bin não pode ser criado por algum motivo (por exemplo, se você estiver criando em um diretório somente leitura).

% bazel info --cpu=piii bazel-bin
/var/tmp/_bazel_johndoe/fbd0e8a34f61ce5d491e3da69d959fe6/execroot/io_bazel/bazel-out/piii-opt/bin
% bazel info --cpu=k8 bazel-bin
/var/tmp/_bazel_johndoe/fbd0e8a34f61ce5d491e3da69d959fe6/execroot/io_bazel/bazel-out/k8-opt/bin

version e --version

O comando "version" mostra detalhes sobre a versão do binário do Bazel criado, incluindo a lista de mudanças em que ele foi criado e a data. Elas são particularmente úteis para determinar se você tem a versão mais recente do Bazel ou se está informando bugs. Alguns dos valores interessantes são:

• changelist: a lista de mudanças em que esta versão do Bazel foi lançada.
• label: o rótulo de lançamento dessa instância do Bazel ou "versão de desenvolvimento" se esse não for um binário lançado. Muito útil ao informar bugs.

bazel --version, sem outros argumentos, vai emitir a mesma saída que bazel version --gnu_format, exceto sem o efeito colateral de potencialmente iniciar um servidor do Bazel ou descompactar o arquivo do servidor. O bazel --version pode ser executado de qualquer lugar, sem a necessidade de um diretório de espaço de trabalho.

mobile-install

O comando mobile-install instala apps em dispositivos móveis. No momento, apenas dispositivos Android com o ART são compatíveis.

Consulte bazel mobile-install para mais informações.

Observação: esse comando não instala a mesma coisa que bazel build produz. O Bazel ajusta o app para que ele possa ser criado, instalado e reinstalado rapidamente. No entanto, isso precisa ser transparente para o app.

As seguintes opções são compatíveis:

--incremental

Se definido, o Bazel tenta instalar o app de forma incremental, ou seja, apenas as partes que foram alteradas desde o último build. Isso não pode atualizar recursos referenciados de AndroidManifest.xml, código nativo ou recursos Java (como aqueles referenciados por Class.getResource()). Se essas coisas mudarem, essa opção precisará ser omitida. Contrariando o espírito do Bazel e devido às limitações da plataforma Android, é responsabilidade do usuário saber quando esse comando é bom o suficiente e quando uma instalação completa é necessária.

Se você estiver usando um dispositivo com o Marshmallow ou uma versão mais recente, considere a flag --split_apks.

--split_apks

Define se os APKs divididos devem ser usados para instalar e atualizar o app no dispositivo. Funciona apenas com dispositivos com o Marshmallow ou versões mais recentes. A flag --incremental não é necessária ao usar --split_apks.

--start_app

Inicia o app em um estado limpo após a instalação. É equivalente a --start=COLD.

--debug_app

Espera que o depurador seja anexado antes de iniciar o app em um estado limpo após a instalação. É equivalente a --start=DEBUG.

--start=_start_type_

Como o app deve ser iniciado após a instalação. Os _start_type_s aceitos são:

• NO Não inicia o app. Essa é a configuração padrão.
• COLD Inicia o app em um estado limpo após a instalação.
• WARM Preserva e restaura o estado do aplicativo em instalações incrementais.
• DEBUG Aguarda o depurador antes de iniciar o app em um estado limpo após a instalação.

Observação: se mais de um dos valores --start=_start_type_, --start_app ou --debug_app for definido, o último valor será usado.

--adb=path

Indica o binário adb a ser usado.

O padrão é usar o adb no SDK do Android especificado por --android_sdk.

--adb_arg=serial

Argumentos extras para adb. Eles vêm antes do subcomando na linha de comando e geralmente são usados para especificar em qual dispositivo instalar. Por exemplo, para selecionar o dispositivo ou emulador Android a ser usado:

% bazel mobile-install --adb_arg=-s --adb_arg=deadbeef

invoca adb como

adb -s deadbeef install ...

--incremental_install_verbosity=number

O nível de detalhamento da instalação incremental. Defina como 1 para que os registros de depuração sejam impressos no console.

dump

O comando dump imprime no stdout um despejo do estado interno do servidor do Bazel. Esse comando é destinado principalmente ao uso por desenvolvedores do Bazel. Portanto, a saída desse comando não é especificada e está sujeita a alterações.

Por padrão, o comando apenas imprime uma mensagem de ajuda descrevendo as possíveis opções para despejar áreas específicas do estado do Bazel. Para despejar o estado interno, pelo menos uma das opções precisa ser especificada.

As seguintes opções são compatíveis:

• --action_cache despeja o conteúdo do cache da ação.
• --packages armazena o conteúdo do cache do pacote.
• --skyframe faz o despejo de estado do gráfico de dependências interno do Bazel.
• --rules exibe o resumo da regra para cada regra e classe de aspecto, incluindo contagens e contagens de ações. Isso inclui regras nativas e Starlark. Se o rastreamento de memória estiver ativado, o consumo de memória das regras também será impresso.
• O --skylark_memory gera um arquivo .gz compatível com pprof no caminho especificado. É necessário ativar o rastreamento de memória para que isso funcione.

Monitoramento de memória

Alguns comandos dump exigem o rastreamento de memória. Para ativar isso, é necessário transmitir flags de inicialização para o Bazel:

• --host_jvm_args=-javaagent:$BAZEL/third_party/allocation_instrumenter/java-allocation-instrumenter-3.3.0.jar
• --host_jvm_args=-DRULE_MEMORY_TRACKER=1

O java-agent é verificado no Bazel em third_party/allocation_instrumenter/java-allocation-instrumenter-3.3.0.jar. Portanto, ajuste $BAZEL para onde você mantém o repositório do Bazel.

Continue passando essas opções para o Bazel para cada comando, ou o servidor será reiniciado.

Exemplo:

    % bazel --host_jvm_args=-javaagent:$BAZEL/third_party/allocation_instrumenter/java-allocation-instrumenter-3.3.0.jar \
    --host_jvm_args=-DRULE_MEMORY_TRACKER=1 \
    build --nobuild <targets>

    # Dump rules
    % bazel --host_jvm_args=-javaagent:$BAZEL/third_party/allocation_instrumenter/java-allocation-instrumenter-3.3.0.jar \
    --host_jvm_args=-DRULE_MEMORY_TRACKER=1 \
    dump --rules

    # Dump Starlark heap and analyze it with pprof
    % bazel --host_jvm_args=-javaagent:$BAZEL/third_party/allocation_instrumenter/java-allocation-instrumenter-3.3.0.jar \
    --host_jvm_args=-DRULE_MEMORY_TRACKER=1 \
    dump --skylark_memory=$HOME/prof.gz
    % pprof -flame $HOME/prof.gz

analyze-profile

O comando analyze-profile analisa os dados coletados anteriormente durante o build usando a opção --profile. Ele oferece várias opções para realizar a análise da execução do build ou exportar dados no formato especificado.

As seguintes opções são compatíveis:

• --dump exibe todos os dados coletados em um formato legível por humanos. No entanto, ele ainda não oferece suporte a outros formatos.

Para detalhes sobre o formato e ajuda sobre o uso, consulte Solução de problemas de desempenho com a criação de perfil.

canonicalize-flags

O comando canonicalize-flags, que recebe uma lista de opções para um comando do Bazel e retorna uma lista de opções com o mesmo efeito. A nova lista de opções é canônica. Por exemplo, duas listas de opções com o mesmo efeito são canônicas para a mesma nova lista.

A opção --for_command pode ser usada para selecionar entre diferentes comandos. No momento, apenas build e test são compatíveis. Opções que o comando não oferece causam um erro.

Observação: um pequeno número de opções não pode ser reordenado, porque o Bazel não pode garantir que o efeito seja idêntico. Observe também que esse comando não expande as sinalizações de --config.

Como exemplo:

  % bazel canonicalize-flags -- --config=any_name --test_tag_filters="-lint"
  --config=any_name
  --test_tag_filters=-lint

Opções de inicialização

As opções descritas nesta seção afetam a inicialização da máquina virtual Java usada pelo processo do servidor Bazel e se aplicam a todos os comandos subsequentes processados por esse servidor. Se houver um servidor Bazel já em execução e as opções de inicialização não corresponderem, ele será reiniciado.

Todas as opções descritas nesta seção precisam ser especificadas usando a sintaxe --key=value ou --key value. Além disso, essas opções precisam aparecer antes do nome do comando do Bazel. Use startup --key=value para listar esses arquivos em um arquivo .bazelrc.

--output_base=dir

Essa opção requer um argumento de caminho, que precisa especificar um diretório gravável. O Bazel vai usar esse local para gravar toda a saída. A base de saída também é a chave pela qual o cliente localiza o servidor do Bazel. Ao mudar a base de saída, você muda o servidor que processa o comando.

Por padrão, a base de saída é derivada do nome de login do usuário e do nome do diretório do espaço de trabalho (na verdade, do resumo MD5), então um valor típico tem esta aparência: /var/tmp/google/_bazel_johndoe/d41d8cd98f00b204e9800998ecf8427e.

Observação: o cliente usa a base de saída para encontrar a instância do servidor Bazel. Portanto, se você especificar uma base de saída diferente em um comando Bazel, um servidor diferente será encontrado (ou iniciado) para processar a solicitação. É possível executar dois builds simultâneos no mesmo diretório de espaço de trabalho variando a base de saída.

Exemplo:

 OUTPUT_BASE=/var/tmp/google/_bazel_johndoe/custom_output_base
% bazel --output_base ${OUTPUT_BASE}1 build //foo  &  bazel --output_base ${OUTPUT_BASE}2 build //bar

Nesse comando, os dois comandos do Bazel são executados simultaneamente (por causa do operador & do shell), cada um usando uma instância de servidor do Bazel diferente (devido às diferentes bases de saída). Por outro lado, se a base de saída padrão fosse usada nos dois comandos, as duas solicitações seriam enviadas ao mesmo servidor, que as processaria sequencialmente: primeiro o build //foo, seguido por um build incremental de //bar.

Observação: recomendamos que você não use um NFS ou um sistema de arquivos em rede semelhante para o diretório raiz, porque a latência de acesso mais alta causa builds visivelmente mais lentos.

--output_user_root=dir

Aponta para o diretório raiz onde as bases de saída e instalação são criadas. O diretório não pode existir ou precisa ser de propriedade do usuário que faz a chamada. No passado, era permitido apontar para um diretório compartilhado entre vários usuários, mas isso não é mais permitido. Isso poderá ser permitido quando o problema 11100 for resolvido.

Se a opção --output_base for especificada, ela vai substituir o uso de --output_user_root para calcular a base de saída.

O local da base instalada é calculado com base em --output_user_root, além da identidade MD5 dos binários incorporados do Bazel.

É possível usar a opção --output_user_root para escolher um local de base alternativo para toda a saída do Bazel (base de instalação e base de saída) se houver um local melhor no layout do sistema de arquivos.

Observação: recomendamos que você não use um NFS ou um sistema de arquivos em rede semelhante para o diretório raiz, porque a latência de acesso mais alta causa builds visivelmente mais lentos.

--server_javabase=dir

Especifica a máquina virtual Java em que o Bazel é executado. O valor precisa ser um caminho para o diretório que contém um JDK ou JRE. Não pode ser um rótulo. Essa opção precisa aparecer antes de qualquer comando do Bazel, por exemplo:

  % bazel --server_javabase=/usr/local/buildtools/java/jdk11 build //foo

Essa flag não afeta as JVMs usadas pelos subprocessos do Bazel, como aplicativos, testes, ferramentas etc. Use as opções de build --javabase ou --host_javabase.

Essa flag era chamada de --host_javabase (às vezes chamada de --host_javabase do "lado esquerdo"), mas foi renomeada para evitar confusão com a flag de build --host_javabase (às vezes chamada de --host_javabase do "lado direito").

--host_jvm_args=string

Especifica uma opção de inicialização a ser transmitida para a máquina virtual Java em que o Bazel é executado. Isso pode ser usado para definir o tamanho da pilha, por exemplo:

  % bazel --host_jvm_args="-Xss256K" build //foo

Essa opção pode ser usada várias vezes com argumentos individuais. A configuração dessa flag raramente é necessária. Também é possível transmitir uma lista de strings separada por espaços, cada uma delas será interpretada como um argumento separado da JVM, mas esse recurso será descontinuado em breve.

Isso não afeta nenhuma JVMs usadas por subprocessos do Bazel: aplicativos, testes, ferramentas e assim por diante. Para transmitir opções da JVM a programas Java executáveis, seja por bazel run ou na linha de comando, use o argumento --jvm_flags, que é compatível com todos os programas java_binary e java_test. Como alternativa, para testes, use bazel test --test_arg=--jvm_flags=foo ....

--host_jvm_debug

Essa opção faz com que a máquina virtual Java espere uma conexão de um depurador compatível com JDWP antes de chamar o método principal do Bazel. Ele é destinado principalmente a desenvolvedores do Bazel.

Observação: isso não afeta as JVMs usadas por subprocessos do Bazel: aplicativos, testes, ferramentas etc.

--autodetect_server_javabase

Essa opção faz com que o Bazel procure automaticamente um JDK instalado na inicialização e volte para o JRE instalado se o JRE incorporado não estiver disponível. --explicit_server_javabase pode ser usado para escolher um JRE explícito para executar o Bazel.

--batch

O modo de lote faz com que o Bazel não use o modo cliente/servidor padrão, mas execute um processo Bazel Java para um único comando, que foi usado para semântica mais previsível com relação ao processamento de sinais, controle de trabalhos e herança de variáveis do ambiente, e é necessário para executar o Bazel em uma prisão chroot.

O modo de lote mantém a semântica de filas adequada dentro da mesma output_base. Ou seja, invocações simultâneas serão processadas em ordem, sem sobreposição. Se um modo de lote do Bazel for executado em um cliente com um servidor em execução, ele primeiro encerrará o servidor antes de processar o comando.

O Bazel vai ser executado mais lentamente no modo de lote ou com as alternativas descritas acima. Isso ocorre porque, entre outras coisas, o cache do arquivo de build é residente na memória, portanto, não é preservado entre invocações de lote sequenciais. Portanto, o uso do modo em lote geralmente faz mais sentido nos casos em que o desempenho é menos crítico, como em builds contínuos.

Aviso: --batch é consideravelmente mais lento do que o modo padrão de cliente/servidor. Além disso, ele pode não oferecer suporte a todos os recursos e otimizações que são possíveis com um servidor Bazel persistente. Se você estiver usando --batch para fins de isolamento de build, use a opção de comando --nokeep_state_after_build, que garante que nenhum estado incremental na memória seja mantido entre os builds. Para reiniciar o servidor e a JVM do Bazel após um build, faça isso explicitamente usando o comando "shutdown".

--max_idle_secs=n

Essa opção especifica quanto tempo, em segundos, o processo do servidor do Bazel precisa esperar após a última solicitação do cliente antes de sair. O valor padrão é 10.800 (3 horas). --max_idle_secs=0 faz com que o processo do servidor do Bazel persista indefinidamente.

Observação :essa sinalização só será lida se o Bazel precisar iniciar um novo servidor. Mudar essa opção não faz com que o servidor seja reiniciado.

Essa opção pode ser usada por scripts que invocam o Bazel para garantir que eles não deixem os processos do servidor do Bazel na máquina de um usuário quando não estiverem em execução. Por exemplo, um script de pré-envio pode querer invocar bazel query para garantir que a mudança pendente de um usuário não introduza dependências indesejadas. No entanto, se o usuário não tiver feito um build recente nesse espaço de trabalho, não será desejável que o script de pré-envio inicie um servidor do Bazel apenas para que ele permaneça ocioso pelo resto do dia. Ao especificar um valor pequeno de --max_idle_secs na solicitação de consulta, o script pode garantir que se ele fez com que um novo servidor fosse iniciado, esse servidor será encerrado imediatamente. No entanto, se já havia um servidor em execução, ele continuará em execução até ficar ocioso pelo tempo normal. O timer de inatividade do servidor será redefinido.

--[no]shutdown_on_low_sys_mem

Se estiver ativado e --max_idle_secs estiver definido como uma duração positiva, desligue o servidor de build quando o sistema estiver com pouca memória. Somente no Linux.

Além de executar uma verificação de inatividade correspondente a max_idle_secs, o servidor de build vai começar a monitorar a memória do sistema disponível depois que o servidor ficar inativo por algum tempo. Se a memória do sistema disponível ficar criticamente baixa, o servidor será encerrado.

--[no]block_for_lock

Se ativado, o Bazel vai esperar que outros comandos do Bazel que seguram a trava do servidor sejam concluídos antes de prosseguir. Se desativado, o Bazel vai sair com um erro se não conseguir adquirir a trava imediatamente e prosseguir.

Os desenvolvedores podem usar isso nas verificações de pré-envio para evitar esperas longas causadas por outro comando do Bazel no mesmo cliente.

--io_nice_level=n

Define um nível de 0 a 7 para a programação de E/S de melhor esforço. 0 é a prioridade mais alta, 7 é a mais baixa. O programador antecipado só pode atender até a prioridade 4. Valores negativos são ignorados.

--batch_cpu_scheduling

Use a programação de CPU batch para o Bazel. Essa política é útil para cargas de trabalho não interativas, mas que não querem diminuir o valor de bom. Consulte "man 2 sched_setscheduler". Essa política pode melhorar a interatividade do sistema em detrimento da capacidade de processamento do Bazel.

Opções diversas

--[no]announce_rc

Controla se o Bazel anuncia as opções de comando lidas do arquivo do Bazel na inicialização. (As opções de inicialização são anunciadas incondicionalmente.)

--color (yes|no|auto)

Essa opção determina se o Bazel vai usar cores para destacar a saída na tela.

Se essa opção for definida como yes, a saída de cores será ativada. Se essa opção for definida como auto, o Bazel vai usar a saída em cores somente se a saída estiver sendo enviada para um terminal e a variável de ambiente TERM estiver definida como um valor diferente de dumb, emacs ou xterm-mono. Se essa opção for definida como no, a saída em cores será desativada, independente de a saída ser enviada para um terminal e da configuração da variável de ambiente TERM.

--config=name

Seleciona outra seção de configuração dos arquivos rc. Para o command atual, ele também extrai as opções de command:name, se essa seção existir. Pode ser especificado várias vezes para adicionar flags de várias seções de configuração. As expansões podem se referir a outras definições (por exemplo, podem ser encadeadas).

--curses (yes|no|auto)

Essa opção determina se o Bazel vai usar controles de cursor na saída da tela. Isso resulta em menos dados de rolagem e um fluxo de saída mais compacto e fácil de ler do Bazel. Isso funciona bem com --color.

Se essa opção for definida como yes, o uso dos controles do cursor será ativado. Se essa opção for definida como no, o uso dos controles do cursor será desativado. Se essa opção for definida como auto, o uso dos controles de cursor será ativado nas mesmas condições que para --color=auto.

--[no]show_timestamps

Se especificado, um carimbo de data/hora é adicionado a cada mensagem gerada pelo Bazel, especificando o horário em que a mensagem foi exibida.