L'un des aspects les plus puissants du travail dans un monorepo est la possibilité de partager du code entre les packages/équipes/hiérarchies. Dans cet article, je vais essayer d'expliquer un scénario réel très simple

Exemple de scénario

Imaginez que vous souhaitiez développer une bibliothèque pour afficher la taille des fichiers en mégaoctets qui, selon vous, pourraient être utiles à d'autres parties de votre monorepo. La bibliothèque accepte la taille en entier (ex : 2048 octets) et peut renvoyer une chaîne humanisée (ex : 2 Mo). Pour ajouter une certaine assurance qualité, nous rédigerons également un test pour le même.

Comment Bazel permet-il le partage de code ?

D'après le scénario ci-dessus, nous sommes conscients que nous devons développer cette fonction en tant que bibliothèque partagée qui sera ensuite importée par un autre package pour être utilisée. Bazel rend cela extrêmement simple en nous permettant de définir la fonction dans une bibliothèque et de l'exporter vers d'autres services qui en auront besoin. Comme expliqué dans mon article précédent lié au bas de cet article, nous pouvons également contrôler quelles autres bibliothèques peuvent être autorisées à l'importer pour l'utiliser également.

Passons au codage

À des fins d'organisation du code, nous aurons un répertoire de bibliothèques à la racine de notre espace de travail avec un répertoire enfant appelé humanize_filesize dans lequel nous écrirons notre code de bibliothèque.

Écrivons du code Go très élémentaire dans 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"
}

Ce code prend simplement un int32 comme entrée et renvoie une chaîne de mégaoctets lisible calculée avec une précision de 4 décimales

Cette fonction n'est certainement pas exhaustive et peut certainement être améliorée, mais ce n'est pas le but de cet exercice.

Affirmons également que notre logique fonctionne comme prévu, nous ajouterons un test très élémentaire à côté de notre code go dans un fichier appelé 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
}

Un test très simple avec des tests de base pour nil, int32 et 0 comme entrées

Vient maintenant la partie intéressante de la façon d'exporter cette fonction afin qu'elle puisse être importée dans d'autres packages ou services. C'est ici que nous devons définir le fichier 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"],
)

Nous définissons ici deux règles principales. Un pour la bibliothèque réelle et un pour le fichier de test que nous avons écrit.

La go_library définit que la cible humanize_filesize utilise humanize_filesize.go comme l'une de ses sources qui peut être importée par le chemin spécifié dans importpath et elle est visible publiquement dans l'espace de travail pour que d'autres packages puissent l'importer. Nous apprendrons comment contrôler la visibilité dans un prochain article.

Le go_test définit une cible de test qui intègre le code de la sortie de go_library.

À ce stade, nous devrions pouvoir tester la bibliothèque en exécutant notre suite de tests comme suit

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

Vous devriez pouvoir voir le résultat du test comme suit, indiquant que tous les tests ont réussi.

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

 ? Waouh!!! ? Nous savons maintenant que notre bibliothèque fonctionne comme prévu.

Utilisons maintenant cette bibliothèque dans un service service1 au sein d'un répertoire de services que nous allons créer à la racine de l'espace de travail avec le code go suivant et le fichier BUILD.bazel.

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

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

Le code go est assez simple : il importe notre bibliothèque que nous avons déclarée précédemment et utilise la fonction GetHumanizedFilesize de notre bibliothèque, transmet une valeur entière aléatoire et imprime la sortie.

Maintenant, lors de l'exécution de bazel build //services/service1 , bazel résoudra toutes les dépendances de notre cible, y compris la bibliothèque que nous avons développée et les construira.

service1 peut désormais être exécuté à l'aide de bazel run //services/service1 puisque nous n'avons qu'une seule cible binaire définie. Si vous avez plusieurs cibles binaires, ex : serviceX, vous pouvez l'exécuter en utilisant bazel run //services/service1:serviceX. Par défaut, lorsqu'il ne spécifie pas de cible, Bazel essaiera toujours de trouver une cible binaire portant le même nom que le répertoire et l'exécutera.

Alors... voilà. Nous avons créé votre première bibliothèque partagée qui peut être utilisée par d'autres parties de notre monorepo.

Tout le code de cet exemple peut être trouvé sur https://github.com/nixclix/basil/pull/3/commits/61c673b8757860bd5e60eb2ab6c35f3f4da78c87

Si vous aimez le contenu de cet article, n'hésitez pas à le partager. N'hésitez pas également à vous abonner et à laisser des commentaires sur ce que vous pensez de cet article et s'il y a des choses que vous aimeriez que je améliore.