release: open-source release build logic for unix packages

Updates tailscale/corp#9221

Signed-off-by: David Anderson <danderson@tailscale.com>

release/dist/memoize.go

@@ -0,0 +1,83 @@
+package dist
+
+import (
+	"sync"
+
+	"tailscale.com/util/deephash"
+)
+
+// MemoizedFn is a function that memoize.Do can call.
+type MemoizedFn[T any] func() (T, error)
+
+// Memoize runs MemoizedFns and remembers their results.
+type Memoize[O any] struct {
+	mu       sync.Mutex
+	cond     *sync.Cond
+	outs     map[deephash.Sum]O
+	errs     map[deephash.Sum]error
+	inflight map[deephash.Sum]bool
+}
+
+// Do runs fn and returns its result.
+// fn is only run once per unique key. Subsequent Do calls with the same key
+// return the memoized result of the first call, even if fn is a different
+// function.
+func (m *Memoize[O]) Do(key any, fn MemoizedFn[O]) (ret O, err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.cond == nil {
+		m.cond = sync.NewCond(&m.mu)
+		m.outs = map[deephash.Sum]O{}
+		m.errs = map[deephash.Sum]error{}
+		m.inflight = map[deephash.Sum]bool{}
+	}
+
+	k := deephash.Hash(&key)
+
+	for m.inflight[k] {
+		m.cond.Wait()
+	}
+	if err := m.errs[k]; err != nil {
+		var ret O
+		return ret, err
+	}
+	if ret, ok := m.outs[k]; ok {
+		return ret, nil
+	}
+
+	m.inflight[k] = true
+	m.mu.Unlock()
+	defer func() {
+		m.mu.Lock()
+		delete(m.inflight, k)
+		if err != nil {
+			m.errs[k] = err
+		} else {
+			m.outs[k] = ret
+		}
+		m.cond.Broadcast()
+	}()
+
+	ret, err = fn()
+	if err != nil {
+		var ret O
+		return ret, err
+	}
+	return ret, nil
+}
+
+// once is like memoize, but for functions that don't return non-error values.
+type once struct {
+	m Memoize[any]
+}
+
+// Do runs fn.
+// fn is only run once per unique key. Subsequent Do calls with the same key
+// return the memoized result of the first call, even if fn is a different
+// function.
+func (o *once) Do(key any, fn func() error) error {
+	_, err := o.m.Do(key, func() (any, error) {
+		return nil, fn()
+	})
+	return err
+}