बिल्ड इवेंट प्रोटोकॉल के उदाहरण

बिल्ड इवेंट प्रोटोकॉल की पूरी जानकारी उसके प्रोटोकॉल में देखी जा सकती है बफ़र की परिभाषा. हालांकि, अपने-आप में थोड़ी बहुत सी सोच पैदा करने से मदद मिल सकती है देखें.

ऐसा सामान्य बेज़ल फ़ाइल फ़ोल्डर बनाएं जिसमें दो खाली शेल स्क्रिप्ट हों foo.sh और foo_test.sh और इस BUILD फ़ाइल:

sh_library(
    name = "foo_lib",
    srcs = ["foo.sh"],
)

sh_test(
    name = "foo_test",
    srcs = ["foo_test.sh"],
    deps = [":foo_lib"],
)

इस प्रोजेक्ट पर bazel test ... चलाने पर, जनरेट किए गए प्रोजेक्ट का बिल्ड ग्राफ़ बिल्ड इवेंट नीचे दिए गए ग्राफ़ के जैसे दिखेंगे. ऐरो दिखाते हैं कि माता-पिता और बच्चे के संबंध के बारे में ऊपर बताया गया है. ध्यान दें कि कुछ बिल्ड इवेंट और कम शब्दों में जानकारी देने के लिए, ज़्यादातर फ़ील्ड को हटा दिया गया है.

पहला डायग्राम. बीईपी ग्राफ़.

शुरुआत में, एक BuildStarted इवेंट पब्लिश होता है. इस इवेंट से हमें पता चलता है कि बिल्ड को bazel test कमांड से शुरू किया गया और यह चाइल्ड इवेंट की जानकारी देता है:

• OptionsParsed
• WorkspaceStatus
• CommandLine
• UnstructuredCommandLine
• BuildMetadata
• BuildFinished
• PatternExpanded
• Progress

पहले तीन इवेंट से यह जानकारी मिलती है कि बेज़ल को कैसे शुरू किया गया था.

PatternExpanded बिल्ड इवेंट से अहम जानकारी मिलती है इन चुनिंदा टारगेट में ... पैटर्न का इस्तेमाल करके: //foo:foo_lib और //foo:foo_test. ऐसा दो बच्चों के तौर पर TargetConfigured इवेंट. ध्यान दें कि TargetConfigured इवेंट यह Configuration इवेंट को चाइल्ड इवेंट के तौर पर दिखाता है, भले ही Configuration को TargetConfigured इवेंट से पहले पोस्ट किया गया.

माता-पिता और बच्चे के संबंध के अलावा, इवेंट एक-दूसरे को भी रेफ़र कर सकते हैं बिल्ड इवेंट आइडेंटिफ़ायर का इस्तेमाल करके. उदाहरण के लिए, ऊपर दिए गए ग्राफ़ में, TargetComplete इवेंट का मतलब NamedSetOfFiles इवेंट से है, जो fileSets में है फ़ील्ड में डालें.

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

यहां //foo:foo_lib के लिए, TargetComplete इवेंट का एक उदाहरण दिया गया है ऊपर दिए गए ग्राफ़ में दिया गया टारगेट, प्रोटोकॉल बफ़र के JSON में प्रिंट किया हुआ. बिल्ड इवेंट आइडेंटिफ़ायर में टारगेट, एक ओपेक स्ट्रिंग के तौर पर शामिल होता है और यह Configuration इवेंट, अपने बिल्ड इवेंट आइडेंटिफ़ायर का इस्तेमाल करके. इवेंट ऐसा नहीं करता बच्चों के किसी भी इवेंट के बारे में एलान कर सकती हैं. पेलोड में यह जानकारी होती है कि टारगेट, आउटपुट फ़ाइलों का सेट, और टारगेट के टाइप को बनाया.

{
  "id": {
    "targetCompleted": {
      "label": "//foo:foo_lib",
      "configuration": {
        "id": "544e39a7f0abdb3efdd29d675a48bc6a"
      }
    }
  },
  "completed": {
    "success": true,
    "outputGroup": [{
      "name": "default",
      "fileSets": [{
        "id": "0"
      }]
    }],
    "targetKind": "sh_library rule"
  }
}

BEP में आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) के नतीजे

सामान्य बिल्ड, (target, configuration) से जुड़ी कार्रवाइयों का आकलन करते हैं पेयर. आसपेक्ट चालू रहते समय, Babel साथ ही, दिए गए चालू पहलू से प्रभावित हर टारगेट के लिए, (target, configuration, aspect) तीन गुना से जुड़े टारगेट का आकलन करता है.

