Halaman ini diterjemahkan oleh Cloud Translation API.

Aspek

Halaman ini menjelaskan dasar-dasar dan manfaat penggunaan aspek serta memberikan contoh sederhana dan lanjutan.

Aspek memungkinkan penambahan grafik dependensi build dengan informasi dan tindakan tambahan. Beberapa skenario umum terkait kegunaan aspek:

IDE yang mengintegrasikan Bazel dapat menggunakan aspek untuk mengumpulkan informasi tentang project.
Alat pembuatan kode dapat memanfaatkan aspek untuk dijalankan pada inputnya dengan cara agnostik target. Sebagai contoh, file BUILD dapat menentukan hierarki definisi library protobuf, dan aturan khusus bahasa dapat menggunakan aspek untuk melampirkan tindakan yang menghasilkan kode dukungan protobuf untuk bahasa tertentu.

Dasar-dasar aspek

File BUILD memberikan deskripsi kode sumber project: file sumber apa yang merupakan bagian dari project, artefak (target) apa yang harus dibuat dari file tersebut, dependensi antara file tersebut, dll. Bazel menggunakan informasi ini untuk menjalankan build, yaitu, mengetahui kumpulan tindakan yang diperlukan untuk menghasilkan artefak (seperti menjalankan compiler atau penaut) dan mengeksekusi tindakan tersebut. Bazel melakukannya dengan membuat grafik dependensi antar-target dan membuka grafik ini untuk mengumpulkan tindakan tersebut.

Pertimbangkan file BUILD berikut:

java_library(name = 'W', ...)
java_library(name = 'Y', deps = [':W'], ...)
java_library(name = 'Z', deps = [':W'], ...)
java_library(name = 'Q', ...)
java_library(name = 'T', deps = [':Q'], ...)
java_library(name = 'X', deps = [':Y',':Z'], runtime_deps = [':T'], ...)

File BUILD ini menentukan grafik dependensi yang ditampilkan dalam gambar berikut:

Membuat grafik

Gambar 1. Grafik dependensi file BUILD.

Bazel menganalisis grafik dependensi ini dengan memanggil fungsi implementasi aturan terkait (dalam hal ini "java_library") untuk setiap target dalam contoh di atas. Fungsi implementasi aturan menghasilkan tindakan yang membuat artefak, seperti file .jar, dan meneruskan informasi, seperti lokasi dan nama artefak tersebut, ke dependensi balik target tersebut di penyedia.

Aspek mirip dengan aturan karena memiliki fungsi implementasi yang menghasilkan tindakan dan menampilkan penyedia. Namun, kekuatan mereka berasal dari cara pembuatan grafik dependensi. Aspek memiliki implementasi dan daftar semua atribut yang disebarkan. Pertimbangkan aspek A yang menyebarkan di sepanjang atribut bernama "dependensi". Aspek ini dapat diterapkan ke target X, yang menghasilkan node aplikasi aspek A(X). Selama penerapannya, aspek A diterapkan secara rekursif ke semua target yang dirujuk X dalam atribut "dependensi"-nya (semua atribut dalam daftar propagasi A).

Dengan demikian, satu tindakan penerapan aspek A ke target X akan menghasilkan "grafik bayangan" dari grafik dependensi asli target yang ditampilkan dalam gambar berikut:

Membuat Grafik dengan Aspek

Gambar 2. Membuat grafik dengan aspek-aspek.

Satu-satunya tepi yang dibayangi adalah tepi di sepanjang atribut dalam kumpulan propagasi, sehingga tepi runtime_deps tidak dibayangi dalam contoh ini. Fungsi implementasi aspek kemudian dipanggil pada semua node dalam grafik bayangan yang serupa dengan cara implementasi aturan dipanggil pada node grafik asli.

Contoh sederhana

Contoh ini menunjukkan cara mencetak file sumber secara berulang untuk aturan dan semua dependensinya yang memiliki atribut deps. Tutorial ini menunjukkan implementasi aspek, definisi aspek, dan cara memanggil aspek dari command line Bazel.

def _print_aspect_impl(target, ctx):
    # Make sure the rule has a srcs attribute.
    if hasattr(ctx.rule.attr, 'srcs'):
        # Iterate through the files that make up the sources and
        # print their paths.
        for src in ctx.rule.attr.srcs:
            for f in src.files.to_list():
                print(f.path)
    return []

print_aspect = aspect(
    implementation = _print_aspect_impl,
    attr_aspects = ['deps'],
)

Mari kita uraikan contoh menjadi bagian-bagiannya dan periksa masing-masing satu per satu.

Definisi aspek

print_aspect = aspect(
    implementation = _print_aspect_impl,
    attr_aspects = ['deps'],
)

Definisi aspek mirip dengan definisi aturan, dan ditentukan menggunakan fungsi aspect.

Sama seperti aturan, aspek memiliki fungsi implementasi yang dalam hal ini adalah _print_aspect_impl.

