Merge master into breakout_swarm

Signed-off-by: Alex Ellis <alexellis2@gmail.com>

gateway/vendor/github.com/nats-io/nuid/.gitignore

@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof

gateway/vendor/github.com/nats-io/nuid/.travis.yml

@@ -0,0 +1,16 @@
+language: go
+sudo: false
+go:
+- 1.5
+
+install:
+- go get -t ./...
+- go get github.com/mattn/goveralls
+
+script:
+- go fmt ./...
+- go vet ./...
+- go test -v
+- go test -v --race
+- go test -v -covermode=count -coverprofile=coverage.out
+- $HOME/gopath/bin/goveralls -coverprofile coverage.out -service travis-ci

gateway/vendor/github.com/nats-io/nuid/README.md

@@ -35,8 +35,8 @@ NUID needs to be very fast to generate and be truly unique, all while being entr
 NUID uses 12 bytes of crypto generated data (entropy draining), and 10 bytes of pseudo-random
 sequential data that increments with a pseudo-random increment.
 
-Total length of a NUID string is 22 bytes of base 62 ascii text, so 62^22 or
-2707803647802660400290261537185326956544 possibilities.
+Total length of a NUID string is 22 bytes of base 36 ascii text, so 36^22 or
+17324272922341479351919144385642496 possibilities.
 
 NUID can generate identifiers as fast as 60ns, or ~16 million per second. There is an associated
 benchmark you can use to test performance on your own hardware.

gateway/vendor/github.com/nats-io/nuid/nuid_test.go

@@ -0,0 +1,79 @@
+package nuid
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestDigits(t *testing.T) {
+	if len(digits) != base {
+		t.Fatalf("digits length does not match base modulo")
+	}
+}
+
+func TestGlobalNUIDInit(t *testing.T) {
+	if globalNUID == nil {
+		t.Fatalf("Expected g to be non-nil\n")
+	}
+	if globalNUID.pre == nil || len(globalNUID.pre) != preLen {
+		t.Fatalf("Expected prefix to be initialized\n")
+	}
+	if globalNUID.seq == 0 {
+		t.Fatalf("Expected seq to be non-zero\n")
+	}
+}
+
+func TestNUIDRollover(t *testing.T) {
+	globalNUID.seq = maxSeq
+	// copy
+	oldPre := append([]byte{}, globalNUID.pre...)
+	Next()
+	if bytes.Equal(globalNUID.pre, oldPre) {
+		t.Fatalf("Expected new pre, got the old one\n")
+	}
+}
+
+func TestGUIDLen(t *testing.T) {
+	nuid := Next()
+	if len(nuid) != totalLen {
+		t.Fatalf("Expected len of %d, got %d\n", totalLen, len(nuid))
+	}
+}
+
+func TestProperPrefix(t *testing.T) {
+	min := byte(255)
+	max := byte(0)
+	for i := 0; i < len(digits); i++ {
+		if digits[i] < min {
+			min = digits[i]
+		}
+		if digits[i] > max {
+			max = digits[i]
+		}
+	}
+	total := 100000
+	for i := 0; i < total; i++ {
+		n := New()
+		for j := 0; j < preLen; j++ {
+			if n.pre[j] < min || n.pre[j] > max {
+				t.Fatalf("Iter %d. Valid range for bytes prefix: [%d..%d]\nIncorrect prefix at pos %d: %v (%s)",
+					i, min, max, j, n.pre, string(n.pre))
+			}
+		}
+	}
+}
+
+func BenchmarkNUIDSpeed(b *testing.B) {
+	n := New()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		n.Next()
+	}
+}
+
+func BenchmarkGlobalNUIDSpeed(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		Next()
+	}
+}

gateway/vendor/github.com/nats-io/nuid/unique_test.go

@@ -0,0 +1,19 @@
+// +build !race
+
+package nuid
+
+import (
+	"testing"
+)
+
+func TestBasicUniqueness(t *testing.T) {
+	n := 10000000
+	m := make(map[string]struct{}, n)
+	for i := 0; i < n; i++ {
+		n := Next()
+		if _, ok := m[n]; ok {
+			t.Fatalf("Duplicate NUID found: %v\n", n)
+		}
+		m[n] = struct{}{}
+	}
+}