Registry Pattern — Practice Tasks¶

package codec

import "sync"

type Codec interface {
    Encode(v any) ([]byte, error)
    Decode(data []byte, out any) error
}

// Senior decision: wrap the map and lock in one struct so future
// readers can never forget the mutex. A bare package-level map plus a
// separate mutex is a footgun.
type registry struct {
    mu sync.RWMutex
    m  map[string]Codec
}

var defaultRegistry = &registry{m: map[string]Codec{}}

func Register(name string, c Codec) {
    // Senior decision: fail loud on nil and duplicates. Both are almost
    // certainly bugs in the caller's init(); panicking now beats a nil
    // dereference 200ms later in main.
    if c == nil {
        panic("codec: Register nil codec for " + name)
    }
    if name == "" {
        panic("codec: Register empty name")
    }
    defaultRegistry.mu.Lock()
    defer defaultRegistry.mu.Unlock()
    if _, dup := defaultRegistry.m[name]; dup {
        panic("codec: Register called twice for " + name)
    }
    defaultRegistry.m[name] = c
}

func Get(name string) (Codec, bool) {
    defaultRegistry.mu.RLock()
    defer defaultRegistry.mu.RUnlock()
    c, ok := defaultRegistry.m[name]
    return c, ok
}

// codec/json/json.go
package json

import (
    "encoding/json"
    "example.com/codec"
)

type jsonCodec struct{}

func (jsonCodec) Encode(v any) ([]byte, error)      { return json.Marshal(v) }
func (jsonCodec) Decode(data []byte, out any) error { return json.Unmarshal(data, out) }

// Senior decision: init() is the only place a package should register
// itself. Lazy-in-a-constructor introduces a "did you call Init()?"
// footgun. Go guarantees init() runs at most once, before any function
// in the package can be called from main — exactly the semantics here.
func init() {
    codec.Register("json", jsonCodec{})
}

// codec/json/json_test.go
package json_test

import (
    "testing"
    "example.com/codec"
    _ "example.com/codec/json"
)

func TestJSONSelfRegisters(t *testing.T) {
    c, ok := codec.Get("json")
    if !ok {
        t.Fatal("json codec not registered")
    }
    b, err := c.Encode(map[string]any{"x": 1})
    if err != nil || string(b) != `{"x":1}` {
        t.Fatalf("got %q err=%v", b, err)
    }
}

package main

import (
    "fmt"
    "os"

    "example.com/codec"
    _ "example.com/codec/json" // Senior decision: blank import for side
                               // effects only. Removing this line breaks
                               // the binary at runtime, not compile time.
                               // That trade-off lets the binary author
                               // choose which codecs are compiled in
                               // without touching the registry or its
                               // consumers — the same trade-off
                               // database/sql makes.
)

func main() {
    c, ok := codec.Get("json")
    if !ok {
        fmt.Fprintln(os.Stderr, "no json codec — forgot blank import?")
        os.Exit(1)
    }
    payload := struct {
        Name string
        Age  int
    }{"alice", 30}
    b, err := c.Encode(payload)
    if err != nil {
        fmt.Fprintln(os.Stderr, "encode:", err)
        os.Exit(1)
    }
    fmt.Println(string(b))
}

// codec/codec.go
func Names() []string {
    defaultRegistry.mu.RLock()
    defer defaultRegistry.mu.RUnlock()
    // Senior decision: snapshot keys under the lock, sort outside.
    // sort.Strings allocates; we don't want it on the read lock's
    // critical path.
    out := make([]string, 0, len(defaultRegistry.m))
    for n := range defaultRegistry.m {
        out = append(out, n)
    }
    sort.Strings(out)
    return out
}

// cmd/myapp/main.go
func main() {
    if len(os.Args) < 2 { usage(); os.Exit(2) }
    switch os.Args[1] {
    case "list-codecs":
        for _, n := range codec.Names() { fmt.Println(n) }
    case "help", "-h", "--help":
        usage()
    default:
        fmt.Fprintf(os.Stderr, "unknown: %s\n", os.Args[1])
        usage()
        os.Exit(2)
    }
}

package stores

import (
    "fmt"
    "sort"
    "sync"
)

