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 reales Szenario 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 eine gewisse Qualitätssicherung zu gewährleisten, werden wir auch einen Test dafür schreiben.

Wie ermöglicht Bazel das Teilen von Code?

Aus dem obigen Szenario wissen wir, 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 nimmt einfach einen int32 als Eingabe und gibt einen berechneten lesbaren Megabyte-String 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.

Stellen Sie außerdem sicher, dass unsere Logik wie vorgesehen funktioniert. Wir werden 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 man die Sichtbarkeit steuert, 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 Testausgabe wie folgt sehen können, was darauf hinweist, dass alle Tests bestanden wurden.

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

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

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 verwendet 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 auch und hinterlassen Sie Kommentare dazu, was Sie über diesen Beitrag denken und ob es Dinge gibt, bei denen ich mich gerne verbessern würde.