अपने-आप एक्ज़ीक्यूशन ग्रुप (एईजी)

अपने-आप ट्रिगर होने वाले ग्रुप, हर टूलचेन टाइप के लिए एक ट्रिगर करने वाला प्लैटफ़ॉर्म चुनते हैं. दूसरे शब्दों में, एक टारगेट में कई टारगेट ग्रुप तय किए बिना, कई टारगेट प्लैटफ़ॉर्म हो सकते हैं.

खास जानकारी

अपने-आप लागू होने वाले ग्रुप, टूलचेन से जुड़े होते हैं. अगर टूलचेन का इस्तेमाल किया जा रहा है, तो आपको उन ऐक्शन पर toolchain पैरामीटर जोड़कर उन्हें सेट करना होगा जिन पर असर पड़ा है. ये ऐसे ऐक्शन होते हैं जो टूलचेन से किसी प्रोग्राम या टूल का इस्तेमाल करते हैं. उदाहरण के लिए:

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

अगर कार्रवाई में टूलचेन से किसी टूल या एक्सीक्यूटेबल का इस्तेमाल नहीं किया जाता है और Blaze को इसका पता नहीं चलता है (गड़बड़ी का मैसेज दिखता है), तो toolchain = None सेट किया जा सकता है.

अगर आपको एक ही एक्सीक्यूशन प्लैटफ़ॉर्म पर कई टूलचेन का इस्तेमाल करना है (ऐक्शन, दो या उससे ज़्यादा टूलचेन के एक्सीक्यूटेबल या टूल का इस्तेमाल करता है), तो आपको मैन्युअल रूप से exec_groups तय करने होंगे. इसके लिए, मुझे कस्टम exec_group का इस्तेमाल कब करना चाहिए? सेक्शन देखें.

इतिहास

एईजी से पहले, नियम के लेवल पर लागू करने के लिए प्लैटफ़ॉर्म चुना जाता था. उदाहरण के लिए:

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

नियम my_rule, दो तरह के टूलचेन रजिस्टर करता है. इसका मतलब है कि टूलचेन रिज़ॉल्यूशन का इस्तेमाल, ऐसे प्लैटफ़ॉर्म को ढूंढने के लिए किया गया है जो दोनों तरह के टूलचेन के साथ काम करता है. चुने गए ट्रिगर प्लैटफ़ॉर्म का इस्तेमाल, नियम में रजिस्टर की गई हर कार्रवाई के लिए किया जाता है. ऐसा तब तक होता है, जब तक exec_groups के साथ अलग से कुछ नहीं बताया जाता. दूसरे शब्दों में, नियम में मौजूद सभी कार्रवाइयों के लिए एक ही प्लैटफ़ॉर्म का इस्तेमाल किया जाता था. भले ही, वे अलग-अलग टूलचैन से टूल का इस्तेमाल करते हों. हर टारगेट के लिए, प्लैटफ़ॉर्म को चुना जाता है. जब सभी टूलचेन के साथ काम करने वाला कोई रनटाइम प्लैटफ़ॉर्म उपलब्ध नहीं होता था, तो इस वजह से गड़बड़ियां होती थीं.

मौजूदा स्थिति

AEGs की मदद से, हर टूलचेन टाइप के लिए, प्रोग्राम चलाने का प्लैटफ़ॉर्म चुना जाता है. पहले उदाहरण, my_rule के लागू करने वाले फ़ंक्शन का यह दिखेगा:

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',
    )

यह नियम दो कार्रवाइयां बनाता है. First action, //tools:toolchain_type_1 से एक्सीक्यूटेबल का इस्तेमाल करता है और Second action, //tools:toolchain_type_2 से एक्सीक्यूटेबल का इस्तेमाल करता है. AEG से पहले, ये दोनों कार्रवाइयां एक ही प्लैटफ़ॉर्म पर की जाती थीं. यह प्लैटफ़ॉर्म, टूलचेन के दोनों टाइप के साथ काम करता था. AEGs की मदद से, ऐक्शन में toolchain पैरामीटर जोड़कर, हर ऐक्शन उस प्लैटफ़ॉर्म पर लागू होता है जो टूलचेन उपलब्ध कराता है. कार्रवाइयां, अलग-अलग प्लैटफ़ॉर्म पर की जा सकती हैं.

यह ctx.actions.run_shell के साथ भी काम करता है. इसमें toolchain पैरामीटर तब जोड़ा जाना चाहिए, जब tools टूलचेन से हों.