type Store interface {
    Get(key string) (string, error)
    Put(key, val string) error
    Close() error
}

type Config struct {
    Addr, User, Password string
    Options              map[string]string
}

type Factory func(cfg Config) (Store, error)

type registry struct {
    mu sync.RWMutex
    m  map[string]Factory
}

var defaultRegistry = &registry{m: map[string]Factory{}}

func Register(name string, f Factory) {
    if f == nil { panic("stores: nil factory for " + name) }
    defaultRegistry.mu.Lock()
    defer defaultRegistry.mu.Unlock()
    if _, dup := defaultRegistry.m[name]; dup {
        panic("stores: Register twice for " + name)
    }
    defaultRegistry.m[name] = f
}

func New(name string, cfg Config) (Store, error) {
    defaultRegistry.mu.RLock()
    f, ok := defaultRegistry.m[name]
    defaultRegistry.mu.RUnlock()
    // Senior decision: drop the read lock BEFORE calling f. Factories
    // open sockets, query DNS, do TLS handshakes — slow work. Holding
    // the registry's lock across that serializes every Register/New
    // call in the program behind the slowest factory.
    if !ok {
        return nil, fmt.Errorf("stores: no factory for %q (have: %v)", name, Names())
    }
    return f(cfg)
}

func Names() []string {
    defaultRegistry.mu.RLock()
    defer defaultRegistry.mu.RUnlock()
    out := make([]string, 0, len(defaultRegistry.m))
    for n := range defaultRegistry.m { out = append(out, n) }
    sort.Strings(out)
    return out
}

// Wiring:
//   func init() {
//       stores.Register("redis", func(cfg stores.Config) (stores.Store, error) {
//           return openRedis(cfg)
//       })
//   }
//   // main:
//   s, err := stores.New("redis", stores.Config{Addr: "localhost:6379"})

package codec

import (
    "sort"
    "sync"
)

// Senior decision: sync.Map fits two specific shapes — (a) write-once
// then read-many, (b) keys disjoint between goroutines. (a) is exactly
// the startup-registration case. Under write-heavy load it's SLOWER
// than RWMutex because it maintains two internal maps with migration.
var defaultRegistry sync.Map

func Register(name string, c Codec) {
    if c == nil { panic("codec: nil codec for " + name) }
    if _, loaded := defaultRegistry.LoadOrStore(name, c); loaded {
        panic("codec: Register twice for " + name)
    }
}

func Get(name string) (Codec, bool) {
    v, ok := defaultRegistry.Load(name)
    if !ok { return nil, false }
    return v.(Codec), true
}

func Names() []string {
    var out []string
    defaultRegistry.Range(func(k, _ any) bool {
        out = append(out, k.(string))
        return true
    })
    sort.Strings(out)
    return out
}

package codec

import (
    "fmt"
    "sort"
    "sync"
)

type Codec interface {
    Encode(v any) ([]byte, error)
    Decode(data []byte, out any) error
}

type Registry struct {
    mu sync.RWMutex
    m  map[string]Codec
}

// Senior decision: New() is the only constructor. No package-level var
// or init() — that would create the global we're escaping. Callers
// who want a singleton wrap their own.
func New() *Registry { return &Registry{m: map[string]Codec{}} }

func (r *Registry) Register(name string, c Codec) {
    if c == nil { panic("codec: nil codec for " + name) }
    r.mu.Lock()
    defer r.mu.Unlock()
    if _, dup := r.m[name]; dup {
        panic("codec: Register twice for " + name)
    }
    r.m[name] = c
}

func (r *Registry) Get(name string) (Codec, bool) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    c, ok := r.m[name]
    return c, ok
}

func (r *Registry) MustGet(name string) Codec {
    c, ok := r.Get(name)
    if !ok {
        panic(fmt.Sprintf("codec: %q not registered (have: %v)", name, r.Names()))
    }
    return c
}

func (r *Registry) Names() []string {
    r.mu.RLock()
    defer r.mu.RUnlock()
    out := make([]string, 0, len(r.m))
    for n := range r.m { out = append(out, n) }
    sort.Strings(out)
    return out
}