attr_aspects adalah daftar atribut aturan yang disebarkan dengan aspek tersebut. Dalam hal ini, aspek akan diterapkan di sepanjang atribut deps aturan tempat aspek tersebut diterapkan.

Argumen umum lainnya untuk attr_aspects adalah ['*'] yang akan menyebarkan aspek ke semua atribut aturan.

Implementasi aspek

def _print_aspect_impl(target, ctx):
    # Make sure the rule has a srcs attribute.
    if hasattr(ctx.rule.attr, 'srcs'):
        # Iterate through the files that make up the sources and
        # print their paths.
        for src in ctx.rule.attr.srcs:
            for f in src.files.to_list():
                print(f.path)
    return []

Fungsi penerapan aspek mirip dengan fungsi penerapan aturan. Metode ini menampilkan penyedia, dapat menghasilkan tindakan, serta menggunakan dua argumen:

target: target tempat aspek diterapkan.
ctx: Objek ctx yang dapat digunakan untuk mengakses atribut dan menghasilkan output dan tindakan.

Fungsi penerapan dapat mengakses atribut aturan target melalui ctx.rule.attr. Bagian ini dapat memeriksa penyedia yang disediakan oleh target tempatnya diterapkan (melalui argumen target).

Aspek diperlukan untuk menampilkan daftar penyedia. Dalam contoh ini, aspek tidak menyediakan apa pun, sehingga menampilkan daftar kosong.

Memanggil aspek menggunakan command line

Cara paling sederhana untuk menerapkan aspek adalah dari command line menggunakan argumen --aspects. Dengan asumsi bahwa aspek di atas ditentukan dalam file bernama print.bzl, ini:

bazel build //MyExample:example --aspects print.bzl%print_aspect

akan menerapkan print_aspect ke target example dan semua aturan target yang dapat diakses secara rekursif melalui atribut deps.

Flag --aspects mengambil satu argumen, yang merupakan spesifikasi aspek dalam format <extension file label>%<aspect top-level name>.

Contoh lanjutan

Contoh berikut menunjukkan penggunaan aspek dari aturan target yang menghitung file dalam target, yang berpotensi memfilternya menurut ekstensi. Contoh ini menunjukkan cara menggunakan penyedia untuk menampilkan nilai, cara menggunakan parameter untuk meneruskan argumen ke dalam implementasi aspek, dan cara memanggil aspek dari aturan.

File file_count.bzl:

FileCountInfo = provider(
    fields = {
        'count' : 'number of files'
    }
)

def _file_count_aspect_impl(target, ctx):
    count = 0
    # Make sure the rule has a srcs attribute.
    if hasattr(ctx.rule.attr, 'srcs'):
        # Iterate through the sources counting files
        for src in ctx.rule.attr.srcs:
            for f in src.files.to_list():
                if ctx.attr.extension == '*' or ctx.attr.extension == f.extension:
                    count = count + 1
    # Get the counts from our dependencies.
    for dep in ctx.rule.attr.deps:
        count = count + dep[FileCountInfo].count
    return [FileCountInfo(count = count)]

file_count_aspect = aspect(
    implementation = _file_count_aspect_impl,
    attr_aspects = ['deps'],
    attrs = {
        'extension' : attr.string(values = ['*', 'h', 'cc']),
    }
)

def _file_count_rule_impl(ctx):
    for dep in ctx.attr.deps:
        print(dep[FileCountInfo].count)

file_count_rule = rule(
    implementation = _file_count_rule_impl,
    attrs = {
        'deps' : attr.label_list(aspects = [file_count_aspect]),
        'extension' : attr.string(default = '*'),
    },
)

File BUILD.bazel:

load('//:file_count.bzl', 'file_count_rule')

cc_library(
    name = 'lib',
    srcs = [
        'lib.h',
        'lib.cc',
    ],
)

cc_binary(
    name = 'app',
    srcs = [
        'app.h',
        'app.cc',
        'main.cc',
    ],
    deps = ['lib'],
)

file_count_rule(
    name = 'file_count',
    deps = ['app'],
    extension = 'h',
)

Definisi aspek

file_count_aspect = aspect(
    implementation = _file_count_aspect_impl,
    attr_aspects = ['deps'],
    attrs = {
        'extension' : attr.string(values = ['*', 'h', 'cc']),
    }
)

Contoh ini menunjukkan cara aspek disebarkan melalui atribut deps.

attrs menentukan serangkaian atribut untuk aspek. Atribut aspek publik menentukan parameter dan hanya dapat berjenis bool, int, atau string. Untuk aspek yang disebarkan oleh aturan, parameter int dan string harus memiliki values yang ditentukan di dalamnya. Contoh ini memiliki parameter bernama extension yang diizinkan memiliki '*', 'h', atau 'cc' sebagai nilai.

