web-dev-qa-db-fra.com

Versioning automatique de l'application

Est-il possible d'incrémenter automatiquement un numéro de version mineure chaque fois qu'une application Go est compilée?

J'aimerais définir un numéro de version dans mon programme, avec une section d'auto-incrémentation:

$ myapp -version
MyApp version 0.5.132

Etre 0.5 le numéro de version que j'ai défini et 132 une valeur qui s'incrémente automatiquement chaque fois que le binaire est compilé.

Est-ce possible dans Go?

go
167
Sebastián Grignoli

L'éditeur de liens Go ( lien outil go ) dispose d'une option permettant de définir la valeur d'une variable chaîne non initialisée:

-X importpath.name=value
  Set the value of the string variable in importpath named name to

valeur. Notez qu'avant Go 1.5, cette option prenait deux arguments séparés. Maintenant, il faut un argument divisé sur le premier signe =.

Dans le cadre de votre processus de construction, vous pouvez définir une variable de chaîne de version à l'aide de cette option. Vous pouvez passer cela via l'outil go en utilisant -ldflags. Par exemple, étant donné le fichier source suivant:

package main

import "fmt"

var xyz string

func main() {
    fmt.Println(xyz)
}

Ensuite:

$ go run -ldflags "-X main.xyz=abc" main.go
abc

Pour définir main.minversion sur la date et l’heure de construction lors de la construction:

go build -ldflags "-X main.minversion=`date -u +.%Y%m%d.%H%M%S`" service.go

Si vous compilez sans initialiser main.minversion de cette manière, il contiendra la chaîne vide.

306
axw

J'ai eu du mal à utiliser le paramètre -ldflags lors de la construction de mon application de ligne de commande et de bibliothèque combinées. J'ai donc utilisé une cible Makefile pour générer un fichier source Go contenant la version de mon application et la date de compilation:

BUILD_DATE := `date +%Y-%m-%d\ %H:%M`
VERSIONFILE := cmd/myapp/version.go

gensrc:
    rm -f $(VERSIONFILE)
    @echo "package main" > $(VERSIONFILE)
    @echo "const (" >> $(VERSIONFILE)
    @echo "  VERSION = \"1.0\"" >> $(VERSIONFILE)
    @echo "  BUILD_DATE = \"$(BUILD_DATE)\"" >> $(VERSIONFILE)
    @echo ")" >> $(VERSIONFILE)

Dans ma méthode init(), je fais ceci:

flag.Usage = func() {
    fmt.Fprintf(os.Stderr, "%s version %s\n", os.Args[0], VERSION)
    fmt.Fprintf(os.Stderr, "built %s\n", BUILD_DATE)
    fmt.Fprintln(os.Stderr, "usage:")
    flag.PrintDefaults()
}

Si vous voulez un numéro de build augmentant de manière atomique au lieu d'une date de build, vous devrez probablement créer un fichier local contenant le dernier numéro de build. Votre Makefile lirait le contenu du fichier dans une variable, l'incrémenterait, l'insérerait dans le fichier version.go à la place de la date et réécrirait le nouveau numéro de construction dans le fichier.

25
pegli

De plus, je voudrais poster un petit exemple sur l'utilisation de git et d'un makefile:

--- Makefile ----

# This how we want to name the binary output
BINARY=gomake

# These are the values we want to pass for VERSION and BUILD
# git tag 1.0.1
# git commit -am "One more change after the tags"
VERSION=`git describe --tags`
BUILD=`date +%FT%T%z`

# Setup the -ldflags option for go build here, interpolate the variable values
LDFLAGS_f1=-ldflags "-w -s -X main.Version=${VERSION} -X main.Build=${BUILD} -X main.Entry=f1"
LDFLAGS_f2=-ldflags "-w -s -X main.Version=${VERSION} -X main.Build=${BUILD} -X main.Entry=f2"

# Builds the project
build:
    go build ${LDFLAGS_f1} -o ${BINARY}_f1
    go build ${LDFLAGS_f2} -o ${BINARY}_f2

# Installs our project: copies binaries
install:
    go install ${LDFLAGS_f1}

# Cleans our project: deletes binaries
clean:
    if [ -f ${BINARY} ] ; then rm ${BINARY} ; fi

.PHONY: clean install

Le fichier make va créer deux exécutables. L'un exécute la fonction un, l'autre prend la fonction deux comme entrée principale:

