Grup Eksekusi Otomatis (AEG)

Grup eksekusi otomatis memilih platform eksekusi untuk setiap jenis rantai alat. Dengan kata lain, satu target dapat memiliki beberapa platform eksekusi tanpa menentukan grup eksekusi.

Ringkasan singkat

Grup eksekusi otomatis terhubung erat dengan rantai alat. Jika menggunakan rantai alat, Anda harus menyetelnya pada tindakan yang terpengaruh (tindakan yang menggunakan executable atau alat dari rantai alat) dengan menambahkan parameter toolchain. Contoh:

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

Jika tindakan tidak menggunakan alat atau executable dari rantai alat, dan Blaze tidak mendeteksinya (error ditampilkan), Anda dapat menetapkan toolchain = None.

Jika perlu menggunakan beberapa rantai alat pada satu platform eksekusi (tindakan menggunakan executable atau alat dari dua rantai alat atau lebih), Anda harus menentukan exec_groups secara manual (lihat bagian Kapan saya harus menggunakan exec_group kustom? ).

Histori

Sebelum AEG, platform eksekusi dipilih di tingkat aturan. Contoh:

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

Aturan my_rule mendaftarkan dua jenis rantai alat. Artinya, Resolusi Rantai Alat digunakan untuk menemukan platform eksekusi yang mendukung kedua jenis rantai alat. Platform eksekusi yang dipilih digunakan untuk setiap tindakan terdaftar di dalam aturan, kecuali jika ditentukan secara berbeda dengan exec_groups. Dengan kata lain, semua tindakan di dalam aturan menggunakan satu platform eksekusi meskipun menggunakan alat dari rantai alat yang berbeda (platform eksekusi dipilih untuk setiap target). Hal ini menyebabkan kegagalan jika tidak ada platform eksekusi yang mendukung semua rantai alat.

Status saat ini

Dengan AEG, platform eksekusi dipilih untuk setiap jenis rantai alat. Fungsi implementasi contoh sebelumnya, my_rule, akan terlihat seperti ini:

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

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

Aturan ini membuat dua tindakan, First action yang menggunakan executable dari //tools:toolchain_type_1 dan Second action yang menggunakan executable dari //tools:toolchain_type_2. Sebelum AEG, kedua tindakan ini akan dieksekusi pada satu platform eksekusi yang mendukung kedua jenis rantai alat. Dengan AEG, dengan menambahkan parameter toolchain di dalam tindakan, setiap tindakan akan dieksekusi di platform eksekusi yang menyediakan rantai alat. Tindakan dapat dieksekusi di platform eksekusi yang berbeda.

Hal yang sama berlaku untuk ctx.actions.run_shell dengan toolchain parameter yang harus ditambahkan jika tools berasal dari rantai alat.

Perbedaan antara grup exec kustom dan grup exec otomatis

Seperti namanya, AEG adalah grup exec yang dibuat secara otomatis untuk setiap jenis rantai alat yang terdaftar pada aturan. Anda tidak perlu menentukannya secara manual, tidak seperti grup exec "klasik".

Kapan saya harus menggunakan exec_group kustom?

exec_group kustom hanya diperlukan jika beberapa rantai alat perlu dieksekusi pada satu platform eksekusi. Dalam kasus lain, Anda tidak perlu menentukan exec_group kustom. Contoh:

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

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

Migrasi AEG

Secara internal di google3, Blaze sudah menggunakan AEG. Secara eksternal untuk Bazel, migrasi sedang dalam proses. Beberapa aturan sudah menggunakan fitur ini (misalnya, aturan Java dan C++).

Versi Bazel mana yang mendukung migrasi ini?

AEG didukung sepenuhnya dari Bazel 7.

Bagaimana cara mengaktifkan AEG?

Tetapkan --incompatible_auto_exec_groups ke true. Informasi selengkapnya tentang flag di masalah GitHub.

Bagaimana cara mengaktifkan AEG di dalam aturan tertentu?

Tetapkan atribut _use_auto_exec_groups pada aturan.

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

Tindakan ini hanya mengaktifkan AEG di my_rule dan tindakannya mulai menggunakan logika baru saat memilih platform eksekusi. Flag yang tidak kompatibel akan diganti dengan atribut ini.

Bagaimana cara menonaktifkan AEG jika terjadi error?

Tetapkan --incompatible_auto_exec_groups ke false untuk menonaktifkan AEG sepenuhnya di project Anda (masalah GitHub flag), atau nonaktifkan aturan tertentu dengan menetapkan atribut _use_auto_exec_groups ke False (detail selengkapnya tentang atribut).

Pesan error saat bermigrasi ke AEG

Tidak dapat mengidentifikasi apakah alat berasal dari dependensi implisit atau rantai alat. Tetapkan parameter rantai alat. Jika Anda tidak menggunakan rantai alat, tetapkan ke 'None'.

• Dalam hal ini, Anda akan mendapatkan tumpukan panggilan sebelum error terjadi dan Anda dapat melihat dengan jelas tindakan mana yang memerlukan parameter rantai alat. Periksa rantai alat yang digunakan untuk tindakan tersebut dan tetapkan dengan parameter rantai alat. Jika tidak ada rantai alat yang digunakan di dalam tindakan untuk alat atau executable, tetapkan ke None.

Tindakan yang dideklarasikan untuk rantai alat '[toolchain_type]' yang tidak ada.

• Artinya, Anda telah menetapkan parameter rantai alat pada tindakan, tetapi tidak mendaftarkannya pada aturan. Daftarkan rantai alat atau tetapkan None di dalam tindakan.

Materi tambahan

Untuk mengetahui informasi selengkapnya, lihat dokumen desain: Grup exec otomatis untuk rantai alat.