confiflow

ConfiFlow

ConfiFlow is a flexible, multi-source configuration management library for Go applications. It provides a unified interface for accessing configuration data from various sources like files, environment variables, Git repositories, and Consul.

Features

• Multiple Sources: Load configuration from files, Git, Consul, environment variables, and more
• Dynamic Updates: Watch for configuration changes and get notified automatically
• Structured Data: Access specific values within JSON and YAML configurations
• Template Support: Render configuration templates with variables
• Schema Validation: Validate configurations against JSON schemas
• Configuration Merging: Combine multiple configurations into a unified view
• Caching: Improve performance with an optional caching layer
• FIPS Compliance: FIPS 140-2 compliant mode for security-sensitive applications

Installation

go get github.com/Michi01/ConfiFlow

Usage

Here's a comprehensive example demonstrating the usage of ConfiFlow:

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/Michi01/ConfiFlow"
)

func main() {
	// Create a new client
	client := confiflow.NewClient(
		confiflow.WithCacheEnabled(true),
		confiflow.WithDefaultProvider("file"),
	)
	defer client.Close()

	// Register default providers
	client.RegisterDefaultProviders()

	// Add a file provider
	client.AddSource(confiflow.Source{
		Type:     "file",
		Location: "./configs",
	})

	// Access a file
	ctx := context.Background()
	data, err := client.Get(ctx, "file:app.json")
	if err != nil {
		log.Fatalf("Failed to get config: %v", err)
	}
	fmt.Println(string(data))

	// Access a specific value in a structured configuration
	value, err := client.GetValue(ctx, "file:app.json#/database/host")
	if err != nil {
		log.Fatalf("Failed to get value: %v", err)
	}
	fmt.Println("Database host:", value)

	// Watch for configuration changes
	watchChan, err := client.Watch(ctx, "file:app.json")
	if err != nil {
		log.Fatalf("Failed to watch config: %v", err)
	}

	// Monitor for changes
	go func() {
		for {
			<-watchChan
			fmt.Println("Configuration changed!")
		}
	}()

	// Add a Consul provider
	client.AddSource(confiflow.Source{
		Type:     "consul",
		Location: "localhost:8500",
		Options: map[string]string{
			"prefix": "myapp/config",
			"token":  "consul-token",
		},
	})

	// Access a key from Consul
	data, err = client.Get(ctx, "consul:database")
	if err != nil {
		log.Fatalf("Failed to get Consul data: %v", err)
	}

	// Watch and unmarshal configuration
	var config AppConfig
	err = client.WatchAndUnmarshal(ctx, "file:app.json", &config, func() {
		fmt.Println("Config updated, new log level:", config.LogLevel)
	})
	if err != nil {
		log.Fatalf("Failed to watch and unmarshal: %v", err)
	}

	// Merge configurations
	mergeOpts := confiflow.MergeOptions{
		Strategy:      "deep",
		ArrayMerge:    "append",
		IgnoreMissing: true,
	}

	merged, err := client.MergeConfigs(ctx, []string{
		"file:default.json",
		"file:environment.json",
		"file:local.json",
	}, mergeOpts)
	if err != nil {
		log.Fatalf("Failed to merge configs: %v", err)
	}
	fmt.Println("Merged config:", string(merged))

	// Render template
	templateOpts := confiflow.TemplateOptions{
		IncludeEnv: true,
		CustomValues: map[string]interface{}{
			"version": "1.0.0",
		},
	}

	rendered, err := client.RenderTemplate(ctx, "file:templates/app.yaml.tmpl", templateOpts)
	if err != nil {
		log.Fatalf("Failed to render template: %v", err)
	}
	fmt.Println("Rendered template:", string(rendered))

	// Validate configuration
	valid, errors, err := client.ValidateConfig(ctx, "file:app.json", "file:schemas/app.schema.json")
	if err != nil {
		log.Fatalf("Failed to validate config: %v", err)
	}
	if !valid {
		for _, errMsg := range errors {
			fmt.Println("Validation error:", errMsg)
		}
	}

	// Create an HTTP server for the configuration API
	server, err := client.NewHTTPServer(":8080",
		confiflow.WithAuthToken("secure-token"),
		confiflow.WithTLS("cert.pem", "key.pem"),
	)
	if err != nil {
		log.Fatalf("Failed to create HTTP server: %v", err)
	}

	// Start the server
	go server.Start()

	// Wait for exit
	select {}
}

Configuration File

ConfiFlow can be configured using a JSON configuration file. Here's an example:

{
  "refreshInterval": "1m",
  "cacheEnabled": true,
  "cacheExpiration": "5m",
  "cacheCleanup": "10m",
  "defaultProvider": "file",
  "fipsMode": false,
  "sources": [
    {
      "name": "local",
      "type": "file",
      "location": "./configs"
    },
    {
      "name": "remote",
      "type": "git",
      "location": "https://github.com/username/repo.git",
      "options": {
        "branch": "main",
        "auth": "token",
        "token": "your-personal-access-token"
      }
    },
    {
      "name": "kvstore",
      "type": "consul",
      "location": "localhost:8500",
      "options": {
        "prefix": "myapp/config"
      }
    }
  ]
}

To load the client configuration from a file:

// Load client from config file
client, err := confiflow.ConfigFromFile(ctx, "confiflow.json")
if err != nil {
	log.Fatalf("Failed to load config: %v", err)
}

Documentation

For detailed documentation on all features and options, please refer to the GoDoc page.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

This project is licensed under the MIT License - see the LICENSE file for details.