इवेंट प्रोटोकॉल शब्दावली बनाएं

समस्या की शिकायत करें सोर्स देखें

हर BEP इवेंट टाइप के खुद के सिमेंटिक होते हैं. कम से कम build_event_stream.proto में इसकी जानकारी दी गई है. नीचे दी गई शब्दावली में हर इवेंट टाइप के बारे में बताया गया है.

रद्द किया गया

अन्य इवेंट से अलग, Aborted में संबंधित आईडी टाइप नहीं होता, क्योंकि Aborted इवेंट अन्य तरह के इवेंट को बदलता है. इस इवेंट से पता चलता है कि बिल्ड जल्दी खत्म हो गया और इवेंट का आईडी आम तौर पर नहीं बन रहा था. Aborted में एक Enum और इंसानों के लिए बनाए गए ब्यौरे हैं, जो बताते हैं कि बिल्ड क्यों पूरा नहीं हुआ.

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

{
  "id": {
    "targetCompleted": {
      "label": "//:foo",
      "configuration": {
        "id": "544e39a7f0abdb3efdd29d675a48bc6a"
      }
    }
  },
  "aborted": {
    "reason": "USER_INTERRUPTED"
  }
}

कार्रवाई पूरी हुई

यह किसी बिल्ड में किसी खास कार्रवाई को लागू करने के बारे में जानकारी देता है. डिफ़ॉल्ट रूप से, यह इवेंट बीईपी में सिर्फ़ उन ऐक्शन के लिए शामिल किया जाता है जो काम नहीं कर पाते. उपयोगकर्ता सभी ActionExecuted इवेंट शामिल करने के लिए --build_event_publish_all_actions फ़्लैग सेट कर सकते हैं.

बिल्ड खत्म

कमांड पूरा होने के बाद एक ही BuildFinished इवेंट भेजा जाता है और इसमें निर्देश का एग्ज़िट कोड शामिल होता है. इस इवेंट में, आधिकारिक तौर पर मिली सफलता या असफलता की जानकारी मिलती है.

बिल्ड मेटाडेटा

इसमें --build_metadata फ़्लैग का पार्स किया गया कॉन्टेंट शामिल होता है. यह इवेंट, बाहरी डेटा (जैसे कि आइडेंटिफ़ायर) को शामिल करके, अन्य टूल के साथ Bazel इंटिग्रेशन की सुविधा देता है.

मेट्रिक बनाना

हर निर्देश के आखिर में एक BuildMetrics इवेंट भेजा जाता है. इसमें काउंटर/गॉज होते हैं, जो कमांड के दौरान बिल्ड टूल के व्यवहार का आकलन करने के लिए मददगार होते हैं. ये मेट्रिक बताते हैं कि काम असल में पूरा हुआ या नहीं. साथ ही, कैश मेमोरी में सेव किए गए काम को नहीं गिना जाता.

ध्यान दें कि अगर कमांड चलाने के दौरान कोई Java जांचें या कचरा नहीं था, तो हो सकता है कि memory_metrics पॉप्युलेट न हो. उपयोगकर्ता --memory_profile=/dev/null का विकल्प सेट कर सकते हैं, ताकि कचरे को इकट्ठा करने वाले टूल को निर्देश के आखिर में memory_metrics की जानकारी अपने-आप मिल जाए.

{
  "id": {
    "buildMetrics": {}
  },
  "buildMetrics": {
    "actionSummary": {
      "actionsExecuted": "1"
    },
    "memoryMetrics": {},
    "targetMetrics": {
      "targetsLoaded": "9",
      "targetsConfigured": "19"
    },
    "packageMetrics": {
      "packagesLoaded": "5"
    },
    "timingMetrics": {
      "cpuTimeInMs": "1590",
      "wallTimeInMs": "359"
    }
  }
}

बिल्ड किया गया

BEP स्ट्रीम के पहले इवेंट में, BuildStarted का मेटाडेटा शामिल होता है. इसकी मदद से, किसी भी काम को शुरू करने से पहले उसका निर्देश दिया जाता है.

BuildToolLogs

किसी कमांड के आखिर में एक BuildToolLogs इवेंट भेजा जाता है. इसमें बिल्ड टूल से जनरेट की गई फ़ाइलों के यूआरआई शामिल होते हैं. इससे, बिल्ड टूल के व्यवहार को समझने या डीबग करने में मदद मिल सकती है. कुछ जानकारी, इनलाइन में शामिल की जा सकती है.

