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

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

रद्द किया गया

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

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

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

ActionExecuted

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

BuildFinished

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

BuildMetadata

इसमें --build_metadata फ़्लैग का पार्स किया गया कॉन्टेंट शामिल होता है. यह इवेंट मौजूद है प्लंबिंग डेटा (उदाहरण के लिए, परफ़ॉर्मेंस मैक्स कैंपेन) के ज़रिए आइडेंटिफ़ायर).

BuildMetrics

हर निर्देश के आखिर में, एक 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"
    }
  }
}

BuildStarted

बीईपी स्ट्रीम के पहले इवेंट में, 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 इवेंट हैं, जिनमें सभी के बारे में जानकारी दी गई है कमांड लाइन आर्ग्युमेंट (इसमें विकल्प और ऐसे आर्ग्युमेंट शामिल हैं जो समझ नहीं आते). हर CommandLine इवेंट के StructuredCommandLineId में एक लेबल होता है, जो बताता है कि यह किस तरह का प्रतिनिधित्व करता है; बीईपी में ऐसे तीन इवेंट दिखते हैं:

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

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

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

{
  "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"
    }
  }
}

ConvenienceSymlinksIdentified

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

{
  "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"
      }
    ]
  }
}

लाएं

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

NamedSetOfFiles

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

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

OptionsParsed

किसी OptionsParsed इवेंट में, निर्देश पर लागू होने वाले सभी विकल्प होते हैं, स्टार्टअप विकल्पों को कमांड विकल्पों से अलग करती हूँ. इसमें यह भी शामिल है InvocationPolicy, अगर कोई हो.

{
  "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

PatternExpanded इवेंट, उन सभी टारगेट के सेट के बारे में बताते हैं जो पैटर्न से मेल खाते हैं दिया गया है. सफल निर्देशों के लिए, एक इवेंट मौजूद होता है PatternExpandedId में सभी पैटर्न और PatternExpanded इवेंट के बच्चे. अगर पैटर्न का विस्तार किसी test_suites test_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"
    }
  }
}

प्रगति

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

TargetComplete

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

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

TargetConfigured

विश्लेषण के चरण को पूरा करने वाले हर टारगेट के लिए, 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"
  }
}

TargetSummary

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

TestResult

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

TestSummary

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

UnstructuredCommandLine

CommandLine से अलग, इस इवेंट में पार्स नहीं की गई कमांडलाइन शामिल होती है सभी को बड़ा करने के बाद बिल्ड टूल में मिलने वाले फ़्लैग के रूप में स्ट्रिंग के रूप में फ़्लैग .bazelrc फ़ाइलें और --config फ़्लैग पर विचार किया जा रहा है.

UnstructuredCommandLine इवेंट पर यह भरोसा किया जा सकता है कि दिए गए निर्देश की ज़रूरत है.

WorkspaceConfig

एक WorkspaceConfig इवेंट में, कन्वर्ज़न इवेंट की फ़ाइल फ़ोल्डर, जैसे एक्ज़ीक्यूशन रूट.

WorkspaceStatus

किसी WorkspaceStatus इवेंट में, वर्कस्पेस की स्थिति का नतीजा शामिल होता है आदेश.