func (s *EtcdSuite) SetUpTest(c *check.C) { s.createComposeProject(c, "etcd") s.composeProject.Start(c) etcd.Register() url := s.composeProject.Container(c, "etcd").NetworkSettings.IPAddress + ":2379" kv, err := libkv.NewStore( store.ETCD, []string{url}, &store.Config{ ConnectionTimeout: 10 * time.Second, }, ) if err != nil { c.Fatal("Cannot create store etcd") } s.kv = kv // wait for etcd err = utils.Try(60*time.Second, func() error { _, err := kv.Exists("test") if err != nil { return fmt.Errorf("Etcd connection error to %s: %v", url, err) } return nil }) c.Assert(err, checker.IsNil) }
func NewStore(machines []string, cmd *ServerCommand, keyspace string) *Storage { etcd.Register() clt, err := libkv.NewStore(store.ETCD, cmd.Config.BackendMachines, &store.Config{}) if err != nil { panic(err) } _, err = clt.List(keyspace) if err != store.ErrKeyNotFound && err != nil { log.WithError(err).Fatal("store: Store backend not reachable") } cfg := client.Config{ Endpoints: machines, Transport: client.DefaultTransport, // set timeout per request to fail fast when the target endpoint is unavailable HeaderTimeoutPerRequest: time.Second, } c, err := client.New(cfg) if err != nil { log.Fatal(err) } kapi := client.NewKeysAPI(c) return &Storage{Client: clt, Kapi: kapi, command: cmd, keyspace: keyspace} }
// 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) { etcd.Register() s, err := libkv.NewStore( store.ETCD, hosts, config, ) if err != nil { return nil, err } return &EtcdStorage{ GeneralStorage: general.New(s, string(store.ETCD)), }, nil }
func init() { etcd.Register() consul.Register() zookeeper.Register() }
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 *Etcd) Provide(configurationChan chan<- types.ConfigMessage, pool *safe.Pool) error { provider.storeType = store.ETCD etcd.Register() return provider.provide(configurationChan, pool) }
func init() { // Register to libkv consul.Register() etcd.Register() }
func registerKVStores() { consul.Register() zookeeper.Register() etcd.Register() boltdb.Register() }
func initLibKV() { etcd.Register() }
func init() { etcd.Register() }
func init() { consul.Register() etcd.Register() }
func main() { fmt.Println("start controller main()") etcd_url_ptr := flag.String("etcd", "192.168.3.2:4001", "etcd url") flag.Parse() fmt.Println("etcd: ", *etcd_url_ptr) h := PC_TopoHandler{} topo.AddHandler(h) topo.Init(*etcd_url_ptr) IpContainerMapMutex = &sync.Mutex{} IpContainerMap = make(map[string]*topo.ContainerInfo) PodContainerListMutex = &sync.Mutex{} PodContainerList = make(map[string]bwctl.QoS) n := PC_NodeHandler{} rest.AddHandler(n) //for testing pgreq0 := PGNetworkReq{"nginx", 0.4, 0.4, "Low", "Low", "Low", "Low", 0.4, 0.4, "Low", "Low", "Low", "Low"} PGNetworkReqPool["nginx"] = pgreq0 netres0 := NodeNetworkRes{"node_0", 0.2, 1.0, "High", "Low", 1.0, 1.0, "High", "Low"} netres1 := NodeNetworkRes{"node_1", 0.3, 1.0, "Low", "Low", 0.5, 1.0, "Low", "Low"} netres2 := NodeNetworkRes{"node_2", 0.4, 1.0, "Low", "Low", 0.4, 1.0, "Low", "Low"} netres3 := NodeNetworkRes{"node_3", 0.6, 1.0, "Low", "Low", 0.6, 1.0, "Low", "Low"} netres4 := NodeNetworkRes{"node_4", 1.0, 1.0, "Low", "Low", 1.0, 1.0, "Low", "Low"} nodeNetworkResPool["node_0"] = netres0 nodeNetworkResPool["node_1"] = netres1 nodeNetworkResPool["node_2"] = netres2 nodeNetworkResPool["node_3"] = netres3 nodeNetworkResPool["node_4"] = netres4 go rest.StartControllerRestServer(*etcd_url_ptr) //scheduler plugin go StartPluginRestServer() // client := etcd.NewClient([]string{"192.168.3.2:4001"}) //http://127.0.0.1:4001 deploy.sh: K8S_NODE_IP // parse_appChain() // select{} /* for { //waiting for update forever ... watchChan := make(chan *etcd.Response) go client.Watch("/0/public/appChain", 0, false, watchChan, nil) log.Println("Waiting for an update...") r := <-watchChan log.Printf("Got updated appChain: %s: %s\n", r.Node.Key, r.Node.Value) parse_appChain() }*/ // We can register as many backends that are supported by libkv etcd.Register() client := "192.168.3.2:4001" // Initialize a new store with consul kv, err := libkv.NewStore( store.ETCD, []string{client}, &store.Config{ ConnectionTimeout: 10*time.Second, }, ) if err != nil { log.Fatal("Cannot create store") } //for qos testing qos_key := "/0/52:54:00:c8:00:ab" qosCtl := []bwctl.QoS{ {"192.0.0.1","1", "100", "1","all", "add", "1000", "1000", "1000", "1000", "0"}, {"192.0.0.1","1", "100", "1","default","add", "10", "100", "10", "100", "5"}, {"192.0.0.1","1", "100", "1","172.17.0.2","add", "500", "500", "700", "700", "0"}, {"192.0.0.2","2", "102", "2","172.17.0.3", "add","200", "200", "200", "200", "5"}, {"192.0.0.2","2", "102", "2","172.17.0.4", "add", "200", "200", "200", "200", "7"}, } qos_encode, err := json.Marshal(qosCtl) if err != nil { log.Fatal(err) } //resp, err := kapi.Set(context.Background(), "/" + n.Name, string(qos_encode), nil) err = kv.Put(qos_key, []byte(qos_encode), nil) if err != nil { log.Fatal("Error trying to put value at key `", qos_key, "`") } pair, err := kv.Get(qos_key) if err != nil { log.Fatal("Error trying accessing value at key `", qos_key, "`") } fmt.Println("value: ", string(pair.Value)) //for qos testing end key := "/0/public/appChain" stopCh := make(<-chan struct{}) events, err := kv.Watch(key, stopCh) for { select { case pair := <-events: parse_appChain() fmt.Printf("value changed on key %s: new value=%s ... \n", key, pair.Value) } } }
// CreateStore creates the KV store func (provider *Etcd) CreateStore() (store.Store, error) { provider.storeType = store.ETCD etcd.Register() return provider.createStore() }
func init() { etcd.Register() consul.Register() }