config

README

Configuration Module Documentation

This Go module provides a singleton configuration object C() that encapsulates various configurations essential for your application. The configurations are filled during the package initialization (init()) by loading from config.yml, Default(), and environment variables.

Usage

Installation

To use this, import the package in your code:

import "your_module_path/config"

Configuration Options

The package allows setting up configurations in three ways:

1. Environment Variables
2. Default Settings via Default()
3. Initialization from config.yml

1. Using Environment Variables

💡 Use this way for storing important secrets that should not be hard coded in repo or in config.yml file. For example, DB_PASSWORD, or JWT_SECRET.

Environment variables are used to configure the application at runtime. The variable names must start with ORMUS_, and nested variables should use __ as a separator (ORMUS_DB__HOST).

Example setting environment variables:

os.Setenv("ORMUS_DEBUG", "true")
os.Setenv("ORMUS_MULTI_WORD_VAR", "this is a multi-word var")
// ... set other environment variables ...

2. Initialization from config.yml

💡 Store variables which are dependant to the environment that code is running or the area, the variables that change more frequent.

The package supports loading configurations from a YAML file named config.yml. Ensure the YAML file is in the correct format.

Example config.yml file:

debug: true
multi_word_var: "this is a multi-word var in YAML"
db: 
  username: ormus
  password: youcannotbreakme
# ... other configurations ...

3. Default Settings via Default()

💡 Store variables which they have the least probability of change. The Default() function in the package allows defining default configurations that act as fallbacks. This function should return a Config struct.

Example of defining default configurations:

// Define default configurations
func Default() config.Config {
    return config.Config{
        // Define your default configurations here
        Debug:        true,
        MultiWordVar: "default value",
		Manager: manager.Config{
            JWTConfig: auth.JwtConfig{
                SecretKey: "the_most_secure_secret_of_all_time",
            },
        },
        // ... other default configurations ...
    }
}

Accessing Configuration

Accessing the Configuration Singleton

To access the configuration object:

// Get the configuration object
cfg := config.C()

Adding New Configurations

For adding new configurations, update the Config struct in the package and ensure it is filled during the initialization process in the init() function. Following this, access the updated configuration using the C() function.

Example

Here's an example demonstrating how to access the configuration object and add new configurations:

package main

import (
    "fmt"
    "your_module_path/config"
)

func main() {
    // Access the configuration object
    loadedConfig := config.C()

    // Access existing configurations
    fmt.Println("Debug mode:", loadedConfig.Debug)
    fmt.Println("Multi-word var:", loadedConfig.MultiWordVar)
    // ... access other configurations ...

    // Add new configurations (modify the Config struct in the package)
    loadedConfig.NewConfig = "new value"

    // Access the newly added configuration
    fmt.Println("New Config:", loadedConfig.NewConfig)
}

Important Notes

• The Config object, accessed via C(), encapsulates all configurations set during the package initialization.
• To add or modify configurations, update the Config struct and ensure it is filled during the initialization process (init()).
• The C() function returns a singleton instance of the configuration object filled by the init() function, consolidating settings from config.yml, Default(), and environment variables.

Conclusion

This configuration module provides a convenient singleton object encapsulating configurations filled from config.yml, Default(), and environment variables during initialization. Use C() to access the configurations and extend the Config struct to incorporate additional settings as needed.

Documentation

Index

• Constants
• type Config
  • func C() Config
  • func Default() Config
  • func New(opt Option) Config
• type Option
• type Swagger
• type SwaggerConfig

Constants

const (
	TimeoutCluster = 5 * time.Second

	// NumRetries represents the number of retries in the ExponentialBackoffRetryPolicy.
	NumRetries = 5

	// MinRetryDelay represents the minimum delay duration in the ExponentialBackoffRetryPolicy.
	MinRetryDelay = time.Second

	// MaxRetryDelay represents the maximum delay duration in the ExponentialBackoffRetryPolicy.
	MaxRetryDelay = 10 * time.Second
)

const (
	ChannelSize    = 100
	NumberInstant  = 100
	MaxRetryPolicy = 10
)

Types

type Config

type Config struct {
	Redis       redis.Config           `koanf:"redis"`
	Etcd        etcd.Config            `koanf:"etcd"`
	RabbitMq    rabbitmqchannel.Config `koanf:"rabbitmq"`
	Manager     manager.Config         `koanf:"manager"`
	Source      source.Config          `koanf:"source"`
	Destination dconfig.Config         `koanf:"destination"`
	Scylladb    scylladb.Config        `koanf:"scylladb"`
	Swagger     Swagger                `koanf:"swagger"`
}

func C

func C() Config

func Default

func Default() Config

func New

func New(opt Option) Config

type Option

type Option struct {
	Prefix       string
	Delimiter    string
	Separator    string
	YamlFilePath string
	CallbackEnv  func(string) string
}

type Swagger

type Swagger struct {
	Port    int           `koanf:"port"`
	Expose  bool          `koanf:"expose"`
	Manager SwaggerConfig `koanf:"manager"`
	Source  SwaggerConfig `koanf:"source"`
}

type SwaggerConfig

type SwaggerConfig struct {
	Version          string `koanf:"version"`
	Host             string `koanf:"host"`
	BasePath         string `koanf:"base_path"`
	Title            string `koanf:"title"`
	Description      string `koanf:"description"`
	InfoInstanceName string `koanf:"info_instance_name"`
}