package main

import (
        "fmt"
)

var (

        Version string
        Build   string
        Entry   string

        funcs = map[string]func() {
                "f1":functionOne,"f2":functionTwo,
        }

)

func functionOne() {
    fmt.Println("This is function one")
}

func functionTwo() {
    fmt.Println("This is function two")
}

func main() {

        fmt.Println("Version: ", Version)
        fmt.Println("Build Time: ", Build)

    funcs[Entry]()

}

Ensuite, lancez simplement:

make

Tu auras:

mab@h2470988:~/projects/go/gomake/3/gomake$ ls -al
total 2020
drwxrwxr-x 3 mab mab    4096 Sep  7 22:41 .
drwxrwxr-x 3 mab mab    4096 Aug 16 10:00 ..
drwxrwxr-x 8 mab mab    4096 Aug 17 16:40 .git
-rwxrwxr-x 1 mab mab 1023488 Sep  7 22:41 gomake_f1
-rwxrwxr-x 1 mab mab 1023488 Sep  7 22:41 gomake_f2
-rw-rw-r-- 1 mab mab     399 Aug 16 10:21 main.go
-rw-rw-r-- 1 mab mab     810 Sep  7 22:41 Makefile
mab@h2470988:~/projects/go/gomake/3/gomake$ ./gomake_f1
Version:  1.0.1-1-gfb51187
Build Time:  2016-09-07T22:41:38+0200
This is function one
mab@h2470988:~/projects/go/gomake/3/gomake$ ./gomake_f2
Version:  1.0.1-1-gfb51187
Build Time:  2016-09-07T22:41:39+0200
This is function two
19
Maciej A. Bednarz

utiliser multi -ldflags:

$ go build -ldflags "-X name1=value1 -X name2=value2" -o path/to/output
12
Kimia Zhu

Utilisez ldflags pour définir les variables dans le package main:

Avec le fichier main.go:

package main

import "fmt"

var (
    version string
    build   string
)

func main() {
    fmt.Println("version=", version)
    fmt.Println("build=", build)
}

Puis lancez:

go run \
  -ldflags "-X main.version=1.0.0 -X main.build=12082019" \ 
  main.go

Construire:

go build -o mybinary \
  -ldflags "-X main.version=1.0.0 -X 'main.build=$(date)'" \ 
  main.go

Utilisez ldflags pour définir une variable dans un package non -main:

Avec le fichier config.go:

package config

import "fmt"

var (
    Version string
)

func LogVersion() {
    fmt.Println("version=", Version)
}

Vous aurez également besoin du fichier main.go:

package main

import (
    "fmt"
    "github.com/user/repo/config"
}

func main() {
    config.LogVersion()
}

Construisez votre binaire en premier:

go build -o mybinary main.go

Recherchez le chemin complet du nom de variable que vous souhaitez définir:

go tool nm <path_to_binary> | grep Version

Exécutez et générez le binaire à nouveau, mais avec le ldflags:

go run \
  -ldflags "-X github.com/user/repo/config.Version=1.0.0" \
  main.go --version       


go build -o mybinary \
  -ldflags "-X github.com/user/repo/config.Version=1.0.0" \
  main.go

Inspiré par https://github.com/golang/go/wiki/GcToolchainTricks#including-build-information-in-the-executable

Aussi, si vous utilisez goreleaser, lisez ceci https://goreleaser.com/#using-the-main-version :

Par défaut, GoReleaser définit trois ldflags:

version principale: balise Git actuelle
main.commit: git actuel SHA
main.date: Date selon RFC3339

Si vous voulez voir ceci en action: https://github.com/hoto/fuzzy-repo-Finder/blob/master/pkg/config/config.go

11
Andrzej Rehmann

Sous Windows, avec le programme ci-dessous

package main

import "fmt"

var (
    version string
    date    string
)

func main() {
    fmt.Printf("version=%s, date=%s", version, date)
}

Vous pouvez construire en utilisant

go build -ldflags "-X main.version=0.0.1 -X main.date=%date:~10,4%-%date:~4,2%-%date:~7,2%T%time:~0,2%:%time:~3,2%:%time:~6,2%"

Le format de date suppose que votre environnement echo %date% est Fri 07/22/2016 et echo %time% est 16:21:52.88.

Ensuite, le résultat sera: version=0.0.1, date=2016-07-22T16:21:52

10
Ostati