// Parallel-test demo (both subtests run concurrently, no interference):
//
//   func TestParallel(t *testing.T) {
//       t.Run("A", func(t *testing.T) {
//           t.Parallel()
//           r := codec.New()
//           r.Register("a", fakeCodec{})
//           if _, ok := r.Get("b"); ok { t.Error("b leaked") }
//       })
//       t.Run("B", func(t *testing.T) {
//           t.Parallel()
//           r := codec.New()
//           r.Register("b", fakeCodec{})
//           if _, ok := r.Get("a"); ok { t.Error("a leaked") }
//       })
//   }

package registry

import (
    "fmt"
    "sort"
    "sync"
)

type Registry[T any] struct {
    mu sync.RWMutex
    m  map[string]T
}

func New[T any]() *Registry[T] { return &Registry[T]{m: map[string]T{}} }

// Senior decision: no nil check inside Register. T may be a struct
// (non-nilable) or interface (nilable). The library can't know, so we
// leave nil-validation to the type-specific wrapper. The old non-
// generic codec registry could check because it knew T = Codec.
func (r *Registry[T]) Register(name string, v T) {
    if name == "" { panic("registry: empty name") }
    r.mu.Lock()
    defer r.mu.Unlock()
    if _, dup := r.m[name]; dup {
        panic("registry: Register twice for " + name)
    }
    r.m[name] = v
}

func (r *Registry[T]) Get(name string) (T, bool) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    v, ok := r.m[name]
    return v, ok
}

func (r *Registry[T]) MustGet(name string) T {
    v, ok := r.Get(name)
    if !ok {
        panic(fmt.Sprintf("registry: %q not registered (have: %v)", name, r.Names()))
    }
    return v
}

func (r *Registry[T]) Names() []string {
    r.mu.RLock()
    defer r.mu.RUnlock()
    out := make([]string, 0, len(r.m))
    for n := range r.m { out = append(out, n) }
    sort.Strings(out)
    return out
}

// Type-specific wrappers:
//   var Codecs = registry.New[Codec]()
//   var Stores = registry.New[Factory]()
//
// Compile error now:
//   Codecs.Register("oops", someFactory) // type Factory used where Codec wanted
//
// Constraint-checked helpers go at top level, not on the method
// (Go has no where-clause on methods):
//   func RegisterChecked[T Validator](r *Registry[T], name string, v T) error {
//       if err := v.Validate(); err != nil { return err }
//       r.Register(name, v); return nil
//   }

package router

import (
    "net/http"
    "strings"
    "sync"
)

type Router struct {
    mu       sync.RWMutex
    handlers map[string]http.Handler
    // Senior decision: track a path -> {method set} so we can return
    // 405 (Method Not Allowed) with the Allow header. Without this,
    // every wrong-method request becomes a 404 — confuses HTTP clients,
    // CDNs, and load balancers.
    paths    map[string]map[string]struct{}
}

func New() *Router {
    return &Router{
        handlers: map[string]http.Handler{},
        paths:    map[string]map[string]struct{}{},
    }
}

func key(method, pattern string) string { return method + " " + pattern }

func (r *Router) Register(method, pattern string, h http.Handler) {
    if h == nil { panic("router: nil handler for " + key(method, pattern)) }
    r.mu.Lock()
    defer r.mu.Unlock()
    k := key(method, pattern)
    if _, dup := r.handlers[k]; dup {
        panic("router: Register twice for " + k)
    }
    r.handlers[k] = h
    if r.paths[pattern] == nil {
        r.paths[pattern] = map[string]struct{}{}
    }
    r.paths[pattern][method] = struct{}{}
}

func (r *Router) Handle(method, pattern string, fn http.HandlerFunc) {
    r.Register(method, pattern, fn)
}

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    r.mu.RLock()
    h, ok := r.handlers[key(req.Method, req.URL.Path)]
    methods, pathExists := r.paths[req.URL.Path]
    r.mu.RUnlock()
    switch {
    case ok:
        h.ServeHTTP(w, req)
    case pathExists:
        allowed := make([]string, 0, len(methods))
        for m := range methods { allowed = append(allowed, m) }
        w.Header().Set("Allow", strings.Join(allowed, ", "))
        http.Error(w, http.StatusText(http.StatusMethodNotAllowed),
            http.StatusMethodNotAllowed)
    default:
        http.NotFound(w, req)
    }
}