Untuk aspek yang disebarkan oleh aturan, parameter value diambil dari aturan yang meminta aspek, menggunakan atribut aturan yang memiliki nama dan jenis yang sama. (lihat definisi file_count_rule).

Untuk aspek command line, nilai parameter dapat diteruskan menggunakan tanda --aspects_parameters. Batasan values parameter int dan string dapat dihilangkan.

Aspek juga diizinkan memiliki atribut pribadi jenis label atau label_list. Atribut label pribadi dapat digunakan untuk menentukan dependensi pada alat atau library yang diperlukan untuk tindakan yang dihasilkan oleh aspek. Tidak ada atribut pribadi yang ditentukan dalam contoh ini, tetapi cuplikan kode berikut menunjukkan cara meneruskan alat ke suatu aspek:

...
    attrs = {
        '_protoc' : attr.label(
            default = Label('//tools:protoc'),
            executable = True,
            cfg = "exec"
        )
    }
...

Implementasi aspek

FileCountInfo = provider(
    fields = {
        'count' : 'number of files'
    }
)

def _file_count_aspect_impl(target, ctx):
    count = 0
    # Make sure the rule has a srcs attribute.
    if hasattr(ctx.rule.attr, 'srcs'):
        # Iterate through the sources counting files
        for src in ctx.rule.attr.srcs:
            for f in src.files.to_list():
                if ctx.attr.extension == '*' or ctx.attr.extension == f.extension:
                    count = count + 1
    # Get the counts from our dependencies.
    for dep in ctx.rule.attr.deps:
        count = count + dep[FileCountInfo].count
    return [FileCountInfo(count = count)]

Sama seperti fungsi implementasi aturan, fungsi implementasi aspek menampilkan struct penyedia yang dapat diakses oleh dependensinya.

Dalam contoh ini, FileCountInfo ditentukan sebagai penyedia yang memiliki satu kolom count. Praktik terbaiknya adalah menentukan kolom penyedia secara eksplisit menggunakan atribut fields.

Kumpulan penyedia untuk aplikasi aspek A(X) adalah gabungan penyedia yang berasal dari penerapan aturan untuk target X dan dari implementasi aspek A. Penyedia yang disebarkan oleh implementasi aturan akan dibuat dan dibekukan sebelum aspek diterapkan dan tidak dapat diubah dari suatu aspek. Akan terjadi error jika target dan aspek yang diterapkan ke sana masing-masing menyediakan penyedia dengan jenis yang sama, kecuali OutputGroupInfo (yang digabungkan, asalkan aturan dan aspek menentukan grup output yang berbeda) dan InstrumentedFilesInfo (yang diambil dari aspek tersebut). Artinya, implementasi aspek mungkin tidak akan pernah menampilkan DefaultInfo.

Parameter dan atribut pribadi diteruskan dalam atribut ctx. Contoh ini merujuk ke parameter extension dan menentukan file yang akan dihitung.

Untuk penyedia yang ditampilkan, nilai atribut bersama tempat aspek disebarkan (dari daftar attr_aspects) akan diganti dengan hasil penerapan aspek tersebut. Misalnya, jika target X memiliki Y dan Z dalam dependensinya, ctx.rule.attr.deps untuk A(X) akan menjadi [A(Y), A(Z)]. Dalam contoh ini, ctx.rule.attr.deps adalah objek Target yang merupakan hasil dari penerapan aspek ke 'dependensi' target asli tempat aspek tersebut diterapkan.

Dalam contoh ini, aspek mengakses penyedia FileCountInfo dari dependensi target untuk mengumpulkan total jumlah transitif file.

Memanggil aspek dari aturan

def _file_count_rule_impl(ctx):
    for dep in ctx.attr.deps:
        print(dep[FileCountInfo].count)

file_count_rule = rule(
    implementation = _file_count_rule_impl,
    attrs = {
        'deps' : attr.label_list(aspects = [file_count_aspect]),
        'extension' : attr.string(default = '*'),
    },
)

Implementasi aturan menunjukkan cara mengakses FileCountInfo melalui ctx.attr.deps.

Definisi aturan menunjukkan cara menentukan parameter (extension) dan memberinya nilai default (*). Perhatikan bahwa memiliki nilai default yang bukan salah satu dari 'cc', 'h', atau '*' akan menyebabkan error karena pembatasan yang ditempatkan pada parameter dalam definisi aspek.

Memanggil aspek melalui aturan target

load('//:file_count.bzl', 'file_count_rule')

cc_binary(
    name = 'app',
...
)

file_count_rule(
    name = 'file_count',
    deps = ['app'],
    extension = 'h',
)

Hal ini menunjukkan cara meneruskan parameter extension ke dalam aspek melalui aturan. Karena parameter extension memiliki nilai default dalam implementasi aturan, extension akan dianggap sebagai parameter opsional.

Saat target file_count di-build, aspek kita akan dievaluasi untuk itu sendiri, dan semua target yang dapat diakses secara rekursif melalui deps.

Referensi

Referensi API aspect