working feature of the dynconf lib test

Author: samuelarogbonlo

.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version: '1.21'
+    - name: Test
+      run: |
+        go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
+    - name: Upload coverage
+      uses: codecov/codecov-action@v3
+      with:
+        file: ./coverage.txt

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cmd/examples/basic/main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+    "context"
+    "errors" // Added this import
+    "log"
+    "time"
+
+    "github.com/samuelarogbonlo/dynconf/pkg/dynconf"
+)
+
+type AppConfig struct {
+    ServerPort int           `json:"server_port"`
+    Timeout    time.Duration `json:"timeout"`
+}
+
+func main() {
+    ctx := context.Background()
+
+    cfg := dynconf.New[AppConfig](
+        dynconf.WithValidation[AppConfig](func(old, new AppConfig) error {
+            if new.ServerPort < 1024 {
+                return errors.New("server port must be >= 1024")
+            }
+            return nil
+        }),
+        dynconf.WithRollback[AppConfig](true),
+    )
+
+    // You might need to use Subscribe() instead of Watch() depending on the package version
+    changes, err := cfg.Subscribe(ctx) // Changed Watch to Subscribe
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    go func() {
+        for newCfg := range changes {
+            log.Printf("Config updated: %+v", newCfg)
+        }
+    }()
+
+    // Application logic...
+    select {}
+}

cmd/examples/multistore/main.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+    "context"
+    "errors"
+    "log"
+    "time"
+
+    "github.com/samuelarogbonlo/dynconf/pkg/dynconf"
+)
+
+type DatabaseConfig struct {
+    Host        string        `json:"host"`
+    Port        int           `json:"port"`
+    MaxConns    int           `json:"max_connections"`
+    IdleTimeout time.Duration `json:"idle_timeout"`
+}
+
+func main() {
+    ctx := context.Background()
+
+    // Create file source
+    fileSource, err := dynconf.NewFileSource[DatabaseConfig]("config.json")
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    // Create etcd source
+    etcdSource, err := dynconf.NewEtcdSource[DatabaseConfig](
+        []string{"localhost:2379"},
+        "/app/database",
+    )
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    // Create config with sources
+    cfg := dynconf.New[DatabaseConfig](
+        // Try the basic Option approach
+        dynconf.Option[DatabaseConfig](func(c *dynconf.Config[DatabaseConfig]) {
+            c.AddSource(fileSource)
+            c.AddSource(etcdSource)
+        }),
+        dynconf.WithValidation[DatabaseConfig](validateDatabase),
+        dynconf.WithRollback[DatabaseConfig](true),
+    )
+
+    changes, cleanup := cfg.Subscribe(ctx)
+    defer cleanup()
+
+    go func() {
+        for newCfg := range changes {
+            log.Printf("Database config updated: %+v", newCfg)
+            if err := updateDatabase(newCfg); err != nil {
+                log.Printf("Error updating database: %v", err)
+            }
+        }
+    }()
+
+    select {}
+}
+
+func validateDatabase(old, new DatabaseConfig) error {
+    if new.MaxConns <= 0 {
+        return errors.New("max connections must be positive")
+    }
+    if new.IdleTimeout < time.Second {
+        return errors.New("idle timeout must be at least 1 second")
+    }
+    return nil
+}
+
+func updateDatabase(cfg DatabaseConfig) error {
+    // Implementation to update database connection pool
+    return nil
+}

