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