मॉड्यूल एक्सटेंशन की मदद से लोग, इनपुट डेटा पढ़कर मॉड्यूल सिस्टम को बढ़ा सकते हैं डिपेंडेंसी ग्राफ़ के मॉड्यूल से, समाधान के लिए ज़रूरी लॉजिक परफ़ॉर्म किया जा रहा है डिपेंडेंसी और आखिर में रेपो नियमों को कॉल करके रेपो बनाना. ये एक्सटेंशन इसमें रेपो नियमों से मिलती-जुलती सुविधाएं हैं. इससे उन्हें फ़ाइल I/O चलाने का विकल्प मिलता है, नेटवर्क अनुरोध भेजने की अनुमति देता है. इसके अलावा, इनकी मदद से बेज़ल ये काम भी कर पाते हैं अन्य पैकेज मैनेजमेंट सिस्टम के साथ इंटरैक्ट करते हैं. साथ ही, Basel मॉड्यूल से बनाया गया डिपेंडेंसी ग्राफ़.
रेपो नियमों की तरह ही, .bzl फ़ाइलों में मॉड्यूल एक्सटेंशन तय किए जा सकते हैं. वे खास हैं
सीधे तौर पर इस्तेमाल नहीं किया गया हो; इसके बजाय, हर मॉड्यूल टैग नाम के डेटा के हिस्सों को तय करता है
का भी इस्तेमाल किया जा सकता है. किसी भी टेस्ट का आकलन करने से पहले, Baze मॉड्यूल का रिज़ॉल्यूशन इस्तेमाल करता है
एक्सटेंशन. एक्सटेंशन, इससे जुड़े सभी टैग को पूरे डेटा में पढ़ता है
डिपेंडेंसी ग्राफ़.
एक्सटेंशन का इस्तेमाल
एक्सटेंशन, Basel मॉड्यूल में खुद होस्ट किए जाते हैं. किसी एक्सटेंशन का इस्तेमाल
मॉड्यूल से, पहले एक्सटेंशन को होस्ट करने वाले मॉड्यूल में bazel_dep जोड़ें और फिर
use_extension पहले से मौजूद फ़ंक्शन को कॉल करें
उसे दायरे में लाने के लिए किया जा सकता है. नीचे दिए गए उदाहरण पर विचार करें — एक स्निपेट
"maven" का इस्तेमाल करने के लिए MODULE.bazel फ़ाइल
rules_jvm_external
मॉड्यूल:
bazel_dep(name = "rules_jvm_external", version = "4.5")
maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
यह use_extension की रिटर्न वैल्यू को वैरिएबल से बाइंड करता है. इससे,
उपयोगकर्ता को डॉट-सिंटैक्स का उपयोग करके एक्सटेंशन के टैग दर्ज करना होगा. टैग, तय किए गए समय के मुताबिक होने चाहिए
इससे जुड़ी टैग क्लास के ज़रिए तय किया गया स्कीमा
एक्सटेंशन की परिभाषा. उदाहरण के लिए, कुछ
maven.install और maven.artifact टैग:
maven.install(artifacts = ["org.junit:junit:4.13.2"])
maven.artifact(group = "com.google.guava",
artifact = "guava",
version = "27.0-jre",
exclusions = ["com.google.j2objc:j2objc-annotations"])
डेटा स्टोर करने की जगह लाने के लिए use_repo डायरेक्टिव का इस्तेमाल करें
को मौजूदा मॉड्यूल के स्कोप में एक्सटेंशन से जनरेट किया जाता है.
use_repo(maven, "maven")
किसी एक्सटेंशन के ज़रिए जनरेट किए गए डेटा स्टोर करने की जगह, इसके एपीआई का हिस्सा होती है. इस उदाहरण में,
"मावेन" मॉड्यूल एक्सटेंशन, maven नाम का रेपो जनरेट करने का वादा करता है.
ऊपर दी गई घोषणा के अनुसार, एक्सटेंशन लेबलों, जैसे कि
"maven" के जनरेट किए गए रेपो पर ले जाने के लिए @maven//:org_junit_junit
एक्सटेंशन चुनें.
एक्सटेंशन की परिभाषा
रेपो नियमों की तरह ही, मॉड्यूल एक्सटेंशन को परिभाषित किया जा सकता है. इसके लिए,
module_extension फ़ंक्शन का इस्तेमाल करें. हालांकि,
रेपो नियमों में कई एट्रिब्यूट होते हैं, जबकि मॉड्यूल एक्सटेंशन में
tag_class हैं, जिनमें से हर एक में
एट्रिब्यूट की वैल्यू सबमिट करें. टैग क्लास, इस एक्सटेंशन में इस्तेमाल किए जाने वाले टैग के लिए स्कीमा तय करती हैं. इसके लिए
उदाहरण के लिए, "maven" ऊपर दिए गए एक्सटेंशन को इस तरह परिभाषित किया जा सकता है:
# @rules_jvm_external//:extensions.bzl
_install = tag_class(attrs = {"artifacts": attr.string_list(), ...})
_artifact = tag_class(attrs = {"group": attr.string(), "artifact": attr.string(), ...})
maven = module_extension(
implementation = _maven_impl,
tag_classes = {"install": _install, "artifact": _artifact},
)
इन एलानों से पता चलता है कि maven.install और maven.artifact टैग
एट्रिब्यूट स्कीमा का इस्तेमाल करके तय किया गया है.
मॉड्यूल एक्सटेंशन को लागू करने का फ़ंक्शन, रेपो एक्सटेंशन से मिलता-जुलता है
इसके अलावा, उन्हें एक module_ctx ऑब्जेक्ट मिलता है,
जो एक्सटेंशन और सभी काम के टैग का इस्तेमाल करने वाले सभी मॉड्यूल को ऐक्सेस करने की अनुमति देता है.
इसके बाद, लागू करने वाला फ़ंक्शन, रेपो जनरेट करने के लिए रेपो नियमों को कॉल करता है.
# @rules_jvm_external//:extensions.bzl
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_file") # a repo rule
def _maven_impl(ctx):
# This is a fake implementation for demonstration purposes only
# collect artifacts from across the dependency graph
artifacts = []
for mod in ctx.modules:
for install in mod.tags.install:
artifacts += install.artifacts
artifacts += [_to_artifact(artifact) for artifact in mod.tags.artifact]
# call out to the coursier CLI tool to resolve dependencies
output = ctx.execute(["coursier", "resolve", artifacts])
repo_attrs = _process_coursier_output(output)
# call repo rules to generate repos
for attrs in repo_attrs:
http_file(**attrs)
_generate_hub_repo(name = "maven", repo_attrs)
एक्सटेंशन आइडेंटिटी
मॉड्यूल एक्सटेंशन की पहचान, ऐप्लिकेशन के नाम और दिखने वाली .bzl फ़ाइल से की जाती है
use_extension को किए गए कॉल में. नीचे दिए गए उदाहरण में, एक्सटेंशन maven
की पहचान .bzl फ़ाइल @rules_jvm_external//:extension.bzl और
नाम maven:
maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
किसी एक्सटेंशन को किसी दूसरी .bzl फ़ाइल से दोबारा एक्सपोर्ट करने पर, उसे एक नई पहचान मिलती है
और अगर एक्सटेंशन के दोनों वर्शन का इस्तेमाल ट्रांज़िटिव मॉड्यूल ग्राफ़ में किया जाता है, तो
तो उनका अलग से मूल्यांकन किया जाएगा और आपको सिर्फ़ उनसे जुड़े टैग दिखेंगे
उस पहचान से जुड़ा हो.
एक्सटेंशन लेखक के रूप में आपको यह पक्का करना चाहिए कि उपयोगकर्ता सिर्फ़ आपके
एक .bzl फ़ाइल से मॉड्यूल एक्सटेंशन.
डेटा स्टोर करने की जगहों के नाम और उनके दिखने की सेटिंग
एक्सटेंशन के ज़रिए जनरेट किए गए डेटा संग्रह में module_repo_canonical_name~extension_name~repo_name के तौर पर कैननिकल नाम होते हैं. इसमें होस्ट किए गए एक्सटेंशन के लिए
रूट मॉड्यूल में module_repo_canonical_name हिस्सा है
स्ट्रिंग को _main से बदला गया. ध्यान दें कि कैननिकल नाम का फ़ॉर्मैट
आपको इस एपीआई का इस्तेमाल करना चाहिए. इसमें किसी भी समय बदलाव हो सकता है.
नाम रखने की इस नीति का मतलब है कि हर एक्सटेंशन का अपना "रेपो नेमस्पेस" है; दो
अलग-अलग एक्सटेंशन जोखिम के बिना, एक ही नाम वाले रेपो को तय कर सकते हैं
लड़ाई में किसी भी तरह की समस्या का सामना नहीं करना पड़ेगा. इसका मतलब यह भी है कि repository_ctx.name, कैननिकल नाम की जानकारी देता है
होता है, जो रेपो नियम में बताए गए नाम से मिलता-जुलता नहीं है
कॉल.
मॉड्यूल एक्सटेंशन की मदद से जनरेट किए गए रेपो को ध्यान में रखते हुए, रेपो की जानकारी दिखाने से जुड़े कई नियम:
- बेज़ेल मॉड्यूल रेपो की मदद से, अपनी
MODULE.bazelफ़ाइल में पेश किए गए सभी रेपो देखे जा सकते हैंbazel_depसे औरuse_repo. - मॉड्यूल एक्सटेंशन के ज़रिए जनरेट किए गए रेपो,
मॉड्यूल जो एक्सटेंशन होस्ट करता है, और इसके ज़रिए जनरेट किए गए अन्य सभी डेटा संग्रह स्थान
एक ही मॉड्यूल एक्सटेंशन (रेपो नियम कॉल में बताए गए नामों का इस्तेमाल करके
असली उपयोगकर्ताओं के नाम.
- इसकी वजह से विवाद हो सकता है. अगर मॉड्यूल रेपो को
दिखाई देता है
foo, और एक्सटेंशन नामfoo, फिर उस एक्सटेंशन के ज़रिए जनरेट किए गए सभी डेटा संग्रह स्थान के लिएfooपिछले वाले के बारे में बताता है.
- इसकी वजह से विवाद हो सकता है. अगर मॉड्यूल रेपो को
दिखाई देता है
सबसे सही तरीके
इस सेक्शन में एक्सटेंशन लिखने के सबसे सही तरीकों के बारे में बताया गया है, ताकि वे ये इस्तेमाल में आसान और आसान होते हैं. साथ ही, समय के साथ होने वाले बदलावों के हिसाब से ढल जाते हैं.
हर एक्सटेंशन को एक अलग फ़ाइल में रखें
जब एक्सटेंशन किसी अलग फ़ाइल में होते हैं, तो यह एक एक्सटेंशन को लोड करने की अनुमति देता है डेटा स्टोर करने की जगहों की जानकारी, किसी दूसरे एक्सटेंशन के ज़रिए जनरेट की गई. भले ही आप इसका उपयोग काम है, तो ज़रूरत पड़ने पर उन्हें अलग-अलग फ़ाइलों में रखना सबसे अच्छा होगा बाद में. ऐसा इसलिए है क्योंकि एक्सटेंशन की पहचान उसकी फ़ाइल पर आधारित होती है, इसलिए किसी अन्य फ़ाइल का एक्सटेंशन बाद में आपके सार्वजनिक API को बदल देता है और वह पीछे की ओर आपके उपयोगकर्ताओं के लिए असंगत परिवर्तन.
ऑपरेटिंग सिस्टम और आर्किटेक्चर की जानकारी दें
अगर आपका एक्सटेंशन, ऑपरेटिंग सिस्टम या उसके आर्किटेक्चर टाइप पर निर्भर है, तो
os_dependent का इस्तेमाल करके, एक्सटेंशन की परिभाषा में इसे दिखाना न भूलें
और arch_dependent बूलियन एट्रिब्यूट. इससे यह पक्का होता है कि Baज़र,
अगर इनमें से किसी में भी बदलाव होता है, तो फिर से आकलन करने की ज़रूरत होगी.
डेटा स्टोर करने की जगह के नामों पर, सिर्फ़ रूट मॉड्यूल का सीधे तौर पर असर होना चाहिए
याद रखें कि जब कोई एक्सटेंशन डेटा संग्रह स्थान बनाता है, तो वे
एक्सटेंशन का नेमस्पेस. इसका मतलब है कि टकराव पैदा हो सकते हैं, अगर वे
मॉड्यूल एक ही एक्सटेंशन का इस्तेमाल करते हैं और उसी के साथ रिपॉज़िटरी बना देते हैं
नाम. यह अक्सर मॉड्यूल एक्सटेंशन के tag_class के रूप में दिखता है, जिसमें name होता है
इस आर्ग्युमेंट को रिपॉज़िटरी नियम की name वैल्यू के तौर पर पास किया जाता है.
उदाहरण के लिए, मान लें कि रूट मॉड्यूल, A, B मॉड्यूल पर निर्भर करता है. दोनों मॉड्यूल
मॉड्यूल mylang पर निर्भर करता है. अगर A और B, दोनों कॉल करते हैं
mylang.toolchain(name="foo"), वे दोनों नाम का डेटा स्टोर करने की जगह बनाने की कोशिश करेंगे
foo मॉड्यूल में mylang होने पर कोई गड़बड़ी मिलेगी.
इससे बचने के लिए, डेटा स्टोर करने की जगह का नाम सीधे सेट करने की सुविधा हटाएं, या सिर्फ़ रूट मॉड्यूल को ऐसा करने की अनुमति दें. रूट मॉड्यूल को अनुमति देने में कोई समस्या नहीं है क्षमता है क्योंकि कुछ भी उस पर निर्भर नहीं होगा, इसलिए उसे चिंता करने की ज़रूरत नहीं है एक विरोधी नाम बनाने के बाद एक अन्य मॉड्यूल.