feature(codes): move away from wordlist generation to simple PIN (4-digits) code generation.

Author: collapsinghierarchy

.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = tab
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false

internal/rendezvous/codes.go

@@ -22,15 +22,19 @@ type CodeEntry struct {
 }
 
 type Store struct {
-	mu           sync.RWMutex
-	codes        map[string]*CodeEntry // code -> entry
-	appToCode    map[string]string     // appID -> code
-	pregen       chan string           // optional pregen pool
-	ttl          time.Duration
-	words        []string
-	perm         []int // permutation of [0..len(words)-1], set once
-	singleIdx    int   // rotating cursor for single-word picks
-	pairA, pairB int   // rotating cursors for two-word pairs
+	mu        sync.RWMutex
+	codes     map[string]*CodeEntry // code -> entry
+	appToCode map[string]string     // appID -> code
+	pregen    chan string           // optional pregen pool
+	ttl       time.Duration
+
+	// The following fields are kept for backward-compat constructors but unused
+	// now that codes are PINs. Safe to remove later if desired.
+	words     []string
+	perm      []int
+	singleIdx int
+	pairA     int
+	pairB     int
 }
 
 func NewStore(words []string, ttl time.Duration, pregenCap int) *Store {
@@ -43,19 +47,6 @@ func NewStore(words []string, ttl time.Duration, pregenCap int) *Store {
 		ttl:       ttl,
 		words:     words,
 	}
-	if n := len(words); n > 0 {
-		s.perm = make([]int, n)
-		for i := 0; i < n; i++ {
-			s.perm[i] = i
-		}
-		// Fisher–Yates with crypto/rand
-		for i := n - 1; i > 0; i-- {
-			j, err := randInt(i + 1)
-			if err == nil && j != i {
-				s.perm[i], s.perm[j] = s.perm[j], s.perm[i]
-			}
-		}
-	}
 	if pregenCap > 0 {
 		s.pregen = make(chan string, pregenCap)
 		go s.pregenerator()
@@ -139,6 +130,7 @@ func (s *Store) pregenerator() {
 		}
 		code, err := s.newUniqueCode()
 		if err != nil {
+			// If space is temporarily exhausted, back off a bit.
 			time.Sleep(20 * time.Millisecond)
 			continue
 		}
@@ -166,6 +158,7 @@ func (s *Store) takeCodeFromPool() (string, bool) {
 }
 
 func (s *Store) newUniqueCode() (string, error) {
+	// Fast attempts first.
 	for tries := 0; tries < 8; tries++ {
 		c, err := s.generateCode()
 		if err != nil {
@@ -178,6 +171,7 @@ func (s *Store) newUniqueCode() (string, error) {
 			return c, nil
 		}
 	}
+	// Keep trying until we find a free PIN (or space is exhausted).
 	for {
 		c, err := s.generateCode()
 		if err != nil {
@@ -192,103 +186,39 @@ func (s *Store) newUniqueCode() (string, error) {
 	}
 }
 
+// generateCode now produces a unique 4-digit PIN "0000".."9999".
 func (s *Store) generateCode() (string, error) {
-	// We need to see what's currently allocated, and advance our fair cursors.
+	const maxPins = 10000
+
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	// 1) Try single-word pool.
-	if code, ok := s.pickSingleLocked(); ok {
-		return code, nil
+	// If the entire PIN space is allocated, bail out.
+	if len(s.codes) >= maxPins {
+		return "", errors.New("PIN space exhausted")
 	}
-	// 2) All single words are currently allocated -> try two-word pool.
-	if code, ok := s.pickPairLocked(); ok {
-		return code, nil
-	}
-	// 3) Extremely unlikely to get here. Fall back to legacy generator (4 words + 4 digits).
-	return s.generateLegacyUnlocked()
-}
 
-// pickSingleLocked returns an unused single-word code if available.
-// Requires s.mu to be held (write lock) because it advances s.singleIdx.
-func (s *Store) pickSingleLocked() (string, bool) {
-	n := len(s.words)
-	if n == 0 {
-		return "", false
-	}
-	if len(s.perm) != n {
-		// Safety: build a basic permutation if not set (shouldn't happen).
-		s.perm = make([]int, n)
-		for i := range s.perm {
-			s.perm[i] = i
+	// Try a handful of random picks first.
+	for tries := 0; tries < 16; tries++ {
+		n, err := randInt(maxPins)
+		if err != nil {
+			return "", err
 		}
-	}
-	for tried := 0; tried < n; tried++ {
-		idx := s.perm[(s.singleIdx+tried)%n]
-		w := s.words[idx]
-		if _, inUse := s.codes[w]; !inUse {
-			// Reserve this candidate by advancing the cursor; actual insertion happens in CreateCode.
-			s.singleIdx = (s.singleIdx + tried + 1) % n
-			return w, true
+		pin := fmt.Sprintf("%04d", n)
+		if _, inUse := s.codes[pin]; !inUse {
+			return pin, nil
 		}
 	}
-	return "", false
-}
 
-// pickPairLocked returns an unused two-word code "w1-w2" if available.
-// Requires s.mu to be held (write lock) because it advances s.pairA/B.
-func (s *Store) pickPairLocked() (string, bool) {
-	n := len(s.words)
-	if n == 0 {
-		return "", false
-	}
-	if len(s.perm) != n {
-		s.perm = make([]int, n)
-		for i := range s.perm {
-			s.perm[i] = i
+	// Fallback: linear scan to find any free PIN.
+	for i := 0; i < maxPins; i++ {
+		pin := fmt.Sprintf("%04d", i)
+		if _, inUse := s.codes[pin]; !inUse {
+			return pin, nil
 		}
 	}
-	// Scan n*n pairs in a rotating manner.
-	for scanned := 0; scanned < n*n; scanned++ {
-		a := s.words[s.perm[s.pairA]]
-		b := s.words[s.perm[s.pairB]]
-		code := a + "-" + b
-
-		// Move pairB then roll into pairA
-		s.pairB++
-		if s.pairB >= n {
-			s.pairB = 0
-			s.pairA = (s.pairA + 1) % n
-		}
-
-		if _, inUse := s.codes[code]; !inUse {
-			return code, true
-		}
-	}
-	return "", false
-}
 
-// generateLegacyUnlocked reproduces the old style code (4 words + 4 digits).
-// Requires s.mu to be held (write lock) only because we share randInt; it doesn't mutate s.
-func (s *Store) generateLegacyUnlocked() (string, error) {
-	const wordsPerCode = 4
-	if len(s.words) < 2 {
-		return "", errors.New("wordlist too small")
-	}
-	parts := make([]string, 0, wordsPerCode+1)
-	for i := 0; i < wordsPerCode; i++ {
-		idx, err := randInt(len(s.words))
-		if err != nil {
-			return "", err
-		}
-		parts = append(parts, s.words[idx])
-	}
-	d, err := randInt(10000) // 0000..9999
-	if err != nil {
-		return "", err
-	}
-	parts = append(parts, fmt.Sprintf("%04d", d))
-	return strings.ToLower(strings.Join(parts, "-")), nil
+	return "", errors.New("PIN space exhausted")
 }
 
 func randInt(n int) (int, error) {

internal/rendezvous/codes_smart_test.go

@@ -2,46 +2,59 @@ package rendezvous
 
 import (
 	"context"
+	"regexp"
 	"testing"
 	"time"
 )
 
-func Test_SingleThenPairs(t *testing.T) {
-	words := []string{"alpha", "bravo", "charlie"}
-	s := NewStore(words, 5*time.Minute, 0)
+func Test_Generates4DigitPins_UniqueAndRedeemable(t *testing.T) {
+	s := NewStore(nil, 2*time.Minute, 0)
 
 	seen := map[string]bool{}
-	var singles int
+	re := regexp.MustCompile(`^\d{4}$`)
 
-	// Allocate more than len(words) to force pairs.
-	for i := 0; i < len(words)+2; i++ {
-		code, appID, _, err := s.CreateCode(context.Background())
+	// Generate a healthy number of codes to exercise collisions/uniqueness.
+	for i := 0; i < 500; i++ {
+		code, appID, exp, err := s.CreateCode(context.Background())
 		if err != nil {
 			t.Fatalf("create: %v", err)
 		}
+		if !re.MatchString(code) {
+			t.Fatalf("code not 4 digits: %q", code)
+		}
 		if seen[code] {
-			t.Fatalf("duplicate code: %s", code)
+			t.Fatalf("duplicate code generated: %s", code)
 		}
 		seen[code] = true
+
 		if appID == "" {
 			t.Fatalf("missing appID")
 		}
-		if countHyphens(code) == 0 {
-			singles++
+		if time.Until(exp) <= 0 {
+			t.Fatalf("bad expiry")
 		}
-	}
 
-	if singles != len(words) {
-		t.Fatalf("expected %d singles first, got %d", len(words), singles)
+		// Redeem should return the same appID/exp.
+		gotApp, gotExp, ok := s.RedeemCode(context.Background(), code)
+		if !ok {
+			t.Fatalf("redeem failed for %s", code)
+		}
+		if gotApp != appID || !gotExp.Equal(exp) {
+			t.Fatalf("redeem mismatch: want (%s,%v) got (%s,%v)", appID, exp, gotApp, gotExp)
+		}
 	}
 }
 
-func countHyphens(s string) int {
-	n := 0
-	for _, r := range s {
-		if r == '-' {
-			n++
+func Test_PinSpaceExhaustion(t *testing.T) {
+	// Very short TTL means janitor might free, but we won't sleep, so map only grows.
+	s := NewStore(nil, time.Hour, 0)
+	for i := 0; i < 10000; i++ {
+		if _, _, _, err := s.CreateCode(context.Background()); err != nil {
+			t.Fatalf("unexpected error before exhaustion: %v", err)
 		}
 	}
-	return n
+	// Next allocation should fail due to 10k space exhausted.
+	if _, _, _, err := s.CreateCode(context.Background()); err == nil {
+		t.Fatalf("expected exhaustion error, got nil")
+	}
 }

internal/server/server.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"log/slog"
 	"net/http"
-	"net/http/pprof"
 	"os"
 	"runtime"
 	"strings"
@@ -107,7 +106,7 @@ func Build(p BuildParams, opt ...any) (*App, error) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	// Optional pprof (NT_PPROF=true/1/on)
+	/* Optional pprof (NT_PPROF=true/1/on)
 	if v := strings.ToLower(strings.TrimSpace(os.Getenv("NT_PPROF"))); v == "1" || v == "true" || v == "on" {
 		mux.HandleFunc("/debug/pprof/", pprof.Index)
 		mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
@@ -116,6 +115,7 @@ func Build(p BuildParams, opt ...any) (*App, error) {
 		mux.HandleFunc("/debug/pprof/trace", pprof.Trace)
 		log.Info("pprof enabled on /debug/pprof/*")
 	}
+	*/
 
 	// WS
 	wsx.SetDevMode(p.DevMode)
@@ -179,8 +179,10 @@ func Build(p BuildParams, opt ...any) (*App, error) {
 		)
 	}
 
-	mux.Handle("/objects", objHandler)
-	mux.Handle("/objects/", objHandler)
+	/*
+		mux.Handle("/objects", objHandler)
+		mux.Handle("/objects/", objHandler)
+	*/
 
 	// health & metrics
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusNoContent) })