Application à la génération automatique de versioning

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

Je voudrais mettre un numéro de version à l'intérieur de mon programme, avec un autoincrementing section:

$ myapp -version
MyApp version 0.5.132

Être de 0,5 le numéro de version j'ai mis, et 132 une valeur qui s'incrémente automatiquement à chaque fois que le binaire est compilé.

Est-ce possible en matière de Go?

InformationsquelleAutor Sebastián Grignoli | 2012-07-06

304

La Aller de l'éditeur de liens (allez outil de lien) dispose d'une option pour définir la valeur d'un non initialisée variable de type string:
```
-X importpath.name=value
  Set the value of the string variable in importpath named name to
```
valeur.
Notez qu'avant d'Aller 1.5, cette option a eu deux arguments.
Maintenant, il prend un argument de split sur le premier signe=.

Dans le cadre de votre processus de création, vous pouvez créer une version variable de chaîne à l'aide de ce. Vous pouvez passer ce par le biais de la go outil à l'aide de -ldflags. Par exemple, pour le fichier source suivant:
```
package main

import "fmt"

var xyz string

func main() {
    fmt.Println(xyz)
}
```
Alors:
```
$ go run -ldflags "-X main.xyz=abc" main.go
abc
```
Afin de mettre en main.minversion à l'accumulation de la date et de l'heure lors de la construction:
```
go build -ldflags "-X main.minversion=`date -u +.%Y%m%d.%H%M%S`" service.go
```
Si vous compilez sans l'initialiser main.minversion de cette façon, il va contenir la chaîne de caractères vide.
- Cette valeur sera enregistrée dans le fichier binaire si j'utilise go bouild au lieu de go run?
- go build -ldflags "-X main.minversion `date -u +.%Y%m%d%.H%M%S`" service.go
- Cela ne semble pas fonctionner pour m'en Aller 1.1.1: $ go run -ldflags "-X main.xyz abc" main.go -> go run: no go files listed
- J'ai juste essayé de nouveau avec Go 1.1.1, et il a travaillé pour moi. De toute façon, "parcourir", c'est juste pour jouer, utilisez "aller construire" comme dans Sebastián commentaire.
- Si vous êtes sur Windows, en voici une que vous pouvez utiliser à partir de l'invite de commande: go build -ldflags "-X main.minversion \"%date%\"". Cela ne fonctionne pas sur LiteIDE bien.
- goxc fait pour vous 🙂 par défaut, il compile avec -ldflags "-Xmain.VERSION x.x.x -Xmain.BUILD_DATE CurrentDateInISO8601", mais vous pouvez configurer ces noms de variable si vous le souhaitez. Voir github.com/laher/goxc ... (disclaimer: j'ai écrit goxc)
- Remarque: -ldflags -X de travail pour les variables dans le paquet principal, mais pas pour les paquets. Voir groups.google.com/d/msg/golang-nuts/F6uxUrKZAsE/StdNt-CX3k4J
- date-u +.%Y%m%d,.%H%M%S
- Je crois que la dernière phrase n'est pas correcte: une chaîne de caractères ne peut pas être nul dans (quand il déclaré juste prend valeur de chaîne vide). Donc go build service.go marcherait aussi bien.
- exemple de travail avec de nouveaux 1.5 syntaxe pour l'ajout de la compilation variable go build -ldflags "-X 'main.buildtime=$(date -u '+%Y-%m-%d %H:%M:%S')'"
- Le xyz variable doit être exporté, sinon ça ne marche pas.
- J'ai juste copier / coller de l'exemple et il fonctionne très bien avec aller 1.5.
- notez que le nom complet du paquet est nécessaire. go build -ldflags "-X pkg.version=123" ne fonctionne pas alors que go build -ldflags "-X path/to/pkg.version=123" fonctionner comme prévu. espérons que cela aide.
- Est-ce à quelque sorte de travail pour une bibliothèque. Disons que je veux utiliser la bibliothèque dans l'autre main. Comment puis-je faire de cette ldflags valide lors de la construction de la bibliothèque?
- s'applique uniquement lorsque vous créez la dernière binaire. Vous devez fournir que chaque fois que vous créez un fichier binaire à l'aide de la bibliothèque.
- C'est pratique pour écraser des variables globales initialisées avec un message du genre: la construction n'a pas fourni cette valeur.
- oui cela fonctionne aussi pour une bibliothèque. si la bibliothèque est dans votre /vendor/ dossier le chemin/vers/pkg sera très long. par exemple, j'ai une bibliothèque que j'appelle instrulog qui est inclus dans mon fond travailleur rc-nag-notification-planificateur-travailleur d'aller construire -ldflags "-X bitbucket.org/newyuinc/rc-nag-notification-scheduler-worker/vendor/bitbucket.org/newyuinc/instrulog.Version=bd48434-dev"
- dans "-X principaux.xyz=abc" principal est le nom du paquet ou nom de fichier ou le nom de méthode?
- comme mentionné dans la sortie de l'aide, c'est la package chemin d'importation.
- Merci. Il a travaillé.
- merci beaucoup!
- est-il possible d'initialiser une structure de champ (de type string) avec cette méthode? Je veux logiquement groupe de quelques-uns de développer des valeurs - et en essayant de les mettre à dire "-X principaux.BuildInfo.GitHash=123abc7 -X principaux.BuildInfo.Unixtime=1541987669" n'a aucun effet sur la structure c'est à dire la structure des champs de type chaîne ont leur zéro valeurs.
- pas directement, vous auriez plutôt dû à l'initialisation de la structure de la variable de package au niveau de la chaîne de vars.
- "La variable de chaîne doit exister, il doit être une variable, pas une constante, et sa valeur ne doit pas être initialisé par un appel de fonction" github.com/golang/go/wiki/GcToolchainTricks
- Je crois que vous pouvez réellement initialiser déjà initialisé les variables, trop
InformationsquelleAutor axw
25

J'ai eu du mal à l'aide de la -ldflags paramètre lors de la création de mon mélangé de la ligne de commande de l'app et de la bibliothèque de projet, j'ai donc fini par utiliser un Makefile cible pour générer un Aller fichier source contenant mon application version 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 mon init() méthode, 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 vouliez une atomiquement l'augmentation de numéro de build au lieu d'une date de création, cependant, vous aurez probablement besoin de créer un fichier local qui contient le dernier numéro de build. Votre Makefile de lire le contenu du fichier dans une variable, l'incrémenter, de l'insérer dans le version.go fichier au lieu de la date, et d'écrire le nouveau numéro de version dans le fichier.
- Solution sympa. Pourtant, je crois que j'ai trouvé la raison pour la -ldflags ennuis. Si le fichier contenant la variable de mises à jour par -X n'est pas touché, alors la compilation ne se déclenche pas et vous avez l'ancienne version dans le fichier binaire. Ma solution était de toucher un petit fichier contenant uniquement de la variable en cours de réinitialisation via-ldflags "-X"..."
InformationsquelleAutor pegli

En outre, je tiens à poster un petit exemple de comment utiliser git et 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 de créer allons créer deux fichiers exécutables. Est en cours d'exécution de la fonction de l'un, l'autre prend la fonction de 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]()

}