{
  "id": {
    "buildToolLogs": {}
  },
  "lastMessage": true,
  "buildToolLogs": {
    "log": [
      {
        "name": "elapsed time",
        "contents": "MC4xMjEwMDA="
      },
      {
        "name": "process stats",
        "contents": "MSBwcm9jZXNzOiAxIGludGVybmFsLg=="
      },
      {
        "name": "command.profile.gz",
        "uri": "file:///tmp/.cache/bazel/_bazel_foo/cde87985ad0bfef34eacae575224b8d1/command.profile.gz"
      }
    ]
  }
}

कमांडलाइन

बीईपी में ऐसे सभी CommandLine इवेंट शामिल होते हैं जिनमें सभी कमांड-लाइन आर्ग्युमेंट को दिखाया जाता है. इनमें विकल्प और बिना मतलब वाले तर्क शामिल होते हैं. हर CommandLine इवेंट के StructuredCommandLineId में एक लेबल होता है, जो बताता है कि कौनसी जानकारी दिख रही है: बीईपी में तीन इवेंट दिखते हैं:

  • "original": Bacell से बनाए गए कमांडलाइन को Bazel क्लाइंट से मिला, जिसमें .rc फ़ाइलों से मिले स्टार्टअप विकल्प शामिल नहीं थे.
  • "canonical" .rc फ़ाइल के साथ असरदार कमांड लाइन को बड़ा किया गया और इनवॉइस की नीति लागू की गई.
  • "tool", --experimental_tool_command_line विकल्प से भरा गया. यह बीईपी के ज़रिए बैजल को रैप करने वाले टूल की कमांड-लाइन बताने में मदद करता है. यह एक Base64-एन्कोड किया गया CommandLine बाइनरी प्रोटोकॉल बफ़र मैसेज हो सकता है, जिसका इस्तेमाल सीधे तौर पर किया जाता है या ऐसी स्ट्रिंग जिसे पार्स नहीं किया गया है, लेकिन उसके बारे में बताया नहीं गया है (जैसा कि टूल के विकल्प Bazel से अलग हो सकते हैं).

कॉन्फ़िगरेशन

किसी बिल्ड में टॉप लेवल टारगेट में इस्तेमाल किए जाने वाले हर configuration के लिए Configuration इवेंट भेजा जाता है. कम से कम एक कॉन्फ़िगरेशन इवेंट हमेशा मौजूद होता है. TargetConfigured और TargetComplete इवेंट आईडी में id का फिर से इस्तेमाल किया जाता है. यह ज़रूरी है कि एक से ज़्यादा कॉन्फ़िगरेशन वाले बिल्ड में अंतर करने के लिए ये इवेंट इस्तेमाल किए जाएं.

{
  "id": {
    "configuration": {
      "id": "a5d130b0966b4a9ca2d32725aa5baf40e215bcfc4d5cdcdc60f5cc5b4918903b"
    }
  },
  "configuration": {
    "mnemonic": "k8-fastbuild",
    "platformName": "k8",
    "cpu": "k8",
    "makeVariable": {
      "COMPILATION_MODE": "fastbuild",
      "TARGET_CPU": "k8",
      "GENDIR": "bazel-out/k8-fastbuild/bin",
      "BINDIR": "bazel-out/k8-fastbuild/bin"
    }
  }
}

सुविधाजनकSymlinksIidified

प्रयोग के तौर पर. अगर --experimental_convenience_symlinks_bep_event विकल्प सेट है, तो build निर्देशों की मदद से एक ConvenienceSymlinksIdentified इवेंट जनरेट होता है. इससे पता चलता है कि फ़ाइल फ़ोल्डर में सिमलिंक किस तरह मैनेज किए जाने चाहिए. यह ऐसे टूल बनाने में मदद करता है जो बेज़ेल को दूर से इस्तेमाल करते हैं. साथ ही, लोकल वर्कस्पेस को इस तरह व्यवस्थित करते हैं जैसे कि बेज़ल स्थानीय तौर पर चलाया जा रहा हो.

{
  "id": {
    "convenienceSymlinksIdentified":{}
  },
  "convenienceSymlinksIdentified": {
    "convenienceSymlinks": [
      {
        "path": "bazel-bin",
        "action": "CREATE",
        "target": "execroot/google3/bazel-out/k8-fastbuild/bin"
      },
      {
        "path": "bazel-genfiles",
        "action": "CREATE",
        "target": "execroot/google3/bazel-out/k8-fastbuild/genfiles"
      },
      {
        "path": "bazel-out",
        "action": "CREATE",
        "target": "execroot/google3/bazel-out"
      }
    ]
  }
}

