मोनोरिपो में काम करने के सबसे शक्तिशाली पहलुओं में से एक पैकेज/टीम/पदानुक्रम के बीच कोड साझा करने की क्षमता है। इस पोस्ट में मैं एक बहुत ही सरल वास्तविक दुनिया परिदृश्य को समझाने की कोशिश करूंगा

उदाहरण परिदृश्य

कल्पना करें कि आप मेगाबाइट में फ़ाइल आकार दिखाने के लिए एक लाइब्रेरी विकसित करना चाहते हैं जो आपको लगता है कि आपके मोनोरेपो के अन्य हिस्सों के लिए उपयोगी हो सकती है। लाइब्रेरी आकार को पूर्णांक (उदा: 2048 बाइट्स) के रूप में स्वीकार करती है और एक मानवीकृत स्ट्रिंग (उदा: 2 एमबी) लौटा सकती है। कुछ गुणवत्ता आश्वासन जोड़ने के लिए, हम इसके लिए एक परीक्षण भी लिखेंगे।

बेज़ेल साझाकरण कोड को कैसे सक्षम करता है?

उपरोक्त परिदृश्य से हम जानते हैं कि हमें इस फ़ंक्शन को एक साझा लाइब्रेरी के रूप में विकसित करने की आवश्यकता है जिसे बाद में उपयोग के लिए किसी अन्य पैकेज द्वारा आयात किया जाएगा। बेज़ेल हमें लाइब्रेरी में फ़ंक्शन को परिभाषित करने और अन्य सेवाओं को निर्यात करने की अनुमति देकर इसे बेहद सरल बनाता है जिन्हें इसकी आवश्यकता होगी। जैसा कि इस पोस्ट के नीचे लिंक की गई मेरी पिछली पोस्ट में बताया गया है, हम यह भी नियंत्रित कर सकते हैं कि किन अन्य पुस्तकालयों को भी उपयोग के लिए इसे आयात करने की अनुमति दी जा सकती है।

आइए कोडिंग प्राप्त करें

कोड संगठन उद्देश्य के लिए, हमारे कार्यक्षेत्र के मूल में एक लाइब्रेरी निर्देशिका होगी जिसमें एक चाइल्ड निर्देशिका होगी जिसे humanize_filesize कहा जाएगा, जहां हम अपना लाइब्रेरी कोड लिखेंगे।

आइए humanize_filesize.go में कुछ बहुत ही प्राथमिक गो कोड लिखें

package humanize_filesize

import "fmt"

// GetHumanizedFilesize takes size_in_bytes as an int32 pointer and returns the size in megabytes.
func GetHumanizedFilesize(size_in_bytes *int32) string {
    if size_in_bytes != nil {
        size_in_megabytes := float64(*size_in_bytes) / (1024 * 1024)
        return fmt.Sprintf("%.4f MB", size_in_megabytes)
    }
    return "0 MB"
}

यह कोड बस एक int32 को इनपुट के रूप में लेता है और एक परिकलित पठनीय मेगाबाइट स्ट्रिंग को 4 दशमलव परिशुद्धता पर लौटाता है

यह फ़ंक्शन निश्चित रूप से व्यापक नहीं है और इसमें निश्चित रूप से सुधार किया जा सकता है, लेकिन यह इस अभ्यास का मुद्दा नहीं है।

यह भी दावा करें कि हमारा तर्क इरादा के अनुसार काम कर रहा है, हम humanize_filesize_test.go नामक फ़ाइल में अपने गो कोड के साथ एक बहुत ही प्रारंभिक परीक्षण जोड़ देंगे

package humanize_filesize

import (
    "testing"
)

func TestHumanizeFilesize(t *testing.T) {
    tests := []struct {
        name          string
        size_in_bytes *int32
        expected      string
    }{
        {
            name:          "nil bytes",
            size_in_bytes: nil,
            expected:      "0 MB",
        },
        {
            name:          "2048 bytes",
            size_in_bytes: int32Ptr(2048),
            expected:      "0.0020 MB",
        },
        {
            name:          "0 bytes",
            size_in_bytes: int32Ptr(0),
            expected:      "0.0000 MB",
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := GetHumanizedFilesize(tt.size_in_bytes)
            if result != tt.expected {
                t.Errorf("expected %s, got %s", tt.expected, result)
            }
        })
    }
}

func int32Ptr(n int32) *int32 {
    return &n
}

इनपुट के रूप में शून्य, int32 और 0 के लिए बुनियादी परीक्षणों के साथ एक बहुत ही सरल परीक्षण

अब इस फ़ंक्शन को निर्यात करने का दिलचस्प हिस्सा आता है ताकि इसे अन्य पैकेजों या सेवाओं में आयात किया जा सके। यहीं पर हमें BUILD.bazen फ़ाइल को परिभाषित करना है।

load("@rules_go//go:def.bzl", "go_library", "go_test")

go_library(
    name = "humanize_filesize",
    srcs = ["humanize_filesize.go"],
    importpath = "basil/libraries/humanize_filesize",
    visibility = ["//visibility:public"],
)

go_test(
    name = "humanize_filesize_test",
    srcs = ["humanize_filesize_test.go"],
    embed = [":humanize_filesize"],
)

यहां हम दो मुख्य नियमों को परिभाषित कर रहे हैं। एक वास्तविक लाइब्रेरी के लिए और एक हमारे द्वारा लिखी गई परीक्षण फ़ाइल के लिए।