पहलुओं के आकलन के नतीजे, BEP में उपलब्ध हैं. भले ही, ऐसा न हो किसी खास आसपेक्ट रेशियो के हिसाब से इवेंट टाइप. हर (target, configuration) जोड़े के लिए, लागू होने के हिसाब से, Basel का वर्शन एक अतिरिक्त TargetConfigured और आसपेक्ट रेशियो को लागू करने से नतीजा देने वाला TargetComplete इवेंट टारगेट. उदाहरण के लिए, अगर //:foo_lib को इसके साथ बनाया गया है --aspects=aspects/myaspect.bzl%custom_aspect, यह इवेंट इसमें भी दिखेगा BEP:

{
  "id": {
    "targetCompleted": {
      "label": "//foo:foo_lib",
      "configuration": {
        "id": "544e39a7f0abdb3efdd29d675a48bc6a"
      },
      "aspect": "aspects/myaspect.bzl%custom_aspect"
    }
  },
  "completed": {
    "success": true,
    "outputGroup": [{
      "name": "default",
      "fileSets": [{
        "id": "1"
      }]
    }]
  }
}

NamedSetOfFiles का इस्तेमाल कर रहा है

किसी दिए गए टारगेट (या पहलू) से बने आर्टफ़ैक्ट का पता लगाना एक सामान्य बात है BEP का इस्तेमाल कैसे करें, इसे कुछ तैयारी की मदद से बेहतर तरीके से किया जा सकता है. इस सेक्शन पर इसमें NamedSetOfFiles के बार-बार होने वाले, शेयर किए गए स्ट्रक्चर पर चर्चा की गई है इवेंट, जो स्टारलार्क डेपसेट की बनावट से मेल खाता है.

उपभोक्ताओं को इस बात का ध्यान रखना चाहिए कि वे डेटा को प्रोसेस करते समय क्वाड्रेटिक एल्गोरिदम का इस्तेमाल न करें NamedSetOfFiles इवेंट क्योंकि बड़े बिल्ड में हज़ारों या लाखों इवेंट हो सकते हैं इस तरह की घटनाओं के लिए, ट्रेवर्सल में करोड़ों ऑपरेशन की ज़रूरत होती है. क्वाड्रेटिक कॉम्प्लेक्सिटी.

दूसरा डायग्राम. NamedSetOfFiles बीईपी ग्राफ़.

NamedSetOfFiles इवेंट, BEP स्ट्रीम में हमेशा किसी ऑफ़र से पहले दिखता है TargetComplete या NamedSetOfFiles इवेंट, जिससे रेफ़रंस मिलता है. यह है "पैरंट-चाइल्ड" से उलट इवेंट संबंध, जहां पहले इवेंट को छोड़कर सभी कम से कम एक इवेंट की घोषणा के बाद दिखेगा. NamedSetOfFiles इवेंट है यह एलान Progress इवेंट ने किया है. इसमें सिमैंटिक का इस्तेमाल नहीं किया गया है.

क्रम और शेयर करने की इन पाबंदियों को देखते हुए, एक आम उपभोक्ता को सभी चीज़ों को बफ़र करना होगा BEP स्ट्रीम के खत्म होने तक, NamedSetOfFiles इवेंट. यह JSON फ़ाइल इवेंट स्ट्रीम और Python कोड, "डिफ़ॉल्ट" में बनाए गए आर्टफ़ैक्ट का टारगेट/आसपेक्ट आउटपुट ग्रुप, और बनाए गए टारगेट/एस्पेक्ट के सबसेट के आउटपुट को प्रोसेस करना:

named_sets = {}  # type: dict[str, NamedSetOfFiles]
outputs = {}     # type: dict[str, dict[str, set[str]]]

for event in stream:
  kind = event.id.WhichOneof("id")
  if kind == "named_set":
    named_sets[event.id.named_set.id] = event.named_set_of_files
  elif kind == "target_completed":
    tc = event.id.target_completed
    target_id = (tc.label, tc.configuration.id, tc.aspect)
    outputs[target_id] = {}
    for group in event.completed.output_group:
      outputs[target_id][group.name] = {fs.id for fs in group.file_sets}

for result_id in relevant_subset(outputs.keys()):
  visit = outputs[result_id].get("default", [])
  seen_sets = set(visit)
  while visit:
    set_name = visit.pop()
    s = named_sets[set_name]
    for f in s.files:
      process_file(result_id, f)
    for fs in s.file_sets:
      if fs.id not in seen_sets:
        visit.add(fs.id)
        seen_sets.add(fs.id)