Golang etcd.Register函数代码示例

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 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
//.........这里部分代码省略.........

// 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()
}