mirror of https://github.com/status-im/consul.git
112 lines
3.8 KiB
Go
112 lines
3.8 KiB
Go
package proxy
|
|
|
|
import (
|
|
"io/ioutil"
|
|
|
|
"github.com/hashicorp/consul/api"
|
|
"github.com/hashicorp/hcl"
|
|
)
|
|
|
|
// Config is the publicly configurable state for an entire proxy instance. It's
|
|
// mostly used as the format for the local-file config mode which is mostly for
|
|
// dev/testing. In normal use, different parts of this config are pulled from
|
|
// different locations (e.g. command line, agent config endpoint, agent
|
|
// certificate endpoints).
|
|
type Config struct {
|
|
// ProxyID is the identifier for this proxy as registered in Consul. It's only
|
|
// guaranteed to be unique per agent.
|
|
ProxyID string `json:"proxy_id" hcl:"proxy_id"`
|
|
|
|
// Token is the authentication token provided for queries to the local agent.
|
|
Token string `json:"token" hcl:"token"`
|
|
|
|
// ProxiedServiceName is the name of the service this proxy is representing.
|
|
ProxiedServiceName string `json:"proxied_service_name" hcl:"proxied_service_name"`
|
|
|
|
// ProxiedServiceNamespace is the namespace of the service this proxy is
|
|
// representing.
|
|
ProxiedServiceNamespace string `json:"proxied_service_namespace" hcl:"proxied_service_namespace"`
|
|
|
|
// PublicListener configures the mTLS listener.
|
|
PublicListener PublicListenerConfig `json:"public_listener" hcl:"public_listener"`
|
|
|
|
// Upstreams configures outgoing proxies for remote connect services.
|
|
Upstreams []UpstreamConfig `json:"upstreams" hcl:"upstreams"`
|
|
|
|
// DevCAFile allows passing the file path to PEM encoded root certificate
|
|
// bundle to be used in development instead of the ones supplied by Connect.
|
|
DevCAFile string `json:"dev_ca_file" hcl:"dev_ca_file"`
|
|
|
|
// DevServiceCertFile allows passing the file path to PEM encoded service
|
|
// certificate (client and server) to be used in development instead of the
|
|
// ones supplied by Connect.
|
|
DevServiceCertFile string `json:"dev_service_cert_file" hcl:"dev_service_cert_file"`
|
|
|
|
// DevServiceKeyFile allows passing the file path to PEM encoded service
|
|
// private key to be used in development instead of the ones supplied by
|
|
// Connect.
|
|
DevServiceKeyFile string `json:"dev_service_key_file" hcl:"dev_service_key_file"`
|
|
}
|
|
|
|
// ConfigWatcher is a simple interface to allow dynamic configurations from
|
|
// plugggable sources.
|
|
type ConfigWatcher interface {
|
|
// Watch returns a channel that will deliver new Configs if something external
|
|
// provokes it.
|
|
Watch() <-chan *Config
|
|
}
|
|
|
|
// StaticConfigWatcher is a simple ConfigWatcher that delivers a static Config
|
|
// once and then never changes it.
|
|
type StaticConfigWatcher struct {
|
|
ch chan *Config
|
|
}
|
|
|
|
// NewStaticConfigWatcher returns a ConfigWatcher for a config that never
|
|
// changes. It assumes only one "watcher" will ever call Watch. The config is
|
|
// delivered on the first call but will never be delivered again to allow
|
|
// callers to call repeatedly (e.g. select in a loop).
|
|
func NewStaticConfigWatcher(cfg *Config) *StaticConfigWatcher {
|
|
sc := &StaticConfigWatcher{
|
|
// Buffer it so we can queue up the config for first delivery.
|
|
ch: make(chan *Config, 1),
|
|
}
|
|
sc.ch <- cfg
|
|
return sc
|
|
}
|
|
|
|
// Watch implements ConfigWatcher on a static configuration for compatibility.
|
|
// It returns itself on the channel once and then leaves it open.
|
|
func (sc *StaticConfigWatcher) Watch() <-chan *Config {
|
|
return sc.ch
|
|
}
|
|
|
|
// ParseConfigFile parses proxy configuration form a file for local dev.
|
|
func ParseConfigFile(filename string) (*Config, error) {
|
|
bs, err := ioutil.ReadFile(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var cfg Config
|
|
|
|
err = hcl.Unmarshal(bs, &cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &cfg, nil
|
|
}
|
|
|
|
// AgentConfigWatcher watches the local Consul agent for proxy config changes.
|
|
type AgentConfigWatcher struct {
|
|
client *api.Client
|
|
}
|
|
|
|
// Watch implements ConfigWatcher.
|
|
func (w *AgentConfigWatcher) Watch() <-chan *Config {
|
|
watch := make(chan *Config)
|
|
// TODO implement me
|
|
return watch
|
|
}
|