envconfig

README

envconfig

import "github.com/kelseyhightower/envconfig"

Documentation

See godoc

Usage

Set some environment variables:

export MYAPP_DEBUG=false
export MYAPP_PORT=8080
export MYAPP_USER=Kelsey
export MYAPP_RATE="0.5"
export MYAPP_TIMEOUT="3m"
export MYAPP_USERS="rob,ken,robert"
export MYAPP_COLORCODES="red:1,green:2,blue:3"

Write some code:

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/kelseyhightower/envconfig"
)

type Specification struct {
    Debug       bool
    Port        int
    User        string
    Users       []string
    Rate        float32
    Timeout     time.Duration
    ColorCodes  map[string]int
}

func main() {
    var s Specification
    err := envconfig.Process("myapp", &s)
    if err != nil {
        log.Fatal(err.Error())
    }
    format := "Debug: %v\nPort: %d\nUser: %s\nRate: %f\nTimeout: %s\n"
    _, err = fmt.Printf(format, s.Debug, s.Port, s.User, s.Rate, s.Timeout)
    if err != nil {
        log.Fatal(err.Error())
    }

    fmt.Println("Users:")
    for _, u := range s.Users {
        fmt.Printf("  %s\n", u)
    }

    fmt.Println("Color codes:")
    for k, v := range s.ColorCodes {
        fmt.Printf("  %s: %d\n", k, v)
    }
}

Results:

Debug: false
Port: 8080
User: Kelsey
Rate: 0.500000
Timeout: 3m0s
Users:
  rob
  ken
  robert
Color codes:
  red: 1
  green: 2
  blue: 3

Struct Tag Support

Envconfig supports the use of struct tags to specify alternate, default, and required environment variables.

For example, consider the following struct:

type Specification struct {
    ManualOverride1 string `envconfig:"manual_override_1"`
    DefaultVar      string `default:"foobar"`
    RequiredVar     string `required:"true"`
    IgnoredVar      string `ignored:"true"`
    AutoSplitVar    string `split_words:"true"`
    RequiredAndAutoSplitVar    string `required:"true" split_words:"true"`
}

Envconfig has automatic support for CamelCased struct elements when the split_words:"true" tag is supplied. Without this tag, AutoSplitVar above would look for an environment variable called MYAPP_AUTOSPLITVAR. With the setting applied it will look for MYAPP_AUTO_SPLIT_VAR. Note that numbers will get globbed into the previous word. If the setting does not do the right thing, you may use a manual override.

Envconfig will process value for ManualOverride1 by populating it with the value for MYAPP_MANUAL_OVERRIDE_1. Without this struct tag, it would have instead looked up MYAPP_MANUALOVERRIDE1. With the split_words:"true" tag it would have looked up MYAPP_MANUAL_OVERRIDE1.

export MYAPP_MANUAL_OVERRIDE_1="this will be the value"

# export MYAPP_MANUALOVERRIDE1="and this will not"

If envconfig can't find an environment variable value for MYAPP_DEFAULTVAR, it will populate it with "foobar" as a default value.

If envconfig can't find an environment variable value for MYAPP_REQUIREDVAR, it will return an error when asked to process the struct. If MYAPP_REQUIREDVAR is present but empty, envconfig will not return an error.

If envconfig can't find an environment variable in the form PREFIX_MYVAR, and there is a struct tag defined, it will try to populate your variable with an environment variable that directly matches the envconfig tag in your struct definition:

export SERVICE_HOST=127.0.0.1
export MYAPP_DEBUG=true

type Specification struct {
    ServiceHost string `envconfig:"SERVICE_HOST"`
    Debug       bool
}

Envconfig won't process a field with the "ignored" tag set to "true", even if a corresponding environment variable is set.

Supported Struct Field Types

envconfig supports these struct field types:

• string
• int8, int16, int32, int64
• bool
• float32, float64
• slices of any supported type
• maps (keys and values of any supported type)
• encoding.TextUnmarshaler
• encoding.BinaryUnmarshaler
• time.Duration

Embedded structs using these fields are also supported.

Custom Decoders

Any field whose type (or pointer-to-type) implements envconfig.Decoder can control its own deserialization:

export DNS_SERVER=8.8.8.8

type IPDecoder net.IP

func (ipd *IPDecoder) Decode(value string) error {
    *ipd = IPDecoder(net.ParseIP(value))
    return nil
}

type DNSConfig struct {
    Address IPDecoder `envconfig:"DNS_SERVER"`
}

Also, envconfig will use a Set(string) error method like from the flag.Value interface if implemented.

Documentation

Overview

Package envconfig implements decoding of environment variables based on a user defined specification. A typical use is using environment variables for configuration settings.

Index

• Constants
• Variables
• func CheckDisallowed(prefix string, spec interface{}) error
• func ConvertToStr(v interface{}) (string, error)
• func LoadDefaultFromYml(filePath string) error
• func MustProcess(prefix string, spec interface{})
• func Process(prefix string, spec interface{}) error
• func Usage(prefix string, spec interface{}, security bool) error
• func Usagef(prefix string, spec interface{}, out io.Writer, format string, security bool) error
• func Usaget(prefix string, spec interface{}, out io.Writer, tmpl *template.Template) error
• type Decoder
• type Duration
  • func (d Duration) MarshalText() (text []byte, err error)
  • func (d Duration) String() string
  • func (d *Duration) UnmarshalText(text []byte) error
