Initializer interface, rename "key" to "name"

dannykopping · dannykopping · commit 355afdc83b02 · 2024-09-04T10:26:37.000+02:00
Signed-off-by: Danny Kopping &lt;danny@coder.com&gt;
diff --git a/coderd/runtimeconfig/config.go b/coderd/runtimeconfig/config.go
@@ -9,7 +9,7 @@ import (
 	"golang.org/x/xerrors"
 )
 
-var ErrKeyNotSet = xerrors.New("key is not set")
+var ErrNameNotSet = xerrors.New("name is not set")
 
 // Value wraps the type used by the serpent library for its option values.
 // This gives us a seam should serpent ever move away from its current implementation.
@@ -18,14 +18,15 @@ type Value pflag.Value
 // Entry is designed to wrap any type which satisfies the Value interface, which currently all serpent.Option instances do.
 // serpent.Option provide configurability to Value instances, and we use this Entry type to extend the functionality of
 // those Value instances.
+// An Entry has a "name" which is used to identify it in the store.
 type Entry[T Value] struct {
-	k string
-	v T
+	n     string
+	inner T
 }
 
-// New creates a new T instance with a defined key and value.
-func New[T Value](key, val string) (out Entry[T], err error) {
-	out.k = key
+// New creates a new T instance with a defined name and value.
+func New[T Value](name, val string) (out Entry[T], err error) {
+	out.n = name
 
 	if err = out.SetStartupValue(val); err != nil {
 		return out, err
@@ -35,34 +36,35 @@ func New[T Value](key, val string) (out Entry[T], err error) {
 }
 
 // MustNew is like New but panics if an error occurs.
-func MustNew[T Value](key, val string) Entry[T] {
-	out, err := New[T](key, val)
+func MustNew[T Value](name, val string) Entry[T] {
+	out, err := New[T](name, val)
 	if err != nil {
 		panic(err)
 	}
 	return out
 }
 
+// Initialize sets the entry's name, and initializes the value.
+func (e *Entry[T]) Initialize(name string) {
+	e.n = name
+	e.val()
+}
+
 // val fronts the T value in the struct, and initializes it should the value be nil.
 func (e *Entry[T]) val() T {
-	if reflect.ValueOf(e.v).IsNil() {
-		e.v = create[T]()
+	if reflect.ValueOf(e.inner).IsNil() {
+		e.inner = create[T]()
 	}
-	return e.v
+	return e.inner
 }
 
-// key returns the configured key, or fails with ErrKeyNotSet.
-func (e *Entry[T]) key() (string, error) {
-	if e.k == "" {
-		return "", ErrKeyNotSet
+// name returns the configured name, or fails with ErrNameNotSet.
+func (e *Entry[T]) name() (string, error) {
+	if e.n == "" {
+		return "", ErrNameNotSet
 	}
 
-	return e.k, nil
-}
-
-// SetKey allows the key to be set.
-func (e *Entry[T]) SetKey(k string) {
-	e.k = k
+	return e.n, nil
 }
 
 // Set is an alias of SetStartupValue.
@@ -103,34 +105,34 @@ func (e *Entry[T]) StartupValue() T {
 
 // SetRuntimeValue attempts to update the runtime value of this field in the store via the given Mutator.
 func (e *Entry[T]) SetRuntimeValue(ctx context.Context, m Mutator, val T) error {
-	key, err := e.key()
+	name, err := e.name()
 	if err != nil {
 		return err
 	}
 
-	return m.UpsertRuntimeSetting(ctx, key, val.String())
+	return m.UpsertRuntimeSetting(ctx, name, val.String())
 }
 
 // UnsetRuntimeValue removes the runtime value from the store.
 func (e *Entry[T]) UnsetRuntimeValue(ctx context.Context, m Mutator) error {
-	key, err := e.key()
+	name, err := e.name()
 	if err != nil {
 		return err
 	}
 
-	return m.DeleteRuntimeSetting(ctx, key)
+	return m.DeleteRuntimeSetting(ctx, name)
 }
 
 // Resolve attempts to resolve the runtime value of this field from the store via the given Resolver.
 func (e *Entry[T]) Resolve(ctx context.Context, r Resolver) (T, error) {
 	var zero T
 
-	key, err := e.key()
+	name, err := e.name()
 	if err != nil {
 		return zero, err
 	}
 
-	val, err := r.GetRuntimeSetting(ctx, key)
+	val, err := r.GetRuntimeSetting(ctx, name)
 	if err != nil {
 		return zero, err
 	}
diff --git a/coderd/runtimeconfig/config_test.go b/coderd/runtimeconfig/config_test.go
@@ -61,13 +61,13 @@ func TestUsage(t *testing.T) {
 		// The value has to now be retrieved from a StartupValue() call.
 		require.Equal(t, "localhost:1234", field.StartupValue().String())
 
-		// One new constraint is that we have to set the key on the runtimeconfig.Entry.
-		// Attempting to perform any operation which accesses the store will enforce the need for a key.
+		// One new constraint is that we have to set the name on the runtimeconfig.Entry.
+		// Attempting to perform any operation which accesses the store will enforce the need for a name.
 		_, err := field.Resolve(ctx, resolver)
-		require.ErrorIs(t, err, runtimeconfig.ErrKeyNotSet)
+		require.ErrorIs(t, err, runtimeconfig.ErrNameNotSet)
 
-		// Let's see that key. The environment var name is likely to be the most stable.
-		field.SetKey(opt.Env)
+		// Let's set that name; the environment var name is likely to be the most stable.
+		field.Initialize(opt.Env)
 
 		newVal := serpent.HostPort{Host: "12.34.56.78", Port: "1234"}
 		// Now that we've set it, we can update the runtime value of this field, which modifies given store.
@@ -94,19 +94,19 @@ func TestConfig(t *testing.T) {
 
 		require.Panics(t, func() {
 			// "hello" cannot be set on a *serpent.Float64 field.
-			runtimeconfig.MustNew[*serpent.Float64]("key", "hello")
+			runtimeconfig.MustNew[*serpent.Float64]("my-field", "hello")
 		})
 
 		require.NotPanics(t, func() {
-			runtimeconfig.MustNew[*serpent.Float64]("key", "91.1234")
+			runtimeconfig.MustNew[*serpent.Float64]("my-field", "91.1234")
 		})
 	})
 
 	t.Run("zero", func(t *testing.T) {
 		t.Parallel()
 
 		// A zero-value declaration of a runtimeconfig.Entry should behave as a zero value of the generic type.
-		// NB! A key has not been set for this entry.
+		// NB! A name has not been set for this entry; it is "uninitialized".
 		var field runtimeconfig.Entry[*serpent.Bool]
 		var zero serpent.Bool
 		require.Equal(t, field.StartupValue().Value(), zero.Value())
@@ -116,10 +116,10 @@ func TestConfig(t *testing.T) {
 
 		// But attempting to resolve will produce an error.
 		_, err := field.Resolve(context.Background(), runtimeconfig.NewNoopResolver())
-		require.ErrorIs(t, err, runtimeconfig.ErrKeyNotSet)
+		require.ErrorIs(t, err, runtimeconfig.ErrNameNotSet)
 		// But attempting to set the runtime value will produce an error.
 		val := serpent.BoolOf(ptr.Ref(true))
-		require.ErrorIs(t, field.SetRuntimeValue(context.Background(), runtimeconfig.NewNoopMutator(), val), runtimeconfig.ErrKeyNotSet)
+		require.ErrorIs(t, field.SetRuntimeValue(context.Background(), runtimeconfig.NewNoopMutator(), val), runtimeconfig.ErrNameNotSet)
 	})
 
 	t.Run("simple", func(t *testing.T) {
diff --git a/coderd/runtimeconfig/spec.go b/coderd/runtimeconfig/spec.go
@@ -2,16 +2,20 @@ package runtimeconfig
 
 import "context"
 
+type Initializer interface {
+	Initialize(name string)
+}
+
 // Resolver is an interface for resolving runtime settings.
 type Resolver interface {
-	// GetRuntimeSetting gets a runtime setting by key.
-	GetRuntimeSetting(ctx context.Context, key string) (string, error)
+	// GetRuntimeSetting gets a runtime setting by name.
+	GetRuntimeSetting(ctx context.Context, name string) (string, error)
 }
 
 // Mutator is an interface for mutating runtime settings.
 type Mutator interface {
-	// UpsertRuntimeSetting upserts a runtime setting by key.
-	UpsertRuntimeSetting(ctx context.Context, key, val string) error
-	// DeleteRuntimeSetting deletes a runtime setting by key.
-	DeleteRuntimeSetting(ctx context.Context, key string) error
+	// UpsertRuntimeSetting upserts a runtime setting by name.
+	UpsertRuntimeSetting(ctx context.Context, name, val string) error
+	// DeleteRuntimeSetting deletes a runtime setting by name.
+	DeleteRuntimeSetting(ctx context.Context, name string) error
 }
