config

package
v1.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 31, 2017 License: Apache-2.0 Imports: 11 Imported by: 37

Documentation

Index

Constants

View Source 
const (
	//TerminateProcess signal that supervisor should kill other processes and exit process on failure
	TerminateProcess = "terminate"

	//IgnoreProcess signal that supervisor should ignore this process on failure
	IgnoreProcess = "ignore"
)
View Source 
const (
	Amalgam8Adapter   = "amalgam8"
	KubernetesAdapter = "kubernetes"
	EurekaAdapter     = "eureka"
)

Supported Service Registry/Discovery/Rules adapter

View Source 
const (
	HTTPHealthCheck    = "http"
	HTTPSHealthCheck   = "https"
	TCPHealthCheck     = "tcp"
	CommandHealthCheck = "file"
)

Health check types.

View Source 
const (
	EnvoyAdapter = "envoy"
)

Supported proxy adapters

Variables

View Source 
var DefaultConfig = Config{
	Register:     false,
	Proxy:        false,
	ProxyAdapter: EnvoyAdapter,
	DNS:          false,

	ProxyConfig: ProxyConfig{
		TLS:              false,
		CertChainFile:    "",
		PrivateKeyFile:   "",
		CACertFile:       "",
		HTTPListenerPort: 0,
		DiscoveryPort:    0,
		AdminPort:        0,
		WorkingDir:       "",
		LoggingDir:       "",
		ProxyBinary:      "",
		GRPCHTTP1Bridge:  false,
		TCPProxies:       nil,
	},

	Service: Service{
		Name: "",
		Tags: nil,
	},

	Endpoint: Endpoint{
		Host: "",
		Port: 0,
		Type: "http",
	},

	DiscoveryAdapter: Amalgam8Adapter,

	A8Registry: Amalgam8Registry{
		URL:   "",
		Token: "",
		Poll:  time.Duration(15 * time.Second),
	},

	A8Controller: Amalgam8Controller{
		URL:   "",
		Token: "",
		Poll:  time.Duration(15 * time.Second),
	},

	RulesAdapter: Amalgam8Adapter,

	Kubernetes: Kubernetes{
		URL:       "",
		Token:     "",
		Namespace: "default",
		PodName:   "",
	},

	Eureka: Eureka{
		URLs: []string{},
	},

	Dnsconfig: Dnsconfig{
		Port:   8053,
		Domain: "amalgam8",
	},

	HealthChecks: nil,

	LogLevel: "info",

	Commands: nil,
}

DefaultConfig defines default values for the various configuration options