Alors il suffit d'exécuter:

make

Vous obtiendrez:

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

Ou plus simple: il suffit de faire deux principaux dans deux répertoires différents. Cette solution semble être sérieusement overengineered.

InformationsquelleAutor Maciej A. Bednarz

à l'utilisation de plusieurs -ldflags:

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

InformationsquelleAutor Kimia Zhu

10

Sur Windows OS donné 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 créer 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%"
```
Format de Date suppose que votre environnement echo %date% est Fri 07/22/2016 et echo %time% est 16:21:52.88

Alors la sortie sera: version=0.0.1, date=2016-07-22T16:21:52
- Merci pour ce super solution! Je vais l'utiliser dans le github.com/pbek/lmdownload 😉
InformationsquelleAutor Ostati

Utilisation `ldflags` de définir des variables dans `main` package:

Avec fichier main.go:

package main

import "fmt"

var (
    version string
    build   string
)

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

Puis exécutez:

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

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

Avec fichier config.go:

package config

import "fmt"

var (
    Version string
)

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

Vous aurez également besoin de fichier main.go:

package main

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

func main() {
    config.LogVersion()
}

Construire votre binaire première:

go build -o mybinary main.go

Trouver le chemin d'accès complet du nom de la variable que vous souhaitez définir:

go tool nm <path_to_binary> | grep Version

Construire les binaires à nouveau, mais avec la 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 êtes en utilisant goreleaser alors lisez cette https://goreleaser.com/#using-the-main-version:

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

principal.version: Courant Git tag

principal.commit: Courant git commit SHA

principal.date: date selon RFC3339

InformationsquelleAutor Andrzej Rehmann

Vous devez vous connecter pour publier un commentaire.

Utilisation ldflags de définir des variables dans main package:

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

Utilisation `ldflags` de définir des variables dans `main` package:

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