func (s *ConsulSuite) setupConsul(c *check.C) { s.createComposeProject(c, "consul") s.composeProject.Start(c) consul.Register() kv, err := libkv.NewStore( store.CONSUL, []string{s.composeProject.Container(c, "consul").NetworkSettings.IPAddress + ":8500"}, &store.Config{ ConnectionTimeout: 10 * time.Second, }, ) if err != nil { c.Fatal("Cannot create store consul") } s.kv = kv // wait for consul err = utils.Try(60*time.Second, func() error { _, err := kv.Exists("test") if err != nil { return err } return nil }) c.Assert(err, checker.IsNil) }
func NewBgpRouteManager(masterIface string, server net.IP, as string) *BgpRouteManager { b := &BgpRouteManager{ ethIface: masterIface, server: server, neighborlist: map[string]string{}, asnum: as, } consul.Register() client := "localhost:8500" kv, err := libkv.NewStore( store.CONSUL, // or "consul" []string{client}, &store.Config{ ConnectionTimeout: 10 * time.Second, }, ) b.kv = kv if err != nil { log.Fatal("Cannot create store consul") } b.neighborkey = "bgpneighbor" if exist, _ := kv.Exists(b.neighborkey); exist == false { err := b.kv.Put(b.neighborkey, []byte("bgpneighbor"), &store.WriteOptions{IsDir: true}) if err != nil { fmt.Errorf("Something went wrong when initializing key %v", b.neighborkey) } } err = b.kv.Put(b.neighborkey+"/"+server.String(), []byte(as), nil) if err != nil { log.Errorf("Error trying to put value at key: %v", b.neighborkey) } return b }
// Init is exported func Init() { // Register to libkv zookeeper.Register() consul.Register() etcd.Register() // Register to internal Swarm discovery service discovery.Register("zk", &Discovery{backend: store.ZK}) discovery.Register("consul", &Discovery{backend: store.CONSUL}) discovery.Register("etcd", &Discovery{backend: store.ETCD}) }
func (provider *KvProvider) provide(configurationChan chan<- configMessage) error { switch provider.StoreType { case store.CONSUL: consul.Register() case store.ETCD: etcd.Register() case store.ZK: zookeeper.Register() case store.BOLTDB: boltdb.Register() default: return errors.New("Invalid kv store: " + string(provider.StoreType)) } kv, err := libkv.NewStore( provider.StoreType, []string{provider.Endpoint}, &store.Config{ ConnectionTimeout: 30 * time.Second, Bucket: "traefik", }, ) if err != nil { return err } if _, err := kv.List(""); err != nil { return err } provider.kvclient = kv if provider.Watch { stopCh := make(chan struct{}) chanKeys, err := kv.WatchTree(provider.Prefix, stopCh) if err != nil { return err } go func() { for { <-chanKeys configuration := provider.loadConfig() if configuration != nil { configurationChan <- configMessage{string(provider.StoreType), configuration} } defer close(stopCh) } }() } configuration := provider.loadConfig() configurationChan <- configMessage{string(provider.StoreType), configuration} return nil }
func New(hosts []string, config *store.Config) (store.Store, error) { consul.Register() s, err := libkv.NewStore( store.CONSUL, hosts, config, ) if err != nil { return nil, err } return &ConsulStorage{ GeneralStorage: general.New(s, string(store.CONSUL)), }, nil }
func (s *ConsulSuite) setupConsulTLS(c *check.C) { s.createComposeProject(c, "consul_tls") s.composeProject.Start(c) consul.Register() clientTLS := &provider.ClientTLS{ CA: "resources/tls/ca.cert", Cert: "resources/tls/consul.cert", Key: "resources/tls/consul.key", InsecureSkipVerify: true, } TLSConfig, err := clientTLS.CreateTLSConfig() c.Assert(err, checker.IsNil) kv, err := libkv.NewStore( store.CONSUL, []string{s.composeProject.Container(c, "consul").NetworkSettings.IPAddress + ":8585"}, &store.Config{ ConnectionTimeout: 10 * time.Second, TLS: TLSConfig, }, ) if err != nil { c.Fatal("Cannot create store consul") } s.kv = kv // wait for consul err = utils.Try(60*time.Second, func() error { _, err := kv.Exists("test") if err != nil { return err } return nil }) c.Assert(err, checker.IsNil) }
func (gc *GetConf) EnableKVStore(opts *KVOptions) (*GetConf, error) { switch strings.ToLower(opts.Backend) { case "consul": // Register consul store to libkv consul.Register() // Parse config c := &store.Config{ TLS: opts.KVConfig.TLS, ConnectionTimeout: opts.KVConfig.ConnectionTimeout, Bucket: opts.KVConfig.Bucket, PersistConnection: opts.KVConfig.PersistConnection, } if opts.KVConfig.ClientTLS != nil { c.ClientTLS = &store.ClientTLSConfig{ CertFile: opts.KVConfig.ClientTLS.CertFile, KeyFile: opts.KVConfig.ClientTLS.KeyFile, CACertFile: opts.KVConfig.ClientTLS.CACertFile, } } // Initialize a new store with consul kv, err := libkv.NewStore( store.CONSUL, opts.URLs, c, ) if err != nil { return gc, errors.New("cannot create store consul") } gc.KVStore = kv default: return gc, errors.New("unknown backend") } // Read options from KV Store loadFromKV(gc, opts) return gc, nil }
func init() { consul.Register() zookeeper.Register() etcd.Register() boltdb.Register() }
// Provide allows the provider to provide configurations to traefik // using the given configuration channel. func (provider *Consul) Provide(configurationChan chan<- types.ConfigMessage) error { provider.StoreType = store.CONSUL consul.Register() return provider.provide(configurationChan) }
func init() { // Register consul store to libkv consul.Register() }
// CreateStore creates the KV store func (provider *Consul) CreateStore() (store.Store, error) { provider.storeType = store.CONSUL consul.Register() return provider.createStore() }
func registerKVStores() { consul.Register() zookeeper.Register() etcd.Register() boltdb.Register() }
// Provide allows the provider to provide configurations to traefik // using the given configuration channel. func (provider *Consul) Provide(configurationChan chan<- types.ConfigMessage, pool *safe.Pool, constraints []types.Constraint) error { provider.storeType = store.CONSUL consul.Register() return provider.provide(configurationChan, pool, constraints) }
func init() { consul.Register() etcd.Register() }
func init() { etcd.Register() consul.Register() zookeeper.Register() }
func init() { // Register to libkv consul.Register() etcd.Register() }
func init() { etcd.Register() consul.Register() }