View Source 
var Flags = []cli.Flag{
	cli.StringFlag{
		Name:   configFlag,
		EnvVar: envVar(configFlag),
		Usage:  "Load configuration from file",
	},
	cli.BoolFlag{
		Name:   registerFlag,
		EnvVar: envVar(registerFlag),
		Usage:  "Enable automatic service registration and heartbeat",
	},
	cli.BoolFlag{
		Name:   proxyFlag,
		EnvVar: envVar(proxyFlag),
		Usage:  "Start proxy",
	},
	cli.StringFlag{
		Name:   proxyAdapterFlag,
		EnvVar: envVar(proxyAdapterFlag),
		Usage:  fmt.Sprintf("Proxy adapter (%v)", strings.Join(SupportedAdapters, ", ")),
	},
	cli.BoolFlag{
		Name:   dnsFlag,
		EnvVar: envVar(dnsFlag),
		Usage:  "Enable DNS server",
	},
	cli.BoolFlag{
		Name:   proxyTLSFlag,
		EnvVar: envVar(proxyTLSFlag),
		Usage:  "Enable proxy TLS communication",
	},
	cli.StringFlag{
		Name:   proxyCertChainFileFlag,
		EnvVar: envVar(proxyCertChainFileFlag),
		Usage:  "File containing the certificate chain file for the service (to present to clients)",
	},
	cli.StringFlag{
		Name:   proxyPrivateKeyFileFlag,
		EnvVar: envVar(proxyPrivateKeyFileFlag),
		Usage:  "File containing the private key that corresponds to the certificate chain file",
	},
	cli.StringFlag{
		Name:   proxyCACertFileFlag,
		EnvVar: envVar(proxyCACertFileFlag),
		Usage:  "File containing CA certificate(s) to verify client connections",
	},
	cli.StringFlag{
		Name:   serviceFlag,
		EnvVar: envVar(serviceFlag),
		Usage:  "Service name to register with",
	},
	cli.StringFlag{
		Name:   endpointHostFlag,
		EnvVar: envVar(endpointHostFlag),
		Usage:  "Service endpoint host name (local IP is used if none specified)",
	},
	cli.IntFlag{
		Name:   endpointPortFlag,
		EnvVar: envVar(endpointPortFlag),
		Usage:  "Service endpoint port",
	},
	cli.StringFlag{
		Name:   endpointTypeFlag,
		EnvVar: envVar(endpointTypeFlag),
		Usage:  "Service endpoint type (http, https, tcp, udp, user)",
	},
	cli.StringFlag{
		Name:   discoveryAdapterFlag,
		EnvVar: envVar(discoveryAdapterFlag),
		Usage:  fmt.Sprintf("Discovery adapter (%s, %s, %s)", Amalgam8Adapter, KubernetesAdapter, EurekaAdapter),
	},
	cli.StringFlag{
		Name:   registryURLFlag,
		EnvVar: envVar(registryURLFlag),
		Usage:  "URL for Amalgam8 Registry",
	},
	cli.StringFlag{
		Name:   registryTokenFlag,
		EnvVar: envVar(registryTokenFlag),
		Usage:  "API token for Amalgam8 Registry",
	},
	cli.DurationFlag{
		Name:   registryPollFlag,
		EnvVar: envVar(registryPollFlag),
		Usage:  "Interval for polling Amalgam8 Registry",
	},
	cli.StringFlag{
		Name:   kubernetesURLFlag,
		EnvVar: envVar(kubernetesURLFlag),
		Usage:  "URL for Kubernetes API server",
	},
	cli.StringFlag{
		Name:   kubernetesTokenFlag,
		EnvVar: envVar(kubernetesTokenFlag),
		Usage:  "API token for Kubernetes API server",
	},
	cli.StringFlag{
		Name:   kubernetesNamespaceFlag,
		EnvVar: envVar(kubernetesNamespaceFlag),
		Usage:  "Kubernetes API namespace",
	},
	cli.StringFlag{
		Name:   kubernetesPodNameFlag,
		EnvVar: envVar(kubernetesPodNameFlag),
		Usage:  "Kubernetes Pod name, to be used for automatic detection of service name and labels",
	},
	cli.StringSliceFlag{
		Name:   eurekaURLFlag,
		EnvVar: envVar(eurekaURLFlag),
		Usage:  "List of Eureka server URLs",
	},
	cli.StringFlag{
		Name:   rulesAdapterFlag,
		EnvVar: envVar(rulesAdapterFlag),
		Usage:  fmt.Sprintf("Rules service adapter (%s, %s)", Amalgam8Adapter, KubernetesAdapter),
	},
	cli.StringFlag{
		Name:   controllerURLFlag,
		EnvVar: envVar(controllerURLFlag),
		Usage:  "URL for Amalgam8 Controller",
	},
	cli.StringFlag{
		Name:   controllerTokenFlag,
		EnvVar: envVar(controllerTokenFlag),
		Usage:  "API token for Amalgam8 Controller",
	},
	cli.DurationFlag{
		Name:   controllerPollFlag,
		EnvVar: envVar(controllerPollFlag),
		Usage:  "Interval for polling Amalgam8 Rules",
	},
	cli.StringFlag{
		Name:   dnsConfigPortFlag,
		EnvVar: envVar(dnsConfigPortFlag),
		Usage:  "DNS server port number",
	},
	cli.StringFlag{
		Name:   dnsConfigDomainFlag,
		EnvVar: envVar(dnsConfigDomainFlag),
		Usage:  "DNS server authorization domain name",
	},
	cli.BoolFlag{
		Name:   superviseFlag,
		EnvVar: envVar(superviseFlag),
		Usage:  "Deprecated - this flag is no longer required and will be ignored",
	},
	cli.StringSliceFlag{
		Name:   healthchecksFlag,
		EnvVar: envVar(healthchecksFlag),
		Usage:  "List of health check URLs",
	},
	cli.StringFlag{
		Name:   logLevelFlag,
		EnvVar: envVar(logLevelFlag),
		Usage:  "Logging level (debug, info, warn, error, fatal, panic)",
	},
}

Flags is the set of supported flags

View Source 
var SupportedAdapters = []string{EnvoyAdapter}

SupportedAdapters is the set of supported proxy adapters

Functions

func Validate 

func Validate(validators []ValidatorFunc) error

Validate runs validation checks

Types

type Amalgam8Controller added in v1.0.0 

type Amalgam8Controller struct {
	URL   string        `yaml:"url"`
	Token string        `yaml:"token"`
	Poll  time.Duration `yaml:"poll"`
}

Amalgam8Controller configuration

type Amalgam8Registry added in v1.0.0 

type Amalgam8Registry struct {
	URL   string        `yaml:"url"`
	Token string        `yaml:"token"`
	Poll  time.Duration `yaml:"poll"`
}

Amalgam8Registry configuration

type Command added in v0.4.1 

type Command struct {
	Cmd       []string `yaml:"cmd"`
	Env       []string `yaml:"env"`
	OnExit    string   `yaml:"on_exit"`
	KillGroup bool     `yaml:"kill_group"`
}

Command to be managed by sidecar app supervisor

type Config 

