การดำเนินการ
คำสั่งที่จะเรียกใช้ระหว่างการสร้าง เช่น การเรียกใช้คอมไพเลอร์ที่รับอาร์ติแฟกต์เป็นอินพุตและสร้างอาร์ติแฟกต์อื่นๆ เป็นเอาต์พุต รวมถึงข้อมูลเมตา เช่น อาร์กิวเมนต์บรรทัดคำสั่ง คีย์การดำเนินการ ตัวแปรสภาพแวดล้อม และอาร์ติแฟกต์อินพุต/เอาต์พุตที่ประกาศไว้
ดูเพิ่มเติม: เอกสารประกอบเกี่ยวกับกฎ
แคชการดำเนินการ
แคชในดิสก์ที่จัดเก็บการแมปของการดำเนินการที่ดำเนินการแล้วกับ เอาต์พุตที่สร้างขึ้น คีย์แคชเรียกว่าคีย์การดำเนินการ คอมโพเนนต์หลักสำหรับโมเดลการเพิ่มของ Bazel แคชจะจัดเก็บไว้ใน ไดเรกทอรีฐานเอาต์พุต จึงยังคงอยู่ได้แม้จะรีสตาร์ทเซิร์ฟเวอร์ Bazel
กราฟการดำเนินการ
กราฟในหน่วยความจำของการดำเนินการและอาร์ติแฟกต์ที่
การดำเนินการเหล่านี้อ่านและสร้าง กราฟอาจมีอาร์ติแฟกต์ที่อยู่ในรูปแบบ
ไฟล์ต้นฉบับ (เช่น ในระบบไฟล์) รวมถึงอาร์ติแฟกต์
ระดับกลาง/สุดท้ายที่สร้างขึ้นซึ่งไม่ได้กล่าวถึงในไฟล์ BUILD สร้างขึ้น
ในระยะการวิเคราะห์และใช้ในระยะการดำเนินการ
การค้นหากราฟการดำเนินการ (aquery)
เครื่องมือการค้นหาที่ค้นหาการดำเนินการในการสร้างได้ ซึ่งจะช่วยให้วิเคราะห์ได้ว่ากฎการสร้างจะส่งผลต่อการสร้างงานจริงอย่างไร
ปุ่มดำเนินการ
คีย์แคชของการดำเนินการ คำนวณตามข้อมูลเมตาของการดำเนินการ ซึ่งอาจรวมถึงคำสั่งที่จะดำเนินการในการดำเนินการ แฟล็กคอมไพเลอร์ ตำแหน่งไลบรารี หรือส่วนหัวของระบบ ทั้งนี้ขึ้นอยู่กับการดำเนินการ ช่วยให้ Bazel แคชหรือ ล้างการดำเนินการแต่ละรายการได้อย่างแน่นอน
ระยะการวิเคราะห์
เฟสที่ 2 ของการสร้าง ประมวลผลกราฟเป้าหมาย
ที่ระบุในไฟล์ BUILD เพื่อสร้างกราฟ
การดำเนินการในหน่วยความจำ ซึ่งจะกำหนดลำดับการดำเนินการที่จะเรียกใช้ในระยะการดำเนินการ นี่คือระยะที่ระบบประเมินการใช้งานกฎ
อาร์ติแฟกต์
ไฟล์ต้นฉบับหรือไฟล์ที่สร้างขึ้น อาจเป็นไดเรกทอรีของไฟล์ที่เรียกว่าอาร์ติแฟกต์แบบโครงสร้างต้นไม้ก็ได้
อาร์ติแฟกต์อาจเป็นอินพุตของการดำเนินการหลายอย่าง แต่ต้องสร้างขึ้นจากการดำเนินการอย่างน้อย 1 อย่างเท่านั้น
คุณสามารถระบุอาร์ติแฟกต์ที่สอดคล้องกับเป้าหมายไฟล์ได้โดยใช้ป้ายกำกับ
สัดส่วนภาพ
กลไกสำหรับกฎในการสร้างการดำเนินการเพิ่มเติมใน
การอ้างอิง เช่น หากเป้าหมาย A ขึ้นอยู่กับ B คุณสามารถใช้แง่มุมกับ A ที่ข้ามขึ้นขอบเขตการอ้างอิงไปยัง B และเรียกใช้การดำเนินการเพิ่มเติมใน B
เพื่อสร้างและรวบรวมไฟล์เอาต์พุตเพิ่มเติม ระบบจะแคชและนำการดำเนินการเพิ่มเติมเหล่านี้ไปใช้ซ้ำระหว่างเป้าหมายที่ต้องใช้องค์ประกอบเดียวกัน สร้างด้วยฟังก์ชัน
aspect() Starlark Build API ใช้เพื่อสร้างข้อมูลเมตาสำหรับ IDE และสร้างการดำเนินการสำหรับการตรวจสอบโค้ดได้ เป็นต้น
ดูเพิ่มเติม: เอกสารประกอบเกี่ยวกับแง่มุม
Aspect-on-aspect
กลไกการประกอบที่ใช้แง่มุมต่างๆ กับผลลัพธ์
ของแง่มุมอื่นๆ เช่น คุณสามารถใช้ Aspect ที่สร้างข้อมูลเพื่อให้ IDE ใช้ได้กับ Aspect ที่สร้างไฟล์ .java จาก Proto
หากต้องการให้แง่มุม A มีผลเหนือแง่มุม B ผู้ให้บริการที่
B โฆษณาในแอตทริบิวต์ provides
ต้องตรงกับสิ่งที่ A ประกาศว่าต้องการในแอตทริบิวต์ required_aspect_providers
แอตทริบิวต์
พารามิเตอร์ของกฎที่ใช้เพื่อแสดงข้อมูลการสร้างต่อเป้าหมาย
เช่น srcs, deps และ copts ซึ่งประกาศไฟล์ต้นฉบับ การอ้างอิง และตัวเลือกคอมไพเลอร์ที่กำหนดเองของเป้าหมายตามลำดับ แอตทริบิวต์เฉพาะ
ที่ใช้ได้กับเป้าหมายหนึ่งๆ จะขึ้นอยู่กับประเภทกฎของเป้าหมายนั้น
.bazelrc
ไฟล์การกำหนดค่าของ Bazel ใช้เพื่อเปลี่ยนค่าเริ่มต้นสำหรับแฟล็ก
การเริ่มต้นและแฟล็กคำสั่ง รวมถึงเพื่อกำหนดกลุ่มตัวเลือกทั่วไป
ซึ่งจะตั้งค่าร่วมกันได้ในบรรทัดคำสั่ง Bazel โดยใช้แฟล็ก --config Bazel สามารถรวมการตั้งค่าจากไฟล์ bazelrc หลายไฟล์
(ทั่วทั้งระบบ ต่อพื้นที่ทำงาน ต่อผู้ใช้ หรือจากตำแหน่งที่กำหนดเอง) และไฟล์
bazelrc อาจนำเข้าการตั้งค่าจากไฟล์ bazelrc อื่นๆ ได้ด้วย
Blaze
Bazel เวอร์ชันภายในของ Google ระบบบิลด์หลักของ Google สำหรับ ที่เก็บข้อมูลแบบโมโน
ไฟล์ BUILD
BUILD คือไฟล์การกำหนดค่าหลักที่บอก Bazel ว่าจะสร้างเอาต์พุตซอฟต์แวร์ใด
มีการอ้างอิงใดบ้าง และจะสร้างอย่างไร Bazel
ใช้ไฟล์ BUILD เป็นอินพุตและใช้ไฟล์เพื่อสร้างกราฟของการอ้างอิง
และเพื่อหาการดำเนินการที่ต้องทำให้เสร็จเพื่อสร้างเอาต์พุตซอฟต์แวร์ขั้นกลางและขั้นสุดท้าย
ไฟล์ BUILD จะทำเครื่องหมายไดเรกทอรีและไดเรกทอรีย่อยที่ไม่มีไฟล์ BUILD เป็นแพ็กเกจ และอาจมีเป้าหมายที่สร้างโดยกฎ นอกจากนี้ คุณยังตั้งชื่อไฟล์เป็น
BUILD.bazel ได้ด้วย
ไฟล์ BUILD.bazel
ดูBUILD ไฟล์ มีความสำคัญเหนือกว่าไฟล์ BUILD ในไดเรกทอรีเดียวกัน
ไฟล์ .bzl
ไฟล์ที่กำหนดกฎ มาโคร และค่าคงที่ที่เขียนใน Starlark จากนั้นจะนําเข้าข้อมูลเหล่านี้ไปยังBUILD
ไฟล์ได้โดยใช้ฟังก์ชัน load()
สร้างกราฟ
กราฟทรัพยากร Dependency ที่ Bazel สร้างและสำรวจเพื่อทำการบิลด์ ประกอบด้วยโหนดต่างๆ เช่น เป้าหมาย เป้าหมายที่กำหนดค่า การดำเนินการ และอาร์ติแฟกต์ ระบบจะถือว่าการสร้างเสร็จสมบูรณ์เมื่อมีการยืนยันว่าอาร์ติแฟกต์ทั้งหมดที่เป้าหมายที่ขอชุดหนึ่งขึ้นอยู่กับนั้นเป็นเวอร์ชันล่าสุด
การตั้งค่าบิลด์
ส่วนการกำหนดค่าที่กำหนดโดย Starlark การเปลี่ยนสามารถตั้งค่าการสร้างเพื่อเปลี่ยนการกำหนดค่าของกราฟย่อยได้ หากแสดงต่อผู้ใช้เป็นแฟล็กบรรทัดคำสั่ง หรือที่เรียกว่าแฟล็กบิลด์
บิลด์ที่สะอาด
บิลด์ที่ไม่ใช้ผลลัพธ์ของบิลด์ก่อนหน้า โดยทั่วไปแล้วจะช้ากว่าการสร้างแบบเพิ่มทีละรายการ แต่โดยทั่วไปถือว่าถูกต้องกว่า Bazel รับประกันว่าทั้งการสร้างที่สะอาดและการสร้างแบบเพิ่มจะถูกต้องเสมอ
รูปแบบไคลเอ็นต์-เซิร์ฟเวอร์
ไคลเอ็นต์บรรทัดคำสั่ง bazel จะเริ่มเซิร์ฟเวอร์เบื้องหลังโดยอัตโนมัติในเครื่องภายในเพื่อเรียกใช้คำสั่ง Bazel เซิร์ฟเวอร์จะยังคงทำงานอยู่เมื่อมีการเรียกใช้คำสั่งต่างๆ แต่จะหยุดทำงานโดยอัตโนมัติหลังจากไม่มีการใช้งานในระยะเวลาหนึ่ง (หรือหยุดทำงานอย่างชัดเจนผ่านคำสั่ง bazel shutdown) การแยก Bazel ออกเป็นเซิร์ฟเวอร์และไคลเอ็นต์ช่วยลดเวลาเริ่มต้นของ JVM
และรองรับการสร้างแบบเพิ่มที่เร็วขึ้น
เนื่องจากกราฟการดำเนินการยังคงอยู่ในหน่วยความจำในคำสั่งต่างๆ
คำสั่ง
ใช้ในบรรทัดคำสั่งเพื่อเรียกใช้ฟังก์ชัน Bazel ต่างๆ เช่น bazel
build, bazel test, bazel run และ bazel query
Flag คำสั่ง
ชุด Flag ที่เฉพาะเจาะจงสำหรับคำสั่ง มีการระบุการตั้งค่าสถานะคำสั่งหลังจากคำสั่ง (bazel build <command flags>) การตั้งค่าสถานะอาจใช้ได้กับคำสั่งอย่างน้อย 1 รายการ
ตัวอย่างเช่น --configure เป็น Flag สำหรับคำสั่ง bazel sync เท่านั้น แต่ --keep_going ใช้ได้กับ sync, build, test และอื่นๆ มักใช้แฟล็กเพื่อวัตถุประสงค์ในการกำหนดค่า
ดังนั้นการเปลี่ยนแปลงค่าแฟล็กอาจทำให้ Bazel ล้างกราฟในหน่วยความจำ
และรีสตาร์ทระยะการวิเคราะห์
การกำหนดค่า
ข้อมูลภายนอกคำจำกัดความของกฎที่มีผลต่อวิธีที่กฎสร้างการดำเนินการ ทุกบิลด์มีการกำหนดค่าอย่างน้อย 1 รายการที่ระบุ แพลตฟอร์มเป้าหมาย ตัวแปรสภาพแวดล้อมของการดำเนินการ และแฟล็กบิลด์ในบรรทัดคำสั่ง การเปลี่ยนอาจสร้างการกำหนดค่าเพิ่มเติม เช่น สำหรับเครื่องมือโฮสต์หรือการคอมไพล์ข้าม
ดูเพิ่มเติม: การกำหนดค่า
การตัดแต่งการกำหนดค่า
กระบวนการรวมเฉพาะส่วนของการกำหนดค่าที่เป้าหมายต้องการจริงๆ เช่น หากคุณสร้างไบนารี Java //:j ที่มี
การอ้างอิง C++ //:c การรวมค่าของ --javacopt ไว้ใน
การกำหนดค่าของ //:c จะเป็นการสิ้นเปลือง เนื่องจากหากเปลี่ยน --javacopt โดยไม่จำเป็นจะทำให้แคชการสร้าง C++
ใช้ไม่ได้
การค้นหาที่กำหนดค่า (cquery)
เครื่องมือการค้นหาที่ค้นหาเป้าหมายที่กำหนดค่า (หลังจากระยะการวิเคราะห์
เสร็จสมบูรณ์) ซึ่งหมายความว่า select() และบิลด์แฟล็ก (เช่น
--platforms) จะแสดงในผลลัพธ์อย่างถูกต้อง
ดูเพิ่มเติม: เอกสารประกอบของ cquery
เป้าหมายที่กำหนดค่า
ผลลัพธ์ของการประเมินเป้าหมายด้วยการกำหนดค่า ระยะการวิเคราะห์จะสร้างสิ่งนี้โดยการรวมตัวเลือกของบิลด์กับเป้าหมายที่ต้องสร้าง
เช่น หาก //:foo สร้างสำหรับสถาปัตยกรรม 2 แบบที่แตกต่างกันในการสร้างเดียวกัน ก็จะมีเป้าหมายที่กำหนดค่าไว้ 2 รายการ ได้แก่ <//:foo, x86> และ <//:foo, arm>
ความถูกต้อง
บิลด์จะถูกต้องเมื่อเอาต์พุตแสดงสถานะของอินพุตแบบทรานซิทีฟอย่างถูกต้อง Bazel พยายามที่จะปิดผนึก ทำซ้ำได้ และทำให้การวิเคราะห์บิลด์และการดำเนินการเป็นแบบดีเทอร์มินิสติกเพื่อให้ได้บิลด์ที่ถูกต้อง
การขึ้นต่อกัน
ขอบที่กํากับทิศระหว่างเป้าหมาย 2 รายการ เป้าหมาย //:foo มีการอ้างอิงเป้าหมายในเป้าหมาย //:bar หากค่าแอตทริบิวต์ของ //:foo มีการอ้างอิงถึง //:bar //:foo มีการขึ้นต่อกันของการดำเนินการกับ //:bar หากการดำเนินการใน //:foo ขึ้นอยู่กับอาร์ติแฟกต์อินพุตที่สร้างขึ้นโดยการดำเนินการใน //:bar
Depset
โครงสร้างข้อมูลสําหรับการรวบรวมข้อมูลเกี่ยวกับทรัพยากร Dependency แบบทรานซิทีฟ ได้รับการเพิ่มประสิทธิภาพเพื่อให้การผสานรวม Depset มีประสิทธิภาพทั้งด้านเวลาและพื้นที่ เนื่องจากมักจะมี Depset ขนาดใหญ่มาก (ไฟล์หลายแสนไฟล์) ใช้เพื่อ อ้างอิงชุดทรัพยากรอื่นๆ แบบเรียกซ้ำเพื่อเหตุผลด้านประสิทธิภาพของพื้นที่ กฎ การใช้งานไม่ควร "ทำให้แบน" ชุดการพึ่งพาโดยการแปลงเป็นรายการ เว้นแต่ กฎจะอยู่ที่ระดับบนสุดของกราฟการสร้าง การทำให้ Depset ขนาดใหญ่แบนราบจะทำให้ใช้หน่วยความจำ จำนวนมาก หรือที่เรียกว่าชุดที่ซ้อนกันในการใช้งานภายในของ Bazel
ดูเพิ่มเติม: เอกสารประกอบของ Depset
แคชดิสก์
ที่เก็บ Blob ในเครื่องสำหรับฟีเจอร์การแคชระยะไกล ใช้ร่วมกับที่เก็บข้อมูลออบเจ็กต์ระยะไกลจริงได้
Distdir
ไดเรกทอรีแบบอ่านอย่างเดียวที่มีไฟล์ที่ Bazel จะดึงข้อมูลจากอินเทอร์เน็ตโดยใช้กฎของที่เก็บ ช่วยให้การสร้างทำงานแบบออฟไลน์ได้อย่างเต็มที่
การดำเนินการแบบไดนามิก
กลยุทธ์การดำเนินการที่เลือกการดำเนินการในเครื่องหรือการดำเนินการจากระยะไกลตาม ฮิวริสติกต่างๆ และใช้ผลการดำเนินการของวิธีการที่สำเร็จเร็วที่สุด การดำเนินการบางอย่างจะดำเนินการในเครื่องได้เร็วกว่า (เช่น การลิงก์) และการดำเนินการอื่นๆ จะดำเนินการจากระยะไกลได้เร็วกว่า (เช่น การคอมไพล์ ที่ขนานกันได้สูง) กลยุทธ์การดำเนินการแบบไดนามิกจะช่วยให้เวลาในการสร้างที่เพิ่มขึ้นและเวลาในการสร้างที่สะอาดดีที่สุดเท่าที่จะเป็นไปได้
ระยะการดำเนินการ
ระยะที่ 3 ของการสร้าง ดำเนินการการดำเนินการในกราฟการดำเนินการที่สร้างขึ้นในระยะการวิเคราะห์ การดำเนินการเหล่านี้จะเรียกใช้ไฟล์ที่ปฏิบัติการได้ (คอมไพเลอร์ สคริปต์) เพื่ออ่านและเขียนอาร์ติแฟกต์ กลยุทธ์การสร้างควบคุมวิธีดำเนินการต่อไปนี้ ดำเนินการ: ในเครื่อง ระยะไกล แบบไดนามิก แซนด์บ็อกซ์ Docker และอื่นๆ
รูทการดำเนินการ
ไดเรกทอรีในพื้นที่ทำงานของไดเรกทอรีเอาต์พุตพื้นฐาน
ซึ่งจะมีการดำเนินการการดำเนินการในเครื่อง
ในบิลด์ที่ไม่ได้แซนด์บ็อกซ์ เนื้อหาในไดเรกทอรีส่วนใหญ่เป็น Symlink
ของอาร์ติแฟกต์อินพุตจากพื้นที่ทำงาน รูทการดำเนินการยังมี
ลิงก์สัญลักษณ์ไปยังที่เก็บภายนอกเป็นอินพุตอื่นๆ และไดเรกทอรี bazel-out
เพื่อจัดเก็บเอาต์พุตด้วย เตรียมไว้ในระยะการโหลด
โดยการสร้างป่าลิงก์สัญลักษณ์ของไดเรกทอรีที่แสดงถึงการปิดทรานซิทีฟ
ของแพ็กเกจที่บิลด์ขึ้นอยู่กับ เข้าถึงได้ด้วย bazel info
execution_root ในบรรทัดคำสั่ง
ไฟล์
การแยกต่างหาก
บิลด์เป็นแบบเฮอร์เมติกหากไม่มีอิทธิพลภายนอกต่อการดำเนินการบิลด์และการทดสอบ ซึ่งจะช่วยให้มั่นใจได้ว่าผลลัพธ์จะเป็นแบบดีเทอร์มินิสติกและถูกต้อง ตัวอย่างเช่น โดยทั่วไปแล้วบิลด์แบบเฮอร์เมติกจะไม่อนุญาตให้ดำเนินการเข้าถึงเครือข่าย จำกัดการเข้าถึงอินพุตที่ประกาศไว้ ใช้การประทับเวลาและ เขตเวลาที่แน่นอน จำกัดการเข้าถึงตัวแปรสภาพแวดล้อม และใช้ Seed ที่แน่นอนสำหรับ เครื่องมือสร้างตัวเลขสุ่ม
การบิลด์แบบเพิ่ม
การสร้างแบบเพิ่มจะนำผลลัพธ์ของการสร้างก่อนหน้ามาใช้ซ้ำเพื่อลดเวลาในการสร้าง และการใช้ทรัพยากร การตรวจสอบและการแคชการขึ้นต่อกันมีจุดมุ่งหมายเพื่อให้ได้ผลลัพธ์ที่ถูกต้อง สำหรับการสร้างประเภทนี้ การบิลด์แบบเพิ่มทีละรายการตรงข้ามกับการบิลด์ แบบคลีน
ป้ายกำกับ
ตัวระบุสำหรับเป้าหมาย ป้ายกำกับแบบเต็ม เช่น
//path/to/package:target ประกอบด้วย // เพื่อทำเครื่องหมายไดเรกทอรีรูทของพื้นที่ทำงาน
path/to/package เป็นไดเรกทอรีที่มีไฟล์ BUILD ที่ประกาศเป้าหมาย และ :target เป็นชื่อของเป้าหมาย
ที่ประกาศในไฟล์ BUILD ดังกล่าว อาจมีคำนำหน้าเป็น
@my_repository//<..> เพื่อระบุว่าเป้าหมายประกาศไว้ในที่เก็บข้อมูลภายนอกชื่อ my_repository
ระยะการโหลด
เฟสแรกของการสร้างที่ Bazel แยกวิเคราะห์ไฟล์ WORKSPACE, BUILD และ .bzl เพื่อสร้างแพ็กเกจ มาโครและฟังก์ชันบางอย่าง เช่น glob() จะได้รับการประเมินในขั้นตอนนี้ สลับกับเฟสที่ 2 ของการสร้าง ซึ่งก็คือเฟสการวิเคราะห์ เพื่อสร้างกราฟเป้าหมาย
มาโคร
กลไกในการเขียนประกาศเป้าหมายของกฎหลายรายการร่วมกันภายใต้ฟังก์ชัน Starlark เดียว เปิดใช้การนำรูปแบบการประกาศกฎทั่วไป
กลับมาใช้ซ้ำในไฟล์ BUILD ขยายไปเป็นการประกาศเป้าหมายของกฎพื้นฐาน
ในระยะการโหลด
ดูเพิ่มเติม: เอกสารประกอบเกี่ยวกับมาโคร
การช่วยความจำ
สตริงสั้นๆ ที่มนุษย์อ่านได้ซึ่งผู้เขียนกฎเลือกไว้เพื่อให้เข้าใจได้อย่างรวดเร็วว่าการดำเนินการในกฎนั้นทำอะไร สามารถใช้ตัวช่วยจำเป็นตัวระบุสำหรับตัวเลือกกลยุทธ์การเกิด ตัวอย่างของตัวช่วยจำการดำเนินการ
คือ Javac จากกฎ Java, CppCompile จากกฎ C++ และ
AndroidManifestMerger จากกฎ Android
กฎเนทีฟ
กฎที่สร้างขึ้นใน Bazel และนำไปใช้ใน Java กฎดังกล่าวจะปรากฏในไฟล์ .bzl เป็นฟังก์ชันในโมดูลเนทีฟ (เช่น native.cc_library หรือ native.java_library) กฎที่ผู้ใช้กำหนด (ที่ไม่ใช่เนทีฟ) จะสร้างขึ้นโดยใช้ Starlark
ฐานเอาต์พุต
ไดเรกทอรีเฉพาะพื้นที่ทำงานสำหรับจัดเก็บไฟล์เอาต์พุตของ Bazel ใช้ เพื่อแยกเอาต์พุตออกจากโครงสร้างแหล่งที่มาของพื้นที่ทำงาน อยู่ในเอาต์พุต รูทผู้ใช้
กลุ่มเอาต์พุต
กลุ่มไฟล์ที่คาดว่าจะสร้างขึ้นเมื่อ Bazel สร้างเป้าหมายเสร็จ กฎจะวางเอาต์พุตปกติไว้ใน "กลุ่มเอาต์พุตเริ่มต้น"
(เช่น ไฟล์ .jar ของ java_library, .a และ .so สำหรับเป้าหมาย cc_library
) กลุ่มเอาต์พุตเริ่มต้นคือกลุ่มเอาต์พุตที่มีการสร้างอาร์ติแฟกต์เมื่อมีการขอเป้าหมายในบรรทัดคำสั่ง
กฎสามารถกำหนดกลุ่มเอาต์พุตที่มีชื่อเพิ่มเติมซึ่งระบุได้อย่างชัดเจนในBUILDไฟล์ (กฎ filegroup) หรือบรรทัดคำสั่ง (แฟล็ก --output_groups)
เอาต์พุตผู้ใช้รูท
ไดเรกทอรีเฉพาะผู้ใช้สำหรับจัดเก็บเอาต์พุตของ Bazel ชื่อไดเรกทอรีได้มาจากชื่อผู้ใช้ระบบของผู้ใช้ ป้องกันการทับซ้อนของไฟล์เอาต์พุตในกรณีที่ ผู้ใช้หลายคนสร้างโปรเจ็กต์เดียวกันในระบบพร้อมกัน มีไดเรกทอรีย่อยที่สอดคล้องกับเอาต์พุตการสร้างของแต่ละพื้นที่ทำงาน หรือที่เรียกว่าฐานเอาต์พุต
แพ็กเกจ
ชุดเป้าหมายที่กำหนดโดยไฟล์ BUILD ชื่อของแพ็กเกจคือเส้นทางของไฟล์ BUILD ที่สัมพันธ์กับรูทของพื้นที่ทำงาน
แพ็กเกจอาจมีแพ็กเกจย่อยหรือไดเรกทอรีย่อยที่มีไฟล์ BUILD
ซึ่งจะสร้างลำดับชั้นของแพ็กเกจ
กลุ่มแพ็กเกจ
เป้าหมายที่แสดงถึงชุดแพ็กเกจ มักใช้ในค่าแอตทริบิวต์ visibility
แพลตฟอร์ม
"ประเภทเครื่อง" ที่เกี่ยวข้องกับการสร้าง ซึ่งรวมถึงเครื่องที่ Bazel ทำงานอยู่ (แพลตฟอร์ม "โฮสต์"), เครื่องที่เครื่องมือบิลด์ทำงานอยู่ (แพลตฟอร์ม "exec") และเครื่องที่สร้างเป้าหมาย (แพลตฟอร์ม "เป้าหมาย")
ผู้ให้บริการ
สคีมาที่อธิบายหน่วยข้อมูลที่จะส่งระหว่างเป้าหมายของกฎตามความสัมพันธ์ของทรัพยากรที่ขึ้นต่อกัน โดยปกติแล้วไฟล์นี้
จะมีข้อมูล เช่น ตัวเลือกคอมไพเลอร์ แหล่งที่มาหรือไฟล์เอาต์พุตแบบทรานซิทีฟ
และข้อมูลเมตาของการบิลด์ มักใช้ร่วมกับ depsets เพื่อ
จัดเก็บข้อมูลแบบทรานซิทีฟที่สะสมไว้อย่างมีประสิทธิภาพ ตัวอย่างผู้ให้บริการในตัว
คือ DefaultInfo
ดูเพิ่มเติม: เอกสารประกอบของผู้ให้บริการ
การค้นหา (แนวคิด)
กระบวนการวิเคราะห์กราฟการสร้างเพื่อทําความเข้าใจคุณสมบัติเป้าหมายและโครงสร้างการขึ้นต่อกัน Bazel รองรับการค้นหา 3 รูปแบบ ได้แก่ query, cquery และ aquery
คำค้นหา (คำสั่ง)
เครื่องมือการค้นหาที่ทำงานในกราฟเป้าหมายของระยะหลังการโหลดของบิลด์ ซึ่งค่อนข้างรวดเร็ว
แต่ไม่สามารถวิเคราะห์ผลกระทบของ select(), build flags,
artifacts หรือ build actions ได้
ดูเพิ่มเติม: วิธีการค้นหา การอ้างอิงการค้นหา
แคชที่เก็บ
แคชที่แชร์ซึ่งระบุเนื้อหาของไฟล์ที่ Bazel ดาวน์โหลดมาสำหรับการบิลด์
ซึ่งแชร์ได้ในพื้นที่ทำงาน เปิดใช้การสร้างแบบออฟไลน์หลังจาก
การดาวน์โหลดครั้งแรก โดยทั่วไปจะใช้เพื่อแคชไฟล์ที่ดาวน์โหลดผ่านกฎที่เก็บ เช่น http_archive และ API กฎที่เก็บ เช่น repository_ctx.download ระบบจะแคชไฟล์ก็ต่อเมื่อมีการระบุผลรวมตรวจสอบ SHA-256 ของไฟล์สำหรับการดาวน์โหลด
ความสามารถในการทำซ้ำ
คุณสมบัติของบิลด์หรือการทดสอบที่ชุดอินพุตไปยังบิลด์หรือการทดสอบจะ สร้างชุดเอาต์พุตเดียวกันทุกครั้งเสมอ ไม่ว่าจะเป็นเวลา วิธีการ หรือสภาพแวดล้อม โปรดทราบว่าการดำเนินการนี้ไม่ได้หมายความว่าเอาต์พุตจะถูกต้องหรือเป็นเอาต์พุตที่ต้องการเสมอไป
กฎ
สคีมาสำหรับการกำหนดเป้าหมายของกฎในไฟล์ BUILD เช่น
cc_library ในมุมมองของBUILDผู้เขียนไฟล์ กฎประกอบด้วย
ชุดแอตทริบิวต์และตรรกะกล่องดำ ตรรกะจะบอกเป้าหมายของกฎวิธีสร้างเอาต์พุตอาร์ติแฟกต์และส่งข้อมูลไปยัง
เป้าหมายของกฎอื่นๆ ในมุมมองของ.bzlผู้เขียน กฎคือ
วิธีหลักในการขยาย Bazel เพื่อรองรับภาษาโปรแกรมและ
สภาพแวดล้อมใหม่ๆ
ระบบจะสร้างอินสแตนซ์ของกฎเพื่อสร้างเป้าหมายของกฎในเฟสการโหลด ในกฎระยะการวิเคราะห์ เป้าหมายจะสื่อสารข้อมูลไปยังการขึ้นต่อกันที่ดาวน์สตรีมในรูปแบบของผู้ให้บริการ และลงทะเบียนการดำเนินการที่อธิบายวิธี สร้างอาร์ติแฟกต์เอาต์พุต การดำเนินการเหล่านี้จะทำงานในระยะการดำเนินการ
ดูเพิ่มเติม: เอกสารประกอบเกี่ยวกับกฎ
เป้าหมายของกฎ
เป้าหมายที่เป็นอินสแตนซ์ของกฎ แตกต่างจากเป้าหมายไฟล์ และกลุ่มแพ็กเกจ อย่าสับสนกับกฎ
ไฟล์ที่เรียกใช้
ทรัพยากร Dependency ของรันไทม์ของเป้าหมายที่เรียกใช้งานได้ โดยส่วนใหญ่แล้ว ไฟล์ที่เรียกใช้งานได้คือเอาต์พุตที่เรียกใช้งานได้ของกฎการทดสอบ และไฟล์ที่เรียกใช้คือการขึ้นต่อกันของข้อมูลรันไทม์ ของการทดสอบ ก่อนเรียกใช้ไฟล์ที่เรียกใช้งานได้ (ระหว่าง bazel test) Bazel จะเตรียมโครงสร้างของไฟล์ที่เรียกใช้ได้ข้างไฟล์ที่เรียกใช้งานได้ของเทสต์ ตามโครงสร้างไดเรกทอรีแหล่งที่มา
ดูเพิ่มเติม: เอกสารประกอบเกี่ยวกับ Runfiles
แซนด์บ็อกซ์
เทคนิคในการแยกการดำเนินการที่กำลังทำงานอยู่ภายในรูทการดำเนินการที่จำกัดและชั่วคราว ซึ่งช่วยให้มั่นใจได้ว่าการดำเนินการจะไม่ อ่านอินพุตที่ไม่ได้ประกาศหรือเขียนเอาต์พุตที่ไม่ได้ประกาศ แซนด์บ็อกซ์ช่วยปรับปรุงความรัดกุมได้อย่างมาก แต่โดยปกติแล้วจะมีผลต่อประสิทธิภาพ และต้องได้รับการสนับสนุนจากระบบปฏิบัติการ ค่าใช้จ่ายด้านประสิทธิภาพจะขึ้นอยู่กับแพลตฟอร์ม ใน Linux จะไม่ส่งผลมากนัก แต่ใน macOS อาจทำให้ใช้แซนด์บ็อกซ์ไม่ได้
Skyframe
Skyframe เป็นเฟรมเวิร์กการประเมินแบบขนาน ฟังก์ชัน และแบบเพิ่มทีละรายการหลักของ Bazel
การปั๊มวัสดุ
ฟีเจอร์สำหรับฝังข้อมูลเพิ่มเติมลงในอาร์ติแฟกต์ที่สร้างด้วย Bazel
เช่น ใช้สำหรับการควบคุมแหล่งที่มา เวลาบิลด์
และข้อมูลอื่นๆ ที่เกี่ยวข้องกับพื้นที่ทำงานหรือสภาพแวดล้อมสำหรับบิลด์ที่เผยแพร่
เปิดใช้ผ่าน--workspace_status_commandฟีเจอร์ Flag และกฎที่รองรับแอตทริบิวต์แสตมป์
Starlark
ภาษาของส่วนขยายสำหรับการเขียนกฎและมาโคร ชุดย่อยของ Python ที่จำกัด (ตามไวยากรณ์และหลักภาษา) ซึ่งมีจุดมุ่งหมายเพื่อ
วัตถุประสงค์ในการกำหนดค่าและเพื่อประสิทธิภาพที่ดีขึ้น ใช้นามสกุลไฟล์ .bzl ไฟล์ BUILD ใช้ Starlark เวอร์ชันที่จำกัดมากยิ่งขึ้น (เช่น ไม่มีคำจำกัดความฟังก์ชัน def) ซึ่งก่อนหน้านี้รู้จักกันในชื่อ Skylark
ดูเพิ่มเติม: เอกสารประกอบเกี่ยวกับภาษา Starlark
แฟล็กเริ่มต้น
ชุดแฟล็กที่ระบุระหว่าง bazel กับคำสั่ง เช่น bazel --host_jvm_debug build แฟล็กเหล่านี้จะแก้ไขการกำหนดค่าของเซิร์ฟเวอร์ Bazel ดังนั้นการแก้ไขแฟล็กเริ่มต้นจะทำให้เซิร์ฟเวอร์รีสตาร์ท โดยแฟล็กการเริ่มต้นใช้งานไม่ได้เจาะจงคำสั่งใดคำสั่งหนึ่ง
เป้าหมาย
ออบเจ็กต์ที่กำหนดไว้ในไฟล์ BUILD และระบุด้วยป้ายกำกับ เป้าหมายแสดงถึงหน่วยที่สร้างได้ของพื้นที่ทํางานจากมุมมองของผู้ใช้ปลายทาง
เป้าหมายที่ประกาศโดยการสร้างอินสแตนซ์ของกฎเรียกว่าเป้าหมาย
กฎ เป้าหมายของกฎมักขึ้นอยู่กับเป้าหมายอื่นๆ ผ่านแอตทริบิวต์ (เช่น deps) การอ้างอิงเหล่านี้เป็นพื้นฐานของกราฟเป้าหมายcc_binarycc_test
นอกเหนือจากเป้าหมายกฎแล้ว ยังมีเป้าหมายไฟล์และเป้าหมายกลุ่มแพ็กเกจ
ด้วย เป้าหมายของไฟล์จะสอดคล้องกับอาร์ติแฟกต์ที่อ้างอิง
ภายในไฟล์ BUILD ในกรณีพิเศษ BUILD ไฟล์ของแพ็กเกจใดก็ตามจะ
ถือเป็นเป้าหมายไฟล์ต้นฉบับในแพ็กเกจนั้นเสมอ
ระบบจะค้นพบเป้าหมายในระยะการโหลด ในระยะการวิเคราะห์ เป้าหมายจะเชื่อมโยงกับการกำหนดค่า บิลด์เพื่อสร้างเป้าหมายที่กำหนดค่า
กราฟเป้าหมาย
กราฟในหน่วยความจำของเป้าหมายและการขึ้นต่อกัน สร้างขึ้นในระยะการโหลดและใช้เป็นข้อมูลนำเข้าในระยะการวิเคราะห์
รูปแบบเป้าหมาย
วิธีระบุกลุ่มเป้าหมายในบรรทัดคำสั่ง รูปแบบที่ใช้กันทั่วไปคือ :all (เป้าหมายกฎทั้งหมด), :* (เป้าหมายกฎ + ไฟล์ทั้งหมด),
... (แพ็กเกจปัจจุบันและแพ็กเกจย่อยทั้งหมดแบบเรียกซ้ำ) ใช้ร่วมกันได้ เช่น //...:* หมายถึงเป้าหมายของกฎและไฟล์ทั้งหมดในทุกแพ็กเกจแบบเรียกซ้ำจากรูทของพื้นที่ทำงาน
การทดสอบ
กฎ targets ที่สร้างขึ้นจากกฎการทดสอบจึงมี ไฟล์ที่เรียกใช้งานได้สำหรับการทดสอบ รหัสคืนค่าเป็น 0 จากการดำเนินการที่เรียกใช้งานได้ แสดงว่าการทดสอบสำเร็จ สัญญาที่แน่นอนระหว่าง Bazel กับการทดสอบ (เช่น ตัวแปรสภาพแวดล้อมของ การทดสอบ วิธีการรวบรวมผลการทดสอบ) จะระบุไว้ในสารานุกรมการทดสอบ
Toolchain
ชุดเครื่องมือสำหรับสร้างเอาต์พุตสำหรับภาษา โดยปกติแล้ว Toolchain จะมี คอมไพเลอร์ ลิงก์เกอร์ อินเทอร์พรีเตอร์ และ/หรือ Linter นอกจากนี้ Toolchain ยังอาจแตกต่างกันไปตาม แพลตฟอร์มด้วย กล่าวคือ คอมโพเนนต์ของ Toolchain คอมไพเลอร์ Unix อาจแตกต่างกันสำหรับ ตัวแปร Windows แม้ว่า Toolchain จะเป็นภาษาเดียวกันก็ตาม การเลือก เครื่องมือที่เหมาะสมสำหรับแพลตฟอร์มเรียกว่าการแก้ปัญหาเครื่องมือ
เป้าหมายระดับบนสุด
เป้าหมายการสร้างจะอยู่ที่ระดับบนสุดหากมีการขอในบรรทัดคำสั่ง Bazel
เช่น หาก //:foo ขึ้นอยู่กับ //:bar และมีการเรียกใช้ bazel build //:foo สำหรับบิลด์นี้ //:foo จะเป็นระดับบนสุด และ //:bar จะไม่ใช่ระดับบนสุด แม้ว่าทั้ง 2 เป้าหมายจะต้องสร้างก็ตาม ความแตกต่างที่สำคัญ
ระหว่างเป้าหมายระดับบนสุดและเป้าหมายที่ไม่ใช่ระดับบนสุดคือ แฟล็กคำสั่งที่ตั้งค่าในบรรทัดคำสั่ง Bazel (หรือผ่าน
.bazelrc) จะตั้งค่าการกำหนดค่าสำหรับเป้าหมายระดับบนสุด
แต่การเปลี่ยนอาจแก้ไขเป้าหมายที่ไม่ใช่ระดับบนสุด
ทรานซิชัน
การแมปสถานะการกำหนดค่าจากค่าหนึ่งไปยังอีกค่าหนึ่ง ช่วยให้เป้าหมายในกราฟการสร้างมีการกำหนดค่าที่แตกต่างกันได้ แม้ว่าจะสร้างอินสแตนซ์จากกฎเดียวกันก็ตาม การใช้งานการเปลี่ยนฉากที่พบบ่อยคือการเปลี่ยนฉากแบบแยก ซึ่งบางส่วนของกราฟเป้าหมายจะแยกออกพร้อมการกำหนดค่าที่แตกต่างกันสำหรับแต่ละส่วน ตัวอย่างเช่น คุณสามารถสร้าง APK ของ Android ด้วยไบนารีแบบเนทีฟที่คอมไพล์สำหรับ ARM และ x86 โดยใช้การเปลี่ยนผ่านแบบแยกในการสร้างครั้งเดียว
ดูเพิ่มเติม: การเปลี่ยนฉากที่ผู้ใช้กำหนด
อาร์ติแฟกต์ของทรี
อาร์ติแฟกต์ที่แสดงถึงคอลเล็กชันของไฟล์ เนื่องจากไฟล์เหล่านี้ไม่ใช่ Artifact Action ที่ดำเนินการกับไฟล์เหล่านี้จึงต้องลงทะเบียน Tree Artifact เป็นอินพุตหรือเอาต์พุตแทน
ระดับการแชร์
กลไก 2 อย่างที่ใช้ป้องกันการขึ้นต่อกันที่ไม่ต้องการในระบบบิลด์
ระดับการเข้าถึงเป้าหมายสำหรับการควบคุมว่าเป้าหมายอื่นจะขึ้นต่อกันได้หรือไม่
และระดับการเข้าถึงการโหลดสำหรับการควบคุมว่าไฟล์ BUILD
หรือ .bzl จะโหลดไฟล์ .bzl ที่กำหนดได้หรือไม่ โดยปกติแล้ว หากไม่มีบริบท "การมองเห็น" จะหมายถึงการมองเห็นเป้าหมาย
ดูเพิ่มเติม: เอกสารประกอบเกี่ยวกับระดับการเข้าถึง
Workspace
ไดเรกทอรีที่มีไฟล์ WORKSPACE และซอร์สโค้ดสำหรับซอฟต์แวร์ที่คุณต้องการสร้าง
ป้ายกำกับที่ขึ้นต้นด้วย // จะสัมพันธ์กับไดเรกทอรีพื้นที่ทำงาน
ไฟล์ WORKSPACE
กำหนดไดเรกทอรีให้เป็นพื้นที่ทำงาน ไฟล์นี้อาจว่างเปล่าได้ แม้ว่าโดยปกติแล้วจะมีประกาศที่เก็บภายนอกเพื่อดึงข้อมูล การอ้างอิงเพิ่มเติมจากเครือข่ายหรือระบบไฟล์ในเครื่อง