Existe-t-il une méthode pour générer un UUID avec go language

J'ai du code qui ressemble à ceci:

u := make([]byte, 16)
_, err := rand.Read(u)
if err != nil {
    return
}

u[8] = (u[8] | 0x80) & 0xBF // what does this do?
u[6] = (u[6] | 0x40) & 0x4F // what does this do?

return hex.EncodeToString(u)

Il renvoie une chaîne d'une longueur de 32, mais je ne pense pas que ce soit un UUID valide. S'il s'agit d'un UUID réel, pourquoi s'agit-il d'un UUID et quel est le but du code qui modifie la valeur de u[8]et u[6].

Existe-t-il un meilleur moyen de générer des UUID?

u[8] = (u[8] | 0x80) & 0xBF // what's the purpose ?
u[6] = (u[6] | 0x40) & 0x4F // what's the purpose ?

Ces lignes fixent les valeurs des octets 6 et 8 à une plage spécifique. rand.Readrenvoie des octets aléatoires dans la plage 0-255, qui ne sont pas toutes des valeurs valides pour un UUID. Pour autant que je sache, cela devrait être fait pour toutes les valeurs de la tranche.

Si vous êtes sous Linux, vous pouvez également appeler /usr/bin/uuidgen.

package main

import (
    "fmt"
    "log"
    "os/exec"
)

func main() {
    out, err := exec.Command("uuidgen").Output()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s", out)
}

Ce qui donne:

$ go run uuid.go 
dc9076e9-2fda-4019-bd2c-900a8284b9c4

Vous pouvez générer des UUID à l'aide de la bibliothèque go-uuid . Cela peut être installé avec:

go get github.com/nu7hatch/gouuid

Vous pouvez générer des UUID aléatoires (version 4) avec:

import "github.com/nu7hatch/gouuid"

...

u, err := uuid.NewV4()

Le UUIDtype renvoyé est un tableau de 16 octets, vous pouvez donc récupérer facilement la valeur binaire. Il fournit également la représentation sous forme de chaîne hexadécimale standard via sa String()méthode.

Le code que vous avez semble également générer un UUID version 4 valide: la manipulation au niveau du bit que vous effectuez à la fin définit les champs de version et de variante de l'UUID pour l' identifier correctement comme version 4 . Ceci est fait pour distinguer les UUID aléatoires de ceux générés via d'autres algorithmes (par exemple, les UUID de la version 1 en fonction de votre adresse MAC et de l'heure).

La go-uuidbibliothèque n'est PAS conforme à la RFC4122. Les bits de variante ne sont pas définis correctement. Des membres de la communauté ont tenté à plusieurs reprises de corriger ce problème, mais les pull requests pour le correctif ne sont pas acceptées.

Vous pouvez générer des UUID à l'aide de la bibliothèque Go uuid que j'ai réécrite en fonction de la go-uuidbibliothèque. Il existe plusieurs correctifs et améliorations. Cela peut être installé avec:

go get github.com/twinj/uuid

Vous pouvez générer des UUID aléatoires (version 4) avec:

import "github.com/twinj/uuid"

u := uuid.NewV4()

Le type UUID renvoyé est une interface et le type sous-jacent est un tableau.

La bibliothèque génère également des UUID v1 et génère correctement des UUID v3 et 5. Il existe plusieurs nouvelles méthodes pour faciliter l'impression et le formatage, ainsi que de nouvelles méthodes générales pour créer des UUID basés sur des données existantes.

"crypto / rand" est un paquet multiplateforme pour la génération aléatoire d'octets

package main

import (
    "crypto/rand"
    "fmt"
)

// Note - NOT RFC4122 compliant
func pseudo_uuid() (uuid string) {

    b := make([]byte, 16)
    _, err := rand.Read(b)
    if err != nil {
        fmt.Println("Error: ", err)
        return
    }

    uuid = fmt.Sprintf("%X-%X-%X-%X-%X", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])

    return
}

Il existe une mise en œuvre officielle par Google: https://github.com/google/uuid

La génération d'un UUID version 4 fonctionne comme ceci:

package main

import (
    "fmt"
    "github.com/google/uuid"
)

func main() {
    id := uuid.New()
    fmt.Println(id.String())
}

Essayez-le ici: https://play.golang.org/p/6YPi1djUMj9

gofrs / uuid est le remplacement de satori / go.uuid , qui est le package UUID le plus étoilé pour Go . Il prend en charge les versions 1 à 5 d'UUID et est conforme aux normes RFC 4122 et DCE 1.1.

import "github.com/gofrs/uuid"

// Create a Version 4 UUID, panicking on error
u := uuid.Must(uuid.NewV4())

D' après le message de Russ Cox :

Il n'y a pas de bibliothèque officielle. En ignorant la vérification des erreurs, cela semble fonctionner correctement:

f, _ := os.Open("/dev/urandom")
b := make([]byte, 16)
f.Read(b)
f.Close()
uuid := fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])

Remarque: dans la version originale, antérieure à Go 1, la première ligne était:

f, _ := os.Open("/dev/urandom", os.O_RDONLY, 0)

Ici, il compile et exécute, ne /dev/urandomrenvoie que tous les zéros dans la cour de récréation. Devrait bien fonctionner localement.

Dans le même fil, il y a d'autres méthodes / références / packages trouvés.

Dans le cadre de la spécification uuid, si vous générez un uuid aléatoire, il doit contenir un "4" comme 13ème caractère et un "8", "9", "a" ou "b" dans le 17ème ( source ).

// this makes sure that the 13th character is "4"
u[6] = (u[6] | 0x40) & 0x4F
// this makes sure that the 17th is "8", "9", "a", or "b"
u[8] = (u[8] | 0x80) & 0xBF 

Le package gorand a une méthode UUID qui renvoie un UUID version 4 (généré de manière aléatoire) dans sa représentation sous forme de chaîne canonique ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") et il est conforme à la RFC 4122.

Il utilise également le package crypto / rand pour garantir la génération d'UUID la plus sécurisée du point de vue cryptographique sur toutes les plates-formes prises en charge par Go.

import "github.com/leonelquinteros/gorand"

func main() {
    uuid, err := gorand.UUID()
    if err != nil {
        panic(err.Error())
    }

    println(uuid)
} 

Sous Linux, vous pouvez lire à partir de /proc/sys/kernel/random/uuid:

package main

import "io/ioutil"
import "fmt"

func main() {
    u, _ := ioutil.ReadFile("/proc/sys/kernel/random/uuid")
    fmt.Println(string(u))
}

Pas de dépendances externes!

$ go run uuid.go 
3ee995e3-0c96-4e30-ac1e-f7f04fd03e44

Pour Windows, j'ai fait récemment ceci:

// +build windows

package main

import (
    "syscall"
    "unsafe"
)

var (
    modrpcrt4 = syscall.NewLazyDLL("rpcrt4.dll")
    procUuidCreate = modrpcrt4.NewProc("UuidCreate")
)

const (
    RPC_S_OK = 0
)

func NewUuid() ([]byte, error) {
    var uuid [16]byte
    rc, _, e := syscall.Syscall(procUuidCreate.Addr(), 1,
             uintptr(unsafe.Pointer(&uuid[0])), 0, 0)
    if int(rc) != RPC_S_OK {
        if e != 0 {
            return nil, error(e)
        } else {
            return nil, syscall.EINVAL
        }
    }
    return uuid[:], nil
}

Cette bibliothèque est notre standard pour la génération et l'analyse d'uuid:

https://github.com/pborman/uuid