लाएं

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

नाम वाले सेट ऑफ़ फ़ाइलें

NamedSetOfFiles इवेंट, किसी ऐसे स्ट्रक्चर की जानकारी देता है जो कमांड इवैलुएशन के दौरान बनाई गई depset फ़ाइलों से मेल खाता हो. ट्रांज़िट समय में जोड़े गए पैसे की पहचान NamedSetOfFilesId करता है.

किसी स्ट्रीम के NamedSetOfFiles इवेंट को समझने के बारे में ज़्यादा जानकारी के लिए, बीईपी के उदाहरणों का पेज देखें.

विकल्प पार्स किए गए

एक ही OptionsParsed इवेंट में, कमांड पर लागू होने वाले सभी विकल्प होते हैं. इससे, स्टार्टअप के विकल्पों को कमांड के विकल्पों से अलग रखा जाता है. अगर लागू हो, तो इसमें InvotionPolicy भी शामिल होती है.

{
  "id": {
    "optionsParsed": {}
  },
  "optionsParsed": {
    "startupOptions": [
      "--max_idle_secs=10800",
      "--noshutdown_on_low_sys_mem",
      "--connect_timeout_secs=30",
      "--output_user_root=/tmp/.cache/bazel/_bazel_foo",
      "--output_base=/tmp/.cache/bazel/_bazel_foo/a61fd0fbee3f9d6c1e30d54b68655d35",
      "--deep_execroot",
      "--expand_configs_in_place",
      "--idle_server_tasks",
      "--write_command_log",
      "--nowatchfs",
      "--nofatal_event_bus_exceptions",
      "--nowindows_enable_symlinks",
      "--noclient_debug",
    ],
    "cmdLine": [
      "--enable_platform_specific_config",
      "--build_event_json_file=/tmp/bep.json"
    ],
    "explicitCmdLine": [
      "--build_event_json_file=/tmp/bep.json"
    ],
    "invocationPolicy": {}
  }
}

पैटर्न विस्तृत

PatternExpanded इवेंट, उन सभी टारगेट के सेट के बारे में बताते हैं जो कमांडलाइन पर दिए गए पैटर्न से मेल खाते हैं. सफल निर्देशों के लिए, PatternExpandedId में मौजूद सभी पैटर्न वाला एक इवेंट और PatternExpanded इवेंट के बच्चों के सभी टारगेट मौजूद होते हैं. अगर पैटर्न किसी भी test_suitetest_suite में शामिल टेस्ट टारगेट के सेट तक बढ़ता है. हर पैटर्न के लिए जो पैटर्न ठीक नहीं हो पाते, उनके लिए BEP का एक और Aborted इवेंट होता है, जिसमें PatternExpandedId की पहचान होती है.

{
  "id": {
    "pattern": {
      "pattern":["//base:all"]
    }
  },
  "children": [
    {"targetConfigured":{"label":"//base:foo"}},
    {"targetConfigured":{"label":"//base:foobar"}}
  ],
  "expanded": {
    "testSuiteExpansions": {
      "suiteLabel": "//base:suite",
      "testLabels": "//base:foo_test"
    }
  }
}

प्रगति

प्रोग्रेस इवेंट में स्टैंडर्ड आउटपुट और Standard से जुड़ी गड़बड़ी होती है. यह गड़बड़ी, एक्ज़ीक्यूशन के दौरान Bazel से होती है. ये इवेंट अपने-आप भी जनरेट होते हैं, क्योंकि उन इवेंट के बारे में जानकारी देने के लिए इनका इस्तेमाल नहीं किया जाता है जिनका एलान किसी "सही" इवेंट (खास तौर पर NamedSetOfFiles) से नहीं किया गया हो.

टारगेट पूरा हुआ

एक्ज़ीक्यूशन के फ़ेज़ को पूरा करने वाले हर (target, configuration, aspect) कॉम्बिनेशन के लिए, बीईपी में TargetComplete इवेंट शामिल किया जाता है. इस इवेंट में, टारगेट की सफलता/फ़ेल या टारगेट के अनुरोध किए गए आउटपुट ग्रुप होते हैं.