package codec

import (
    "sort"
    "sync/atomic"
)

type Codec interface { /* same as before */ }

type Registry struct {
    // Senior decision: atomic.Pointer to a map gives lock-free reads
    // and (relatively) cheap full-replacement writes. Readers do ONE
    // atomic load and access a snapshot they own. No partial-update
    // window exists — only complete generations swapped atomically.
    // Same trick the Linux kernel uses for RCU.
    m atomic.Pointer[map[string]Codec]
}

func New() *Registry {
    r := &Registry{}
    empty := map[string]Codec{}
    r.m.Store(&empty)
    return r
}

func (r *Registry) Get(name string) (Codec, bool) {
    snap := r.m.Load()
    if snap == nil { return nil, false }
    c, ok := (*snap)[name]
    return c, ok
}

func (r *Registry) Snapshot() map[string]Codec {
    snap := r.m.Load()
    if snap == nil { return nil }
    return *snap
}

func (r *Registry) Swap(next map[string]Codec) {
    // Senior decision: defensive copy. Even if the caller promises not
    // to mutate `next`, we own it from here on.
    cp := make(map[string]Codec, len(next))
    for k, v := range next { cp[k] = v }
    r.m.Store(&cp)
}

func (r *Registry) Register(name string, c Codec) {
    for {
        old := r.m.Load()
        next := make(map[string]Codec, len(*old)+1)
        for k, v := range *old { next[k] = v }
        next[name] = c
        if r.m.CompareAndSwap(old, &next) { return }
    }
}

func (r *Registry) Names() []string {
    snap := r.Snapshot()
    out := make([]string, 0, len(snap))
    for n := range snap { out = append(out, n) }
    sort.Strings(out)
    return out
}

// Wiring a config-watcher:
//   func Watch(ctx context.Context, r *Registry, path string) {
//       t := time.NewTicker(5 * time.Second); defer t.Stop()
//       var lastHash string
//       for {
//           select { case <-ctx.Done(): return; case <-t.C: }
//           data, err := os.ReadFile(path)
//           if err != nil { continue }
//           h := fmt.Sprintf("%x", sha256.Sum256(data))
//           if h == lastHash { continue }
//           lastHash = h
//           r.Swap(parseCodecs(data))
//       }
//   }

package metrics

import (
    "fmt"
    "sort"
    "strings"
    "sync"
)

type Desc struct {
    FQName, Help string
    Labels       []string
}

func (d *Desc) key() string {
    ls := append([]string(nil), d.Labels...)
    sort.Strings(ls)
    return d.FQName + "|" + strings.Join(ls, ",")
}

type Metric struct {
    Desc   *Desc
    Value  float64
    Labels map[string]string
}

type Collector interface {
    Describe(chan<- *Desc)
    Collect(chan<- Metric)
}

type Registry struct {
    mu         sync.RWMutex
    collectors map[Collector]struct{}
    descs      map[string]Collector
}

func NewRegistry() *Registry {
    return &Registry{
        collectors: map[Collector]struct{}{},
        descs:      map[string]Collector{},
    }
}

func (r *Registry) Register(c Collector) error {
    // Senior decision: drain Describe into a buffered channel. A
    // misbehaving Collector that emits 10000 descriptors can't
    // deadlock the registry. Cap of 16 covers any legitimate use.
    ch := make(chan *Desc, 16)
    done := make(chan struct{})
    var gathered []*Desc
    go func() {
        defer close(done)
        for d := range ch { gathered = append(gathered, d) }
    }()
    c.Describe(ch)
    close(ch)
    <-done

    r.mu.Lock()
    defer r.mu.Unlock()
    if _, dup := r.collectors[c]; dup {
        return fmt.Errorf("metrics: collector already registered")
    }
    // Senior decision: check collisions BEFORE mutating anything.
    // Otherwise a failure mid-loop leaves descs partially populated.
    seen := map[string]struct{}{}
    for _, d := range gathered {
        k := d.key()
        if _, taken := r.descs[k]; taken {
            return fmt.Errorf("metrics: duplicate descriptor: %s", d.FQName)
        }
        if _, dup := seen[k]; dup {
            return fmt.Errorf("metrics: collector returned same desc twice: %s", d.FQName)
        }
        seen[k] = struct{}{}
    }
    for _, d := range gathered { r.descs[d.key()] = c }
    r.collectors[c] = struct{}{}
    return nil
}