cmd/examples/rollout/main.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+    "context"
+    "errors"  // Added missing import
+    "log"
+
+    "github.com/samuelarogbonlo/dynconf/pkg/dynconf"
+)
+
+type FeatureConfig struct {
+    Enabled     bool    `json:"enabled"`
+    Percentage  float64 `json:"percentage"`
+    MaxRequests int     `json:"max_requests"`
+}
+
+func main() {
+    ctx := context.Background()
+
+    cfg := dynconf.New[FeatureConfig]()
+
+    // Create validation function
+    validateFunc := func(old, new FeatureConfig) error {
+        return validateFeature(new)
+    }
+
+    // Configure with validation
+    cfg = dynconf.New[FeatureConfig](
+        dynconf.WithValidation[FeatureConfig](validateFunc),
+        dynconf.WithRollback[FeatureConfig](true),
+    )
+
+    // Subscribe to changes instead of Watch
+    changes, cleanup := cfg.Subscribe(ctx)
+    defer cleanup()
+
+    // Create a rollout checker
+    isEnabled := func(cfg FeatureConfig) bool {
+        return cfg.Enabled && cfg.Percentage > 0
+    }
+
+    go func() {
+        for newCfg := range changes {
+            if isEnabled(newCfg) {
+                log.Printf("Applying feature config: %+v", newCfg)
+                if err := applyFeature(newCfg); err != nil {
+                    log.Printf("Error applying feature: %v", err)
+                }
+            }
+        }
+    }()
+
+    select {}
+}
+
+func validateFeature(cfg FeatureConfig) error {
+    if cfg.Percentage < 0 || cfg.Percentage > 100 {
+        return errors.New("percentage must be between 0 and 100")
+    }
+    if cfg.MaxRequests < 0 {
+        return errors.New("max requests must be non-negative")
+    }
+    return nil
+}
+
+func applyFeature(cfg FeatureConfig) error {
+    // Implementation to apply feature configuration
+    return nil
+}

docs/configuration-sources.md

@@ -0,0 +1,26 @@
+# docs/configuration-sources.md
+# Configuration Sources
+
+DynConf supports multiple configuration sources:
+
+## File Source
+
+```go
+source, err := dynconf.NewFileSource[AppConfig]("config.json")
+cfg := dynconf.New[AppConfig](dynconf.WithSource[AppConfig](source))
+```
+
+## Etcd Source
+
+```go
+source, err := dynconf.NewEtcdSource[AppConfig]([]string{"localhost:2379"}, "/app/config")
+cfg := dynconf.New[AppConfig](dynconf.WithSource[AppConfig](source))
+```
+
+## Consul Source
+
+```go
+source, err := dynconf.NewConsulSource[AppConfig]("localhost:8500", "app/config")
+cfg := dynconf.New[AppConfig](dynconf.WithSource[AppConfig](source))
+```
+

docs/contributing.md

@@ -0,0 +1,35 @@
+
+
+# docs/contributing.md
+# Contributing to DynConf
+
+## Development Setup
+
+1. Fork the repository
+2. Clone your fork:
+```bash
+git clone https://github.com/samuelarogbonlo/dynconf.git
+```
+
+3. Install dependencies:
+```bash
+go mod download
+```
+
+4. Run tests:
+```bash
+go test -v ./...
+```
+
+## Pull Request Process
+
+1. Create a new branch for your feature
+2. Add tests for new functionality
+3. Update documentation as needed
+4. Submit PR with description of changes
+
+## Code Style
+
+- Follow standard Go conventions
+- Use gofmt for formatting
+- Add comments for exported symbols

docs/getting-started.md

@@ -0,0 +1,43 @@
+# docs/getting-started.md
+# Getting Started with DynConf
+
+## Installation
+
+```bash
+go get github.com/samuelarogbonlo/dynconf
+```
+
+## Basic Usage
+
+1. Define your configuration type:
+
+```go
+type AppConfig struct {
+    ServerPort int           `json:"server_port"`
+    Timeout    time.Duration `json:"timeout"`
+}
+```
+
+2. Create a configuration instance:
+
+```go
+cfg := dynconf.New[AppConfig](
+    dynconf.WithValidation[AppConfig](validateConfig),
+    dynconf.WithRollback[AppConfig](true),
+)
+```
+
+3. Watch for changes:
+
+```go
+changes, err := cfg.Watch(context.Background())
+if err != nil {
+    log.Fatal(err)
+}
+
+go func() {
+    for newCfg := range changes {
+        // Handle configuration updates
+    }
+}()
+```

docs/metrics.md

@@ -0,0 +1,19 @@
+# docs/metrics.md
+# Metrics
+
+DynConf provides Prometheus metrics for monitoring:
+
+## Available Metrics
+
+- `config_updates_total`: Counter of configuration updates
+- `config_version`: Gauge of current configuration version
+- `validation_errors_total`: Counter of validation errors
+- `rollbacks_total`: Counter of configuration rollbacks
+- `update_duration_seconds`: Histogram of update durations
+
+## Usage
+
+```go
+metrics := dynconf.NewMetrics("myapp")
+cfg.WithMetrics(metrics)
+```