go_library परिभाषित करता है कि लक्ष्य humanize_filesize अपने स्रोतों में से एक के रूप में humanize_filesize.go का उपयोग करता है जिसे आयातपथ में निर्दिष्ट पथ द्वारा आयात किया जा सकता है और यह आयात करने के लिए अन्य पैकेजों के लिए कार्यक्षेत्र के भीतर सार्वजनिक रूप से दिखाई देता है। हम भविष्य की पोस्ट में सीखेंगे कि दृश्यता को कैसे नियंत्रित किया जाए।

go_test एक परीक्षण लक्ष्य को परिभाषित करता है जो go_library के आउटपुट से कोड को एम्बेड करता है।

इस बिंदु पर हमें निम्नलिखित तरीके से अपना परीक्षण सूट चलाकर लाइब्रेरी का परीक्षण करने में सक्षम होना चाहिए

बेज़ल बिल्ड //... && बेज़ेल रन //लाइब्रेरी/ह्यूमनाइज़_फ़ाइलसाइज़: ह्यूमनाइज़_फ़ाइलसाइज़_टेस्ट

आपको परीक्षण आउटपुट इस प्रकार देखने में सक्षम होना चाहिए जो दर्शाता है कि सभी परीक्षण उत्तीर्ण हो गए हैं।

INFO: Analyzed target //libraries/humanize_filesize:humanize_filesize_test (0 packages loaded, 0 targets configured).
INFO: Found 1 target...
Target //libraries/humanize_filesize:humanize_filesize_test up-to-date:
  bazel-bin/libraries/humanize_filesize/humanize_filesize_test_/humanize_filesize_test
INFO: Elapsed time: 0.392s, Critical Path: 0.24s
INFO: 5 processes: 1 internal, 4 darwin-sandbox.
INFO: Build completed successfully, 5 total actions
INFO: Running command line: external/bazel_tools/tools/test/test-setup.sh libraries/humanize_filesize/humanize_filesize_test_/humanize_filesize_test
exec ${PAGER:-/usr/bin/less} "$0" || exit 1
Executing tests from //libraries/humanize_filesize:humanize_filesize_test
-----------------------------------------------------------------------------
PASS

? वाह!!! ? अब हम जानते हैं कि हमारी लाइब्रेरी इच्छानुसार काम कर रही है।

अब इस लाइब्रेरी का उपयोग एक सेवा निर्देशिका के भीतर एक सेवा सेवा1 में करें जिसे हम निम्नलिखित गो कोड और BUILD.bazen फ़ाइल के साथ कार्यक्षेत्र के मूल में बनाएंगे।

service1.go

package main

import (
    "basil/libraries/humanize_filesize"
    "fmt"
    "math/rand"
)

func main() {
    v := rand.Int31n(1000000)
    fmt.Printf(`%d bytes = %s\n`, v, humanize_filesize.GetHumanizedFilesize(&v))
}

BUILD.bazel

load("@rules_go//go:def.bzl", "go_binary", "go_library")

go_library(
    name = "service1_lib",
    srcs = ["service1.go"],
    importpath = "basil/services/service1",
    visibility = ["//visibility:private"],
    deps = ["//libraries/humanize_filesize"],
)

go_binary(
    name = "service1",
    embed = [":service1_lib"],
    visibility = ["//visibility:public"],
)

गो कोड बहुत सरल है जो हमारी लाइब्रेरी को आयात करता है जिसे हमने पहले घोषित किया था और हमारी लाइब्रेरी से GetHumanizedFilesize फ़ंक्शन का उपयोग करता है और एक यादृच्छिक पूर्णांक मान पास करता है और आउटपुट प्रिंट करता है।

अब जब बेज़ल बिल्ड //services/service1 निष्पादित करते हैं, तो बेज़ेल हमारे लक्ष्य के लिए हमारे द्वारा विकसित की गई लाइब्रेरी सहित सभी निर्भरताओं को हल करेगा और उनका निर्माण करेगा।

service1 को अब बेज़ल रन //services/service1 का उपयोग करके निष्पादित किया जा सकता है क्योंकि हमारे पास केवल एक बाइनरी लक्ष्य परिभाषित है। यदि आपके पास एक से अधिक बाइनरी लक्ष्य हैं, उदाहरण के लिए: सर्विसएक्स, तो आप बेज़ल रन //सर्विसेज/सर्विस1:सर्विसएक्स का उपयोग करके उसे निष्पादित कर सकते हैं। डिफ़ॉल्ट रूप से जब कोई लक्ष्य निर्दिष्ट नहीं किया जाता है, तो बेज़ेल हमेशा निर्देशिका के समान नाम के साथ एक बाइनरी लक्ष्य ढूंढने का प्रयास करेगा और उसे चलाएगा।

तो यह तूम गए वहाँ। हमने आपकी पहली साझा लाइब्रेरी बनाई है जिसका उपयोग हमारे मोनोरेपो के अन्य भागों द्वारा किया जा सकता है।

इस उदाहरण के लिए सभी कोड https://github.com/nixclix/basil/pull/3/commits/61c673b8757860bd5e60eb2ab6c35f3f4da78c87

यदि आपको इस पोस्ट की सामग्री पसंद आती है तो बेझिझक इसे साझा करें। इसके अलावा, कृपया सदस्यता लें और टिप्पणी छोड़ें कि आप इस पोस्ट के बारे में क्या सोचते हैं और क्या ऐसी चीजें हैं जिनमें आप मुझे सुधार करते देखना चाहेंगे।