Copied mongo repo (to patch it)

mongo/internal/uuid/uuid.go

@@ -0,0 +1,53 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package uuid
+
+import (
+	"io"
+
+	"go.mongodb.org/mongo-driver/internal/randutil"
+)
+
+// UUID represents a UUID.
+type UUID [16]byte
+
+// A source is a UUID generator that reads random values from a io.Reader.
+// It should be safe to use from multiple goroutines.
+type source struct {
+	random io.Reader
+}
+
+// new returns a random UUIDv4 with bytes read from the source's random number generator.
+func (s *source) new() (UUID, error) {
+	var uuid UUID
+	_, err := io.ReadFull(s.random, uuid[:])
+	if err != nil {
+		return UUID{}, err
+	}
+	uuid[6] = (uuid[6] & 0x0f) | 0x40 // Version 4
+	uuid[8] = (uuid[8] & 0x3f) | 0x80 // Variant is 10
+	return uuid, nil
+}
+
+// newSource returns a source that uses a pseudo-random number generator in reandutil package.
+// It is intended to be used to initialize the package-global UUID generator.
+func newSource() *source {
+	return &source{
+		random: randutil.NewLockedRand(),
+	}
+}
+
+// globalSource is a package-global pseudo-random UUID generator.
+var globalSource = newSource()
+
+// New returns a random UUIDv4. It uses a global pseudo-random number generator in randutil
+// at package initialization.
+//
+// New should not be used to generate cryptographically-secure random UUIDs.
+func New() (UUID, error) {
+	return globalSource.new()
+}

mongo/internal/uuid/uuid_test.go

@@ -0,0 +1,90 @@
+// Copyright (C) MongoDB, Inc. 2022-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package uuid
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// GODRIVER-2349
+// Test that initializing many package-global UUID sources concurrently never leads to any duplicate
+// UUIDs being generated.
+func TestGlobalSource(t *testing.T) {
+	t.Run("exp rand 1 UUID x 1,000,000 goroutines using a global source", func(t *testing.T) {
+		// Read a UUID from each of 1,000,000 goroutines and assert that there is never a duplicate value.
+		const iterations = 1e6
+		uuids := new(sync.Map)
+		var wg sync.WaitGroup
+		wg.Add(iterations)
+		for i := 0; i < iterations; i++ {
+			go func(i int) {
+				defer wg.Done()
+				uuid, err := New()
+				require.NoError(t, err, "new() error")
+				_, ok := uuids.Load(uuid)
+				require.Falsef(t, ok, "New returned a duplicate UUID on iteration %d: %v", i, uuid)
+				uuids.Store(uuid, true)
+			}(i)
+		}
+		wg.Wait()
+	})
+	t.Run("exp rand 1 UUID x 1,000,000 goroutines each initializing a new source", func(t *testing.T) {
+		// Read a UUID from each of 1,000,000 goroutines and assert that there is never a duplicate value.
+		// The goal is to emulate many separate Go driver processes starting at the same time and
+		// initializing the uuid package at the same time.
+		const iterations = 1e6
+		uuids := new(sync.Map)
+		var wg sync.WaitGroup
+		wg.Add(iterations)
+		for i := 0; i < iterations; i++ {
+			go func(i int) {
+				defer wg.Done()
+				s := newSource()
+				uuid, err := s.new()
+				require.NoError(t, err, "new() error")
+				_, ok := uuids.Load(uuid)
+				require.Falsef(t, ok, "New returned a duplicate UUID on iteration %d: %v", i, uuid)
+				uuids.Store(uuid, true)
+			}(i)
+		}
+		wg.Wait()
+	})
+	t.Run("exp rand 1,000 UUIDs x 1,000 goroutines each initializing a new source", func(t *testing.T) {
+		// Read 1,000 UUIDs from each goroutine and assert that there is never a duplicate value, either
+		// from the same goroutine or from separate goroutines.
+		const iterations = 1000
+		uuids := new(sync.Map)
+		var wg sync.WaitGroup
+		wg.Add(iterations)
+		for i := 0; i < iterations; i++ {
+			go func(i int) {
+				defer wg.Done()
+				s := newSource()
+				for j := 0; j < iterations; j++ {
+					uuid, err := s.new()
+					require.NoError(t, err, "new() error")
+					_, ok := uuids.Load(uuid)
+					require.Falsef(t, ok, "goroutine %d returned a duplicate UUID on iteration %d: %v", i, j, uuid)
+					uuids.Store(uuid, true)
+				}
+			}(i)
+		}
+		wg.Wait()
+	})
+}
+
+func BenchmarkUuidGeneration(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, err := New()
+		if err != nil {
+			panic(err)
+		}
+	}
+}