type Config struct {
	Register     bool   `yaml:"register"`
	Proxy        bool   `yaml:"proxy"`
	ProxyAdapter string `yaml:"proxy_adapter"`
	DNS          bool   `yaml:"dns"`

	Service  Service  `yaml:"service"`
	Endpoint Endpoint `yaml:"endpoint"`

	DiscoveryAdapter string `yaml:"discovery_adapter"`
	RulesAdapter     string `yaml:"rules_adapter"`

	A8Registry   Amalgam8Registry   `yaml:"registry"`
	A8Controller Amalgam8Controller `yaml:"controller"`
	Kubernetes   Kubernetes         `yaml:"kubernetes"`
	Eureka       Eureka             `yaml:"eureka"`

	Dnsconfig Dnsconfig `yaml:"dnsconfig"`

	Supervise bool `yaml:"supervise"`

	HealthChecks []HealthCheck `yaml:"healthchecks"`

	ProxyConfig ProxyConfig `yaml:"proxy_config"`

	LogLevel string `yaml:"log_level"`

	Commands []Command `yaml:"commands"`
}

Config stores the various configuration options for the sidecar

func New 

func New(context *cli.Context) (*Config, error)

New creates a new Config object from the given commandline flags, environment variables, and configuration file context.

func (*Config) Validate 

func (c *Config) Validate() error

Validate the configuration

type Dnsconfig added in v0.4.1 

type Dnsconfig struct {
	Port   int    `yaml:"port"`
	Domain string `yaml:"domain"`
}

Dnsconfig - DNS server configuration

type Endpoint 

type Endpoint struct {
	Host string `yaml:"host"`
	Port int    `yaml:"port"`
	Type string `yaml:"type"`
}

Endpoint configuration

type Eureka added in v1.0.0 

type Eureka struct {
	URLs []string `yaml:"urls"`
}

Eureka configuration

type HealthCheck added in v0.4.0 

type HealthCheck struct {
	Type       string        `yaml:"type"`
	Value      string        `yaml:"value"`
	Interval   time.Duration `yaml:"interval"`
	Timeout    time.Duration `yaml:"timeout"`
	Method     string        `yaml:"method"`
	Code       int           `yaml:"code"`
	Args       []string      `yaml:"args"`
	CACertFile string        `yaml:"ca_cert_file"`
}

HealthCheck configuration.

type Kubernetes added in v1.0.0 

type Kubernetes struct {
	URL       string `yaml:"url"`
	Token     string `yaml:"token"`
	Namespace string `yaml:"namespace"`
	PodName   string `yaml:"pod_name"`
}

Kubernetes configuration

type ProxyConfig added in v1.0.0 

type ProxyConfig struct {
	TLS              bool             `yaml:"tls"`
	CertChainFile    string           `yaml:"cert_chain_file"`
	PrivateKeyFile   string           `yaml:"private_key_file"`
	CACertFile       string           `yaml:"ca_cert_file"`
	HTTPListenerPort int              `yaml:"http_listener_port"`
	DiscoveryPort    int              `yaml:"sds_port"`
	AdminPort        int              `yaml:"admin_port"`
	WorkingDir       string           `yaml:"working_dir"`
	LoggingDir       string           `yaml:"logging_dir"`
	ProxyBinary      string           `yaml:"proxy_binary_path"`
	GRPCHTTP1Bridge  bool             `yaml:"grpc_http1_bridge,omitempty"`
	TCPProxies       []TCPProxyConfig `yaml:"tcp_proxies"`
}

ProxyConfig stores proxy configuration.

type Service 

type Service struct {
	Name string   `yaml:"name"`
	Tags []string `yaml:"tags"`
}

Service configuration

type TCPProxyConfig added in v1.1.0 

type TCPProxyConfig struct {
	Service      string `yaml:"service"`
	ListenerPort int    `yaml:"listener_port"`
}

TCPProxyConfig tcp listeners for envoy

type ValidatorFunc 

type ValidatorFunc func() error

ValidatorFunc performs a validation check

func IsEmptyOrValidURL added in v1.0.0 

func IsEmptyOrValidURL(name, value string) ValidatorFunc

IsEmptyOrValidURL ensures that the URL is either empty, or is a valid URL

func IsInRange 

func IsInRange(name string, value, min, max int) ValidatorFunc

IsInRange ensures the integer is within the specified inclusive range

func IsInRangeDuration 

func IsInRangeDuration(name string, value, min, max time.Duration) ValidatorFunc

IsInRangeDuration ensures the time value is between the given min and max times

func IsInSet 

func IsInSet(name, value string, set []string) ValidatorFunc

IsInSet ensures that the value is a member of the set

func IsNotEmpty 

func IsNotEmpty(name, value string) ValidatorFunc

IsNotEmpty ensures the value is not empty

func IsValidDomain added in v0.4.1 

func IsValidDomain(name, value string) ValidatorFunc

IsValidDomain ensures the domain name is valid domain and that it contains only one domain.

func IsValidURL 

func IsValidURL(name, value string) ValidatorFunc

IsValidURL ensures that the URL is valid and has a protocol specified (http, https, etc...)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.