Ein praktisches Beispiel für gemeinsam genutzte Bibliotheken in einem Monorepo

Einer der mächtigsten Aspekte der Arbeit in einem Monorepo ist die Möglichkeit, Code zwischen Paketen/Teams/Hierarchien zu teilen. In diesem Beitrag werde ich versuchen, ein sehr einfaches Szenario aus der realen Welt zu erklären

Beispielszenario

Stellen Sie sich vor, Sie möchten eine Bibliothek entwickeln, um die Dateigrößen in Megabyte anzuzeigen, die Ihrer Meinung nach für andere Teile Ihres Monorepos nützlich sein könnten. Die Bibliothek akzeptiert die Größe als Ganzzahl (z. B. 2048 Byte) und kann eine humanisierte Zeichenfolge (z. B. 2 MB) zurückgeben. Um die Qualität zu sichern, werden wir auch einen Test dafür schreiben.

Wie ermöglicht Bazel das Teilen von Code?

Aus dem obigen Szenario ist uns bewusst, dass wir diese Funktion als gemeinsam genutzte Bibliothek entwickeln müssen, die dann von einem anderen Paket zur Verwendung importiert wird. Bazel macht dies extrem einfach, indem es uns ermöglicht, die Funktion in einer Bibliothek zu definieren und sie für andere Dienste zu exportieren, die sie benötigen. Wie in meinem früheren Beitrag am Ende dieses Beitrags erläutert, können wir auch steuern, welche anderen Bibliotheken es ebenfalls zur Verwendung importieren dürfen.

Beginnen wir mit dem Codieren

Zu Zwecken der Codeorganisation werden wir im Stammverzeichnis unseres Arbeitsbereichs ein Bibliotheksverzeichnis mit einem untergeordneten Verzeichnis namens humanize_filesize haben, in das wir unseren Bibliothekscode schreiben.

Lassen Sie uns einen sehr einfachen Go-Code in humanize_filesize.go schreiben

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

Dieser Code verwendet einfach einen int32 als Eingabe und gibt eine berechnete lesbare Megabyte-Zeichenfolge mit einer Genauigkeit von 4 Dezimalstellen zurück

Diese Funktion ist definitiv nicht umfassend und kann definitiv verbessert werden, aber das ist nicht der Sinn dieser Übung.

Um sicherzustellen, dass unsere Logik wie vorgesehen funktioniert, werden wir neben unserem Go-Code einen sehr einfachen Test in einer Datei namens humanize_filesize_test.go hinzufügen

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
}

Ein sehr einfacher Test mit grundlegenden Tests für Null, int32 und 0 als Eingaben

Jetzt kommt der heikle Teil, wie man diese Funktion exportiert, damit sie in andere Pakete oder Dienste importiert werden kann. Hier müssen wir die Datei BUILD.bazel definieren.

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"],
)

Hier definieren wir zwei Hauptregeln. Eine für die eigentliche Bibliothek und eine für die Testdatei, die wir geschrieben haben.

Die go_library definiert, dass das Ziel humanize_filesize humanize_filesize.go als eine seiner Quellen verwendet, die über den in importpath angegebenen Pfad importiert werden kann und im Arbeitsbereich öffentlich sichtbar ist, damit andere Pakete importiert werden können. Wie Sie die Sichtbarkeit steuern, erfahren Sie in einem zukünftigen Beitrag.

Der go_test definiert ein Testziel, das den Code aus der Ausgabe von go_library einbettet.

An diesem Punkt sollten wir in der Lage sein, die Bibliothek zu testen, indem wir unsere Testsuite wie folgt ausführen

bazel build //... && bazel run //libraries/humanize_filesize:humanize_filesize_test

Sie sollten die folgende Testausgabe sehen können, die anzeigt, dass alle Tests bestanden wurden.

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

? Wohoo!!! ? Jetzt wissen wir, dass unsere Bibliothek wie vorgesehen funktioniert.

Nun verwenden wir diese Bibliothek in einem Dienst service1 innerhalb eines Diensteverzeichnisses, das wir im Stammverzeichnis des Arbeitsbereichs mit dem folgenden Go-Code und der BUILD.bazel-Datei erstellen.

service1.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
}

BUILD.bazel

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"],
)

Der Go-Code ist ziemlich einfach. Er importiert unsere Bibliothek, die wir zuvor deklariert haben, verwendet die Funktion „GetHumanizedFilesize“ aus unserer Bibliothek, übergibt einen zufälligen ganzzahligen Wert und druckt die Ausgabe.

Wenn Sie nun bazel build //services/service1 ausführen, löst Bazel alle Abhängigkeiten für unser Ziel auf, einschließlich der von uns entwickelten Bibliothek, und erstellt sie.

service1 kann jetzt mit bazel run //services/service1 ausgeführt werden, da wir nur ein binäres Ziel definiert haben. Wenn Sie mehr als ein binäres Ziel haben, z. B. serviceX, können Sie dies mit bazel run //services/service1:serviceX ausführen. Wenn kein Ziel angegeben wird, versucht bazel standardmäßig immer, ein binäres Ziel mit demselben Namen wie das Verzeichnis zu finden und dieses auszuführen.

Also... los geht's. Wir haben Ihre erste gemeinsame Bibliothek erstellt, die von anderen Teilen unseres Monorepos genutzt werden kann.

Der gesamte Code für dieses Beispiel finden Sie unter https://github.com/nixclix/basil/pull/3/commits/61c673b8757860bd5e60eb2ab6c35f3f4da78c87

Wenn Ihnen der Inhalt dieses Beitrags gefällt, können Sie ihn gerne teilen. Bitte abonnieren Sie ihn auch und hinterlassen Sie Kommentare dazu, was Sie von diesem Beitrag halten und ob es Dinge gibt, bei denen Sie gerne sehen würden, dass ich mich verbessere.

Das obige ist der detaillierte Inhalt vonEin praktisches Beispiel für gemeinsam genutzte Bibliotheken in einem Monorepo. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!