Allow concurrent, re-creatable usage

uuid_source.go

@@ -0,0 +1,54 @@
+package uuid
+
+import (
+	"io"
+	"crypto/rand"
+)
+
+// A UuidSource holds a random number generator and generates UUIDs using it as its source.
+//
+// It is useful when a process need its own random number generator, 
+// e.g. when running some processes concurrently.
+type UuidSource struct {
+	rander io.Reader
+}
+
+// Creates a new UuidSource which holds its own random number generator.
+//
+// Calling NewSource with nil sets the random number generator to a default
+// generator.
+func NewSource(r io.Reader) UuidSource {
+	var uuidSource UuidSource
+	uuidSource.SetRand(r)
+	return uuidSource
+
+}
+
+// SetRand sets the random number generator of the UuidSource to r, which implements io.Reader.
+// If r.Read returns an error when the package requests random data then
+// a panic will be issued.
+//
+// Calling SetRand with nil sets the random number generator to a default
+// generator.
+func (uuidSource *UuidSource) SetRand(r io.Reader) {
+	if r == nil {
+		uuidSource.rander = rand.Reader
+		return
+	}
+	uuidSource.rander = r
+}
+
+// NewRandom returns a Random (Version 4) UUID based on the random number generator in the UuidSource.
+//
+// See more detailed explanation here: https://godoc.org/github.com/google/uuid#NewRandom
+func (uuidSource UuidSource) NewRandom() (UUID, error) {
+	return newRandom(uuidSource.rander)
+}
+
+// New creates a new random UUID  based on the random number generator in the UuidSource or panics.  New is equivalent to
+// the expression
+//
+//    uuid.Must(uuid.NewRandom())
+func (uuidSource UuidSource) New() UUID {
+	return Must(uuidSource.NewRandom())
+}

uuid_source_test.go

@@ -0,0 +1,62 @@
+package uuid
+
+import (
+	"testing"
+	"strings"
+
+	regen "github.com/zach-klippenstein/goregen"
+)
+
+func TestUuidSources(t *testing.T) {
+
+	myString, _ := regen.Generate("[a-zA-Z]{1000}")
+
+	// Two identical sources, should give same sequence
+	uuidSourceA := NewSource(strings.NewReader(myString))
+	uuidSourceB := NewSource(strings.NewReader(myString))
+
+	for i := 0; i < 10; i++ {
+		uuid1 := uuidSourceA.New()
+		uuid2 := uuidSourceB.New()
+		if uuid1 != uuid2 {
+			t.Errorf("expected duplicates, got %q and %q", uuid1, uuid2)
+		}
+	}
+
+	// Set rander with nil, each source will be random
+	uuidSourceA.SetRand(nil)
+	uuidSourceB.SetRand(nil)
+
+	for i := 0; i < 10; i++ {
+		uuid1 := uuidSourceA.New()
+		uuid2 := uuidSourceB.New()
+		if uuid1 == uuid2 {
+		t.Errorf("unexpected duplicates, got %q", uuid1)
+		}
+	}
+
+	// Set rander to rand source with same seed, should give same sequence
+	uuidSourceA.SetRand(strings.NewReader(myString))
+	uuidSourceB.SetRand(strings.NewReader(myString))
+
+	for i := 0; i < 10; i++ {
+		uuid1 := uuidSourceA.New()
+		uuid2 := uuidSourceB.New()
+		if uuid1 != uuid2 {
+			t.Errorf("expected duplicates, got %q and %q", uuid1, uuid2)
+		}
+	}
+
+	// Set rander to rand source with different seeds, should not give same sequence
+	uuidSourceA.SetRand(strings.NewReader("456" + myString))
+	uuidSourceB.SetRand(strings.NewReader("myString" + myString))
+
+	for i := 0; i < 10; i++ {
+		uuid1 := uuidSourceA.New()
+		uuid2 := uuidSourceB.New()
+		if uuid1 == uuid2 {
+		t.Errorf("unexpected duplicates, got %q", uuid1)
+		}
+	}
+
+}

uuid_test.go

@@ -479,6 +479,27 @@ func TestBadRand(t *testing.T) {
 	}
 }
 
+func TestSetRand(t *testing.T) {
+	myString := "805-9dd6-1a877cb526c678e71d38-7122-44c0-9b7c-04e7001cc78783ac3e82-47a3-4cc3-9951-13f3339d88088f5d685a-11f7-4078-ada9-de44ad2daeb7"
+
+	SetRand(strings.NewReader(myString))
+	uuid1 := New()
+	uuid2 := New()
+
+	SetRand(strings.NewReader(myString))
+	uuid3 := New()
+	uuid4 := New()
+
+	if uuid1 != uuid3 {
+		t.Errorf("expected duplicates, got %q and %q", uuid1, uuid3)
+	}
+	if uuid2 != uuid4 {
+		t.Errorf("expected duplicates, got %q and %q", uuid2, uuid4)
+	}
+
+
+}
+
 var asString = "f47ac10b-58cc-0372-8567-0e02b2c3d479"
 var asBytes = []byte(asString)
 

version4.go

@@ -27,12 +27,17 @@ func New() UUID {
 //  equivalent to the odds of creating a few tens of trillions of UUIDs in a
 //  year and having one duplicate.
 func NewRandom() (UUID, error) {
+	return newRandom(rander)
+}
+
+func newRandom(r io.Reader) (UUID, error) {
 	var uuid UUID
-	_, err := io.ReadFull(rander, uuid[:])
+	_, err := io.ReadFull(r, uuid[:])
 	if err != nil {
 		return Nil, err
 	}
 	uuid[6] = (uuid[6] & 0x0f) | 0x40 // Version 4
 	uuid[8] = (uuid[8] & 0x3f) | 0x80 // Variant is 10
 	return uuid, nil
 }
+