• type Endpoint
  • func ParseEndpoint(text string) (*Endpoint, error)
  • func (e Endpoint) Host() string
  • func (e *Endpoint) IsTLS() bool
  • func (e Endpoint) IsZero() bool
  • func (e Endpoint) MarshalText() (text []byte, err error)
  • func (e Endpoint) SecurityString() string
  • func (e Endpoint) String() string
  • func (e *Endpoint) UnmarshalText(text []byte) error
• type EnvVar
  • func GatherInfo(prefix string, spec interface{}) ([]EnvVar, error)
  • func (e EnvVar) GetValue(security bool) string
• type ISecurityStringer
• type ParseError
  • func (e *ParseError) Error() string
• type Password
  • func (p Password) SecurityString() string
  • func (p Password) String() string
• type Setter

Constants

const (
	// DefaultListFormat constant to use to display usage in a list format
	DefaultListFormat = `` /* 316-byte string literal not displayed */

	// DefaultTableFormat constant to use to display usage in a tabular format
	DefaultTableFormat = `` /* 281-byte string literal not displayed */

)

Variables

var ErrInvalidSpecification = errors.New("specification must be a struct pointer")

ErrInvalidSpecification indicates that a specification is of the wrong type.

var (
	UnSupportTypeError = errors.New("un support type")
)

Functions

func CheckDisallowed

func CheckDisallowed(prefix string, spec interface{}) error

CheckDisallowed checks that no environment variables with the prefix are set that we don't know how or want to parse. This is likely only meaningful with a non-empty prefix.

func ConvertToStr

func ConvertToStr(v interface{}) (string, error)

func LoadDefaultFromYml

func LoadDefaultFromYml(filePath string) error

func MustProcess

func MustProcess(prefix string, spec interface{})

MustProcess is the same as Process but panics if an error occurs

func Process

func Process(prefix string, spec interface{}) error

Process populates the specified struct based on environment variables

func Usage

func Usage(prefix string, spec interface{}, security bool) error

Usage writes usage information to stdout using the default header and table format

func Usagef

func Usagef(prefix string, spec interface{}, out io.Writer, format string, security bool) error

Usagef writes usage information to the specified io.Writer using the specifed template specification

func Usaget

func Usaget(prefix string, spec interface{}, out io.Writer, tmpl *template.Template) error

Usaget writes usage information to the specified io.Writer using the specified template

Types

type Decoder

type Decoder interface {
	Decode(value string) error
}

Decoder has the same semantics as Setter, but takes higher precedence. It is provided for historical compatibility.

type Duration

type Duration time.Duration

func (Duration) MarshalText

func (d Duration) MarshalText() (text []byte, err error)

func (Duration) String

func (d Duration) String() string

func (*Duration) UnmarshalText

func (d *Duration) UnmarshalText(text []byte) error

type Endpoint

type Endpoint struct {
	Scheme   string
	Hostname string
	Port     uint16
	Base     string
	Username string
	Password string
	Extra    url.Values
}

openapi:strfmt endpoint

func ParseEndpoint

func ParseEndpoint(text string) (*Endpoint, error)

func (Endpoint) Host

func (e Endpoint) Host() string

func (*Endpoint) IsTLS

func (e *Endpoint) IsTLS() bool

func (Endpoint) IsZero

func (e Endpoint) IsZero() bool

func (Endpoint) MarshalText

func (e Endpoint) MarshalText() (text []byte, err error)

func (Endpoint) SecurityString

func (e Endpoint) SecurityString() string

func (Endpoint) String

func (e Endpoint) String() string

func (*Endpoint) UnmarshalText

func (e *Endpoint) UnmarshalText(text []byte) error

type EnvVar

type EnvVar struct {
	Name  string
	Alt   string
	Key   string
	Field reflect.Value
	Tags  reflect.StructTag
}

EnvVar maintains information about the configuration variable

func GatherInfo

func GatherInfo(prefix string, spec interface{}) ([]EnvVar, error)

GatherInfo gathers information about the specified struct

func (EnvVar) GetValue

func (e EnvVar) GetValue(security bool) string

type ISecurityStringer

type ISecurityStringer interface {
	SecurityString() string
}

type ParseError

type ParseError struct {
	KeyName   string
	FieldName string
	TypeName  string
	Value     string
	Err       error
}

A ParseError occurs when an environment variable cannot be converted to the type required by a struct field during assignment.

func (*ParseError) Error

func (e *ParseError) Error() string

type Password

type Password string

func (Password) SecurityString

func (p Password) SecurityString() string

func (Password) String

func (p Password) String() string

type Setter

type Setter interface {
	Set(value string) error
}

Setter is implemented by types can self-deserialize values. Any type that implements flag.Value also implements Setter.