ENV Config values (#246)

# Changes
* Secret config type -
  * By default `String()` method returns redacted
* Configs can specify `env` tag to indicate an overriding environment variable (if present)
* Events can be registered to force last
* Fix to colorize goodbye message

Author: Volte6

_datafiles/config.yaml

@@ -420,9 +420,10 @@ Locked:
 
 ################################################################################
 #
-#   ChatGPT Configurations
+#   Secrets
 #
 ################################################################################
-# - ChatGPTKey - 
-#   Your OpenAI Key. If empty, will not use ChatGPT.
-ChatGPTKey: ''
+# - DiscordWebhookUrl - 
+# Optional webhook URL to send mud event messages to, such as joins/disconnects
+# Can also be set via environment variable: DISCORD_WEBHOOK_URL
+DiscordWebhookUrl: ''

internal/configs/config_types.go

@@ -1,16 +1,19 @@
 package configs
 
 import (
+	"fmt"
 	"strconv"
 	"strings"
 )
 
 type ConfigInt int
 type ConfigUInt64 uint64
 type ConfigString string
+type ConfigSecret string // special case string
 type ConfigFloat float64
 type ConfigBool bool
 type ConfigSliceString []string
+type ConfigMap map[string]string
 
 type ConfigValue interface {
 	String() string
@@ -30,6 +33,10 @@ func (c ConfigString) String() string {
 	return string(c)
 }
 
+func (c ConfigSecret) String() string {
+	return `*** REDACTED ***`
+}
+
 func (c ConfigFloat) String() string {
 	return strconv.FormatFloat(float64(c), 'f', -1, 64)
 }
@@ -39,9 +46,16 @@ func (c ConfigBool) String() string {
 }
 
 func (c ConfigSliceString) String() string {
+	if len(c) == 0 {
+		return `[]`
+	}
 	return `["` + strings.Join(c, `", "`) + `"]`
 }
 
+func (c ConfigMap) String() string {
+	return fmt.Sprintf(`%+v`, map[string]string(c))
+}
+
 // Set
 
 func (c *ConfigUInt64) Set(value string) error {
@@ -67,6 +81,11 @@ func (c *ConfigString) Set(value string) error {
 	return nil
 }
 
+func (c *ConfigSecret) Set(value string) error {
+	*c = ConfigSecret(value)
+	return nil
+}
+
 func (c *ConfigFloat) Set(value string) error {
 	v, err := strconv.ParseFloat(value, 64)
 	if err != nil {

internal/configs/configs.go

@@ -103,7 +103,9 @@ type Config struct {
 	LeaderboardSize  ConfigInt `yaml:"LeaderboardSize"`  // Maximum size of leaderboard
 	ContainerSizeMax ConfigInt `yaml:"ContainerSizeMax"` // How many objects containers can hold before overflowing
 
-	SeedInt int64 `yaml:"-"`
+	DiscordWebhookUrl ConfigSecret `yaml:"DiscordWebhookUrl" env:"DISCORD_WEBHOOK_URL"` // Optional Discord URL to post updates to
+
+	seedInt int64 `yaml:"-"`
 
 	// Protected values
 	turnsPerRound   int     // calculated and cached when data is validated.
@@ -253,36 +255,36 @@ func (c Config) AllConfigData(excludeStrings ...string) map[string]any {
 		}
 
 		itm := items.Field(i)
-		if itm.Type().Kind() == reflect.Slice {
 
-			v := reflect.Indirect(itm)
-			list := []string{}
-			for j := 0; j < v.Len(); j++ {
+		if stringerVal, ok := itm.Interface().(fmt.Stringer); ok {
+			output[name] = stringerVal.String()
+		} else {
+			if itm.Type().Kind() == reflect.Slice {
 
-				cmd := itm.Index(j).Interface().(string)
+				v := reflect.Indirect(itm)
+				list := []string{}
+				for j := 0; j < v.Len(); j++ {
 
-				if len(excludeStrings) > 0 {
+					cmd := itm.Index(j).Interface().(string)
+
+					if len(excludeStrings) > 0 {
 
-				}
-				/*
-					if len(cmd) > 27 {
-						cmd = cmd[0:27]
 					}
-				*/
-				list = append(list, cmd)
-				//output[fmt.Sprintf(`%s.%d`, name, j)] = cmd
-			}
-			output[name] = strings.Join(list, `; `)
+					list = append(list, cmd)
+					//output[fmt.Sprintf(`%s.%d`, name, j)] = cmd
+				}
+				output[name] = strings.Join(list, `; `)
 
-		} else if itm.Type().Kind() == reflect.Map {
-			// iterate the map
-			keys := itm.MapKeys()
-			for _, key := range keys {
-				output[fmt.Sprintf(`%s.%d`, name, key.Int())] = itm.MapIndex(key).Float()
-			}
+			} else if itm.Type().Kind() == reflect.Map {
+				// iterate the map
+				keys := itm.MapKeys()
+				for _, key := range keys {
+					output[fmt.Sprintf(`%s.%d`, name, key.Int())] = itm.MapIndex(key).Float()
+				}
 
-		} else {
-			output[name] = itm.Interface()
+			} else {
+				output[name] = itm.Interface()
+			}
 		}
 
 	}
@@ -531,14 +533,47 @@ func (c *Config) Validate() {
 	c.turnsPerSecond = int(1000 / c.TurnMs)
 	c.roundsPerMinute = 60 / float64(c.RoundSeconds)
 
-	c.SeedInt = 0
+	c.seedInt = 0
 	for i, num := range util.Md5Bytes([]byte(string(c.Seed))) {
-		c.SeedInt += int64(num) << i
+		c.seedInt += int64(num) << i
 	}
 
 	c.validated = true
 }
 
+func (c *Config) setEnvAssignments(clear bool) {
+
+	// We use reflect.Indirect to handle if cfg is a pointer or not
+	v := reflect.ValueOf(c).Elem()
+
+	// We'll need the struct type as well (to get field names).
+	t := v.Type()
+
+	for i := 0; i < v.NumField(); i++ {
+		fieldVal := v.Field(i)
+		fieldType := t.Field(i)
+
+		if fieldVal.Type().Kind() != reflect.String {
+			continue
+		}
+
+		if envName := fieldType.Tag.Get(`env`); envName != `` {
+			if fieldVal.CanSet() {
+				if envVal := os.Getenv(envName); envVal != `` {
+
+					if clear {
+						envVal = ``
+					}
+
+					fieldVal.Set(reflect.ValueOf(ConfigSecret(envVal)))
+
+				}
+			}
+		}
+
+	}
+}
+
 func (c Config) GetDeathXPPenalty() (setting string, pct float64) {
 
 	setting = string(c.OnDeathXPPenalty)
@@ -605,6 +640,10 @@ func (c Config) IsBannedName(name string) (string, bool) {
 	return "", false
 }
 
+func (c Config) SeedInt() int64 {
+	return c.seedInt
+}
+
 func GetConfig() Config {
 	configDataLock.RLock()
 	defer configDataLock.RUnlock()
@@ -666,6 +705,8 @@ func ReloadConfig() error {
 		tmpConfigData.SetOverrides(map[string]any{})
 	}
 
+	tmpConfigData.setEnvAssignments(false)
+
 	tmpConfigData.Validate()
 
 	configDataLock.Lock()
@@ -675,3 +716,8 @@ func ReloadConfig() error {
 
 	return nil
 }
+
+// Usage: configs.GetSecret(c.DiscordWebhookUrl)
+func GetSecret(v ConfigSecret) string {
+	return string(v)
+}

internal/configs/configs_test.go

@@ -80,3 +80,166 @@ func Config_Typed(c Config) uint64 {
 func Config_Interface(c interface{}) uint64 {
 	return uint64(c.(Config).turnsPerRound)
 }
+
+func TestConfigUInt64String(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    ConfigUInt64
+		expected string
+	}{
+		{name: "Zero", value: 0, expected: "0"},
+		{name: "SmallNumber", value: 123, expected: "123"},
+		{name: "LargeNumber", value: 9223372036854775808, expected: "9223372036854775808"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.value.String()
+			if got != tt.expected {
+				t.Errorf("ConfigUInt64.String() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestConfigIntString(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    ConfigInt
+		expected string
+	}{
+		{name: "Zero", value: 0, expected: "0"},
+		{name: "Positive", value: 42, expected: "42"},
+		{name: "Negative", value: -100, expected: "-100"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.value.String()
+			if got != tt.expected {
+				t.Errorf("ConfigInt.String() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestConfigStringString(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    ConfigString
+		expected string
+	}{
+		{name: "Empty", value: "", expected: ""},
+		{name: "Hello", value: "Hello, world!", expected: "Hello, world!"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.value.String()
+			if got != tt.expected {
+				t.Errorf("ConfigString.String() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestConfigFloatString(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    ConfigFloat
+		expected string
+	}{
+		{name: "Zero", value: 0.0, expected: "0"},
+		{name: "Pi", value: 3.14, expected: "3.14"},
+		{name: "WholeNumber", value: 2.0, expected: "2"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.value.String()
+			if got != tt.expected {
+				t.Errorf("ConfigFloat.String() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestConfigBoolString(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    ConfigBool
+		expected string
+	}{
+		{name: "True", value: true, expected: "true"},
+		{name: "False", value: false, expected: "false"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.value.String()
+			if got != tt.expected {
+				t.Errorf("ConfigBool.String() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestConfigSliceStringString(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    ConfigSliceString
+		expected string
+	}{
+		{name: "EmptySlice", value: ConfigSliceString{}, expected: `[]`},
+		{name: "SingleElement", value: ConfigSliceString{"one"}, expected: `["one"]`},
+		{name: "MultipleElements", value: ConfigSliceString{"one", "two", "three"}, expected: `["one", "two", "three"]`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.value.String()
+			if got != tt.expected {
+				t.Errorf("ConfigSliceString.String() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestConfigMapString(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    ConfigMap
+		expected string
+	}{
+		{
+			name:     "EmptyMap",
+			value:    ConfigMap{},
+			expected: `map[]`,
+		},
+		{
+			name:  "SingleKeyValue",
+			value: ConfigMap{"key": "value"},
+			// fmt.Sprintf("%+v", map[string]string{"key":"value"}) => "map[key:value]"
+			expected: `map[key:value]`,
+		},
+		{
+			name:  "MultipleKeyValue",
+			value: ConfigMap{"one": "1", "two": "2"},
+			// fmt.Sprintf("%+v", map[string]string{"one":"1","two":"2"}) => "map[one:1 two:2]"
+			// The order of map iteration is not guaranteed. If order is important,
+			// consider sorting the keys before formatting. For the default test:
+			// "map[one:1 two:2]" or "map[two:2 one:1]" are both possible.
+			// You might need a more robust comparison if order varies.
+			expected: `map[one:1 two:2]`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.value.String()
+			if got != tt.expected {
+				t.Errorf("ConfigMap.String() = %q, want %q", got, tt.expected)
+			}
+		})
+	}
+}