कस्टम एक्सीक्यूशन ग्रुप और ऑटोमैटिक एक्सीक्यूशन ग्रुप के बीच अंतर

जैसा कि नाम से पता चलता है, एईजी ऐसे एक्ज़ीक्यूट ग्रुप होते हैं जो किसी नियम पर रजिस्टर किए गए हर टूलचेन टाइप के लिए अपने-आप बन जाते हैं. "क्लासिक" एक्सेक्यूट ग्रुप के उलट, इन्हें मैन्युअल तरीके से बताने की ज़रूरत नहीं है.

मुझे कस्टम exec_group का इस्तेमाल कब करना चाहिए?

कस्टम exec_groups की ज़रूरत सिर्फ़ तब होती है, जब एक से ज़्यादा टूलचेन को एक ही प्लैटफ़ॉर्म पर चलाना हो. बाकी सभी मामलों में, कस्टम exec_groups तय करने की ज़रूरत नहीं होती. उदाहरण के लिए:

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'],
        ),
    }
)

एईजी का माइग्रेशन

Google3 में, Blaze पहले से ही AEG का इस्तेमाल कर रहा है. Bazel के लिए, बाहरी तौर पर माइग्रेशन की प्रोसेस जारी है. कुछ नियम पहले से ही इस सुविधा का इस्तेमाल कर रहे हैं. जैसे, Java और C++ नियम.

Bazel के कौनसे वर्शन इस माइग्रेशन के साथ काम करते हैं?

AEG, Bazel 7 के साथ पूरी तरह से काम करते हैं.

एईजी को कैसे चालू करें?

--incompatible_auto_exec_groups को 'सही' पर सेट करें. GitHub की समस्या पर फ़्लैग के बारे में ज़्यादा जानकारी.

किसी खास नियम में एईजी को कैसे चालू करें?

किसी नियम पर _use_auto_exec_groups एट्रिब्यूट सेट करें.

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

इससे, my_rule में ही AEG चालू होते हैं और कार्रवाइयां, प्लैटफ़ॉर्म चुनते समय नए लॉजिक का इस्तेमाल करना शुरू कर देती हैं. इस एट्रिब्यूट की मदद से, 'काम नहीं करता' फ़्लैग को बदल दिया जाता है.

गड़बड़ी होने पर, AEG को कैसे बंद करें?

अपने प्रोजेक्ट में एईजी को पूरी तरह से बंद करने के लिए, --incompatible_auto_exec_groups को 'गलत' पर सेट करें (फ़्लैग की GitHub समस्या). इसके अलावा, _use_auto_exec_groups एट्रिब्यूट को False पर सेट करके, किसी खास नियम को बंद किया जा सकता है (एट्रिब्यूट के बारे में ज़्यादा जानकारी).

एईजी पर माइग्रेट करते समय गड़बड़ी के मैसेज

यह पता नहीं चल सका कि टूल, इंप्लिसिट डिपेंडेंसी या टूलचेन से हैं या नहीं. कृपया टूलचैन पैरामीटर सेट करें. अगर टूलचेन का इस्तेमाल नहीं किया जा रहा है, तो इसे 'कोई नहीं' पर सेट करें.

• इस मामले में, गड़बड़ी होने से पहले आपको कॉल का स्टैक दिखता है. साथ ही, यह साफ़ तौर पर देखा जा सकता है कि किस कार्रवाई के लिए टूलचेन पैरामीटर की ज़रूरत है. देखें कि कार्रवाई के लिए किस टूलचेन का इस्तेमाल किया जाता है और उसे टूलचेन पैरामीटर के साथ सेट करें. अगर टूल या एक्सीक्यूटेबल के लिए, कार्रवाई में किसी टूलचेन का इस्तेमाल नहीं किया गया है, तो इसे None पर सेट करें.

ऐसी टूलचेन '[toolchain_type]' के लिए कार्रवाई की गई है जो मौजूद नहीं है.

• इसका मतलब है कि आपने ऐक्शन पर टूलचेन पैरामीटर सेट किया है, लेकिन उसे नियम पर रजिस्टर नहीं किया है. टूलचेन को रजिस्टर करें या कार्रवाई में None सेट करें.

अन्य कॉन्टेंट

ज़्यादा जानकारी के लिए, डिज़ाइन दस्तावेज़ देखें: टूलचेन के लिए, अपने-आप काम करने वाले ग्रुप.