{
  "id": {
    "targetCompleted": {
      "label": "//examples/py:bep",
      "configuration": {
        "id": "a5d130b0966b4a9ca2d32725aa5baf40e215bcfc4d5cdcdc60f5cc5b4918903b"
      }
    }
  },
  "completed": {
    "success": true,
    "outputGroup": [
      {
        "name": "default",
        "fileSets": [
          {
            "id": "0"
          }
        ]
      }
    ]
  }
}

टारगेट कॉन्फ़िगर किया गया

विश्लेषण के हर चरण को पूरा करने वाले हर टारगेट के लिए, बीईपी में TargetConfigured इवेंट शामिल किया जाता है. यह टारगेट "रूल टाइप" एट्रिब्यूट का भरोसेमंद सोर्स है. टारगेट पर लागू किए गए कॉन्फ़िगरेशन, इवेंट के बताए गए बच्चों में दिखते हैं.

उदाहरण के लिए, --experimental_multi_cpu विकल्पों के साथ बनाने से दो कॉन्फ़िगरेशन वाले किसी एक टारगेट के लिए, ये TargetConfigured इवेंट बन सकते हैं:

{
  "id": {
    "targetConfigured": {
      "label": "//starlark_configurations/multi_arch_binary:foo"
    }
  },
  "children": [
    {
      "targetCompleted": {
        "label": "//starlark_configurations/multi_arch_binary:foo",
        "configuration": {
          "id": "c62b30c8ab7b9fc51a05848af9276529842a11a7655c71327ade26d7c894c818"
        }
      }
    },
    {
      "targetCompleted": {
        "label": "//starlark_configurations/multi_arch_binary:foo",
        "configuration": {
          "id": "eae0379b65abce68d54e0924c0ebcbf3d3df26c6e84ef7b2be51e8dc5b513c99"
        }
      }
    }
  ],
  "configured": {
    "targetKind": "foo_binary rule"
  }
}

टारगेट की खास जानकारी

लागू होने वाले हर (target, configuration) पेयर के लिए, एक TargetSummary इवेंट को कुल सफलता के नतीजे के साथ शामिल किया जाता है. इसमें, कॉन्फ़िगर किए गए टारगेट का लागू होना और उस कॉन्फ़िगर किए गए टारगेट पर लागू होने वाले सभी पहलू शामिल होते हैं.

टेस्ट का नतीजा

अगर जांच का अनुरोध किया जाता है, तो हर जांच की कोशिश के लिए TestResult इवेंट भेजा जाता है. यह हर टेस्ट के लिए चलाया जाता है. इससे बीईपी के उपभोक्ताओं को यह पता लगाने में मदद मिलती है कि कौनसी जांच कार्रवाइयां उनकी जांच में सफल नहीं हुईं. साथ ही, हर जांच कार्रवाई के लिए टेस्ट आउटपुट (जैसे कि लॉग, test.xml फ़ाइलें) की पहचान कर पाती हैं.

टेस्ट की खास जानकारी

अगर जांच का अनुरोध किया जाता है, तो हर (target, configuration) की जांच के लिए TestSummary इवेंट भेजा जाता है. इसमें, जांच के नतीजों को समझने के लिए ज़रूरी जानकारी शामिल होती है. हर टेस्ट के दौरान शार्ड, शार्ड, और रन की संख्या शामिल है, ताकि बीईपी उपभोक्ता इन डाइमेंशन के आर्टफ़ैक्ट में अंतर कर सकें. हर जांच और चलाने की कोशिशों को ध्यान में रखा जाता है. इसके लिए, TestStatus के एग्रीगेट FLAKY टेस्ट में अंतर करने और FAILED टेस्ट में अंतर दिखाने पर विचार किया जाता है.

अनस्ट्रक्चर्ड कमांड लाइन

CommandLine के उलट, इस इवेंट में पार्स नहीं किए गए कमांडलाइन फ़्लैग होते हैं. यह सभी .bazelrc फ़ाइलों को बड़ा करने और --config फ़्लैग को ध्यान में रखते हुए, बिल्ड टूल में दिखता है.

दिए गए कमांड को पूरी तरह से फिर से चलाने के लिए, UnstructuredCommandLine इवेंट पर भरोसा किया जा सकता है.

Workspace का कॉन्फ़िगरेशन

एक WorkspaceConfig इवेंट में, Workspace से जुड़ी कॉन्फ़िगरेशन की जानकारी होती है, जैसे कि एक्ज़ीक्यूशन रूट.

फ़ाइल फ़ोल्डर की स्थिति

किसी एक WorkspaceStatus इवेंट में, Workspace का स्टेटस कमांड का नतीजा शामिल होता है.