go-aah/aah#21 guid generater added

Author: jeevatkm

guid.go

@@ -0,0 +1,102 @@
+// Copyright (c) Jeevanandam M. (https://github.com/jeevatkm)
+// go-aah/essentials source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package ess
+
+import (
+	"crypto/md5"
+	"crypto/rand"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"io"
+	"os"
+	"sync/atomic"
+	"time"
+)
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// GUID generation
+// Code inspired from mgo/bson ObjectId
+//___________________________________
+
+var (
+	// guidCounter is atomically incremented when generating a new GUID
+	// using UniqueID() function. It's used as a counter part of an id.
+	guidCounter = readRandomUint32()
+
+	// machineID stores machine id generated once and used in subsequent calls
+	// to UniqueId function.
+	machineID = readMachineID()
+
+	// processID is current Process Id
+	processID = os.Getpid()
+)
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Global methods
+//___________________________________
+
+// NewGUID method returns a new Globally Unique identifier (GUID).
+//
+// The 12-byte `UniqueId` consists of-
+//   - 4-byte value representing the seconds since the Unix epoch,
+//   - 3-byte machine identifier,
+//   - 2-byte process id, and
+//   - 3-byte counter, starting with a random value.
+//
+// NewGUID generation using Mongo Object ID algorithm to generate globally
+// unique ids - https://docs.mongodb.com/manual/reference/method/ObjectId/
+func NewGUID() string {
+	var b [12]byte
+	// Timestamp, 4 bytes, big endian
+	binary.BigEndian.PutUint32(b[:], uint32(time.Now().Unix()))
+
+	// Machine, first 3 bytes of md5(hostname)
+	b[4], b[5], b[6] = machineID[0], machineID[1], machineID[2]
+
+	// Pid, 2 bytes, specs don't specify endianness, but we use big endian.
+	b[7], b[8] = byte(processID>>8), byte(processID)
+
+	// Increment, 3 bytes, big endian
+	i := atomic.AddUint32(&guidCounter, 1)
+	b[9], b[10], b[11] = byte(i>>16), byte(i>>8), byte(i)
+
+	return hex.EncodeToString(b[:])
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Unexported methods
+//___________________________________
+
+// readRandomUint32 returns a random guidCounter.
+func readRandomUint32() uint32 {
+	var b [4]byte
+	if _, err := io.ReadFull(rand.Reader, b[:]); err == nil {
+		return (uint32(b[0]) << 0) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24)
+	}
+
+	panic(errors.New("ess - guid: unable to generate random object id"))
+}
+
+// readMachineID generates and returns a machine id.
+// If this function fails to get the hostname it will cause a runtime error.
+func readMachineID() []byte {
+	var sum [3]byte
+	id := sum[:]
+
+	if hostname, err := os.Hostname(); err == nil {
+		hw := md5.New()
+		_, _ = hw.Write([]byte(hostname))
+		copy(id, hw.Sum(nil))
+		return id
+	}
+
+	if _, err := io.ReadFull(rand.Reader, id); err == nil {
+		return id
+	}
+
+	// return nil, errors.New("guid: unable to get hostname and random bytes")
+	panic(errors.New("ess - guid: unable to get hostname and random bytes"))
+}

guid_test.go

@@ -0,0 +1,122 @@
+// Copyright (c) Jeevanandam M. (https://github.com/jeevatkm)
+// go-aah/essentials source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package ess
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"testing"
+	"time"
+
+	"aahframework.org/test.v0/assert"
+)
+
+func TestGUIDNew(t *testing.T) {
+	// Generate 10 ids
+	ids := make([]string, 10)
+	for i := 0; i < 10; i++ {
+		ids[i] = NewGUID()
+	}
+	for i := 1; i < 10; i++ {
+		prevID := ids[i-1]
+		id := ids[i]
+		// Test for uniqueness among all other 9 generated ids
+		for j, tid := range ids {
+			if j != i {
+				assert.NotEqualf(t, id, tid, "Generated ID is not unique")
+			}
+		}
+
+		// Check that timestamp was incremented and is within 30 seconds of the previous one
+		secs := getTime(id).Sub(getTime(prevID)).Seconds()
+		assert.Equalf(t, (secs >= 0 && secs <= 30), true, "wrong timestamp in generated Id")
+
+		// Check that machine ids are the same
+		assert.Equal(t, getMachine(id), getMachine(prevID))
+
+		// Check that pids are the same
+		assert.Equal(t, getPid(id), getPid(prevID))
+
+		// Test for proper increment
+		delta := int(getCounter(id) - getCounter(prevID))
+		assert.Equalf(t, delta, 1, "wrong increment in generated Id")
+	}
+}
+
+type guidParts struct {
+	id        string
+	timestamp int64
+	machine   []byte
+	pid       uint16
+	counter   int32
+}
+
+var uniqueIds = []guidParts{
+	guidParts{
+		"4d88e15b60f486e428412dc9",
+		1300816219,
+		[]byte{0x60, 0xf4, 0x86},
+		0xe428,
+		4271561,
+	},
+	guidParts{
+		"000000000000000000000000",
+		0,
+		[]byte{0x00, 0x00, 0x00},
+		0x0000,
+		0,
+	},
+	guidParts{
+		"00000000aabbccddee000001",
+		0,
+		[]byte{0xaa, 0xbb, 0xcc},
+		0xddee,
+		1,
+	},
+}
+
+func TestGUIDPartsExtraction(t *testing.T) {
+	for i, v := range uniqueIds {
+		assert.Equalf(t, getTime(v.id), time.Unix(v.timestamp, 0), "#%d timestamp", i)
+		assert.Equalf(t, getMachine(v.id), v.machine, "#%d machine", i)
+		assert.Equalf(t, getPid(v.id), v.pid, "#%d pid", i)
+		assert.Equalf(t, getCounter(v.id), v.counter, "#%d counter", i)
+	}
+}
+
+func BenchmarkNewGUID(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_ = NewGUID()
+		}
+	})
+}
+
+func getMachine(id string) []byte {
+	return byteSlice(id, 4, 7)
+}
+
+func getTime(id string) time.Time {
+	secs := int64(binary.BigEndian.Uint32(byteSlice(id, 0, 4)))
+	return time.Unix(secs, 0)
+}
+
+func getPid(id string) uint16 {
+	return binary.BigEndian.Uint16(byteSlice(id, 7, 9))
+}
+
+func getCounter(id string) int32 {
+	b := byteSlice(id, 9, 12)
+	// Counter is stored as big-endian 3-byte value
+	return int32(uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
+}
+
+func byteSlice(id string, s, e int) []byte {
+	if len(id) == 24 {
+		b, _ := hex.DecodeString(id)
+		return b[s:e]
+	}
+	return nil
+}