func (r *Registry) MustRegister(c Collector) {
    if err := r.Register(c); err != nil { panic(err) }
}

func (r *Registry) Unregister(c Collector) bool {
    r.mu.Lock()
    defer r.mu.Unlock()
    if _, ok := r.collectors[c]; !ok { return false }
    delete(r.collectors, c)
    for k, owner := range r.descs {
        if owner == c { delete(r.descs, k) }
    }
    return true
}

func (r *Registry) Gather() ([]Metric, error) {
    r.mu.RLock()
    cols := make([]Collector, 0, len(r.collectors))
    for c := range r.collectors { cols = append(cols, c) }
    r.mu.RUnlock()
    // Senior decision: fan out collectors. Tail latency = max(slowest)
    // instead of sum(all). For 50 collectors with mixed latencies this
    // is the difference between 200ms and 4s scrapes.
    var (
        mu  sync.Mutex
        out []Metric
        wg  sync.WaitGroup
    )
    for _, c := range cols {
        c := c
        wg.Add(1)
        go func() {
            defer wg.Done()
            ch := make(chan Metric, 64)
            done := make(chan struct{})
            go func() {
                var local []Metric
                for m := range ch { local = append(local, m) }
                mu.Lock(); out = append(out, local...); mu.Unlock()
                close(done)
            }()
            c.Collect(ch)
            close(ch)
            <-done
        }()
    }
    wg.Wait()
    return out, nil
}

package pluginreg

import (
    "fmt"
    "plugin"
    "sync"
)

type Plugin interface {
    Name() string
    Version() string
    Init() (any, error)
}

type PluginInfo struct{ Path, Name, Version string }

type Loader struct {
    mu     sync.Mutex
    byPath map[string]Plugin
    info   []PluginInfo
}

func NewLoader() *Loader { return &Loader{byPath: map[string]Plugin{}} }

func (l *Loader) Load(path string) (Plugin, error) {
    l.mu.Lock()
    defer l.mu.Unlock()
    // Senior decision: cache by path. The OS plugin loader already
    // dedupes (second plugin.Open returns the same *Plugin), but our
    // wrapper tracks registration too — we don't want Load called
    // twice to double-register the codec downstream.
    if p, ok := l.byPath[path]; ok { return p, nil }
    pl, err := plugin.Open(path)
    if err != nil {
        return nil, fmt.Errorf("plugin: open %s: %w", path, err)
    }
    sym, err := pl.Lookup("Plugin")
    if err != nil {
        return nil, fmt.Errorf("plugin %s: missing 'Plugin': %w", path, err)
    }
    // Symbol may be T or *T depending on how the plugin declares it.
    var p Plugin
    switch v := sym.(type) {
    case Plugin:
        p = v
    case *Plugin:
        if v == nil || *v == nil {
            return nil, fmt.Errorf("plugin %s: 'Plugin' is nil", path)
        }
        p = *v
    default:
        return nil, fmt.Errorf("plugin %s: 'Plugin' has wrong type: %T", path, sym)
    }
    l.byPath[path] = p
    l.info = append(l.info, PluginInfo{Path: path, Name: p.Name(), Version: p.Version()})
    return p, nil
}

func (l *Loader) Loaded() []PluginInfo {
    l.mu.Lock()
    defer l.mu.Unlock()
    out := make([]PluginInfo, len(l.info))
    copy(out, l.info)
    return out
}

// Sample plugin (built with `go build -buildmode=plugin -o cbor.so`):
//   package main
//   import "github.com/fxamacker/cbor/v2"
//   type cborPlugin struct{}
//   func (cborPlugin) Name() string    { return "cbor" }
//   func (cborPlugin) Version() string { return "v2.5.0" }
//   func (cborPlugin) Init() (any, error) { return cborCodec{}, nil }
//   var Plugin cborPlugin
//
// Driver:
//   p, _ := loader.Load("./cbor.so")
//   raw, _ := p.Init()
//   codec.Register(p.Name(), raw.(codec.Codec))