func doServerBeat(kapi client.KeysAPI) {
var key = runningbase + *serverbeatname
myuuid := uuid.NewV4()
uuidstring := myuuid.String()
fmt.Println("Badum")
_, err := kapi.Set(context.TODO(), key, uuidstring, &client.SetOptions{PrevExist: client.PrevNoExist, TTL: time.Second * 60})
if err != nil {
log.Fatal(err)
}
running := true
counter := *serverbeatcount
for running {
time.Sleep(time.Second * time.Duration(*serverbeattime))
fmt.Println("Badum")
_, err := kapi.Set(context.TODO(), key, uuidstring, &client.SetOptions{PrevExist: client.PrevExist, TTL: time.Second * 60, PrevValue: uuidstring})
if err != nil {
log.Fatal(err)
}
if *serverbeatcount != 0 {
counter = counter - 1
if counter == 0 {
running = false
}
}
}
_, err = kapi.Delete(context.TODO(), key, &client.DeleteOptions{PrevValue: uuidstring})
if err != nil {
log.Fatal(err)
}
}
func cleanBackends(kapi client.KeysAPI) {
resp, err := kapi.Get(context.Background(), "/vulcand/backends/", &client.GetOptions{Recursive: true})
if err != nil {
if e, _ := err.(client.Error); e.Code == etcderr.EcodeKeyNotFound {
return
}
panic(err)
}
if !resp.Node.Dir {
log.Println("/vulcand/backends is not a directory.")
return
}
for _, be := range resp.Node.Nodes {
beHasContent := false
if be.Dir {
for _, child := range be.Nodes {
// anything apart from an empty "servers" dir means this is needed.
if filepath.Base(child.Key) != "servers" || len(child.Nodes) > 0 {
beHasContent = true
break
}
}
}
if !beHasContent {
_, err := kapi.Delete(context.Background(), be.Key, &client.DeleteOptions{Recursive: true})
if err != nil {
log.Printf("failed to remove unwanted backend %v\n", be.Key)
}
}
}
}
func Store(api etcd.KeysAPI, path string, ttl time.Duration) frameworkid.Storage {
// TODO(jdef) validate Config
return &storage{
LookupFunc: func(ctx context.Context) (string, error) {
if response, err := api.Get(ctx, path, nil); err != nil {
if !etcdutil.IsEtcdNotFound(err) {
return "", fmt.Errorf("unexpected failure attempting to load framework ID from etcd: %v", err)
}
} else {
return response.Node.Value, nil
}
return "", nil
},
RemoveFunc: func(ctx context.Context) (err error) {
if _, err = api.Delete(ctx, path, &etcd.DeleteOptions{Recursive: true}); err != nil {
if !etcdutil.IsEtcdNotFound(err) {
return fmt.Errorf("failed to delete framework ID from etcd: %v", err)
}
}
return
},
StoreFunc: func(ctx context.Context, id string) (err error) {
_, err = api.Set(ctx, path, id, &etcd.SetOptions{TTL: ttl})
return
},
}
}
func importFunc(dir string, file string, f iodatafmt.DataFmt, replace bool, yes bool, e Etcdtool, c *cli.Context, ki client.KeysAPI) {
// Check if dir exists and is a directory.
exists, err := dirExists(dir, c, ki)
if err != nil {
fatalf("Specified dir doesn't exist: %s", dir)
}
if exists {
exist, err := isDir(dir, c, ki)
if err != nil {
fatal(err.Error())
}
if exist {
fatalf("Specified dir is not a directory: %s", dir)
}
}
// Load file.
m, err := iodatafmt.Load(file, f)
if err != nil {
fatal(err.Error())
}
// Validate data.
if c.Bool("validate") {
validateFunc(e, dir, m)
}
if exists {
if replace {
if !askYesNo(fmt.Sprintf("Do you want to overwrite data in directory: %s", dir)) {
os.Exit(1)
}
// Delete dir.
if _, err = ki.Delete(context.TODO(), dir, &client.DeleteOptions{Recursive: true}); err != nil {
fatal(err.Error())
}
} else {
if !yes {
if !askYesNo(fmt.Sprintf("Do you want to overwrite data in directory: %s", dir)) {
os.Exit(1)
}
}
}
} else {
// Create dir.
if _, err := ki.Set(context.TODO(), dir, "", &client.SetOptions{Dir: true}); err != nil {
fatal(err.Error())
}
}
// Import data.
if err = etcdmap.Create(ki, dir, reflect.ValueOf(m)); err != nil {
fatal(err.Error())
}
}
func deleteRecursiveIfExists(kapi client.KeysAPI, path string) (err error) {
_, err = kapi.Delete(context.Background(), path, &client.DeleteOptions{Recursive: true})
if e, _ := err.(client.Error); e.Code == etcderr.EcodeKeyNotFound {
// ignore not found.
err = nil
}
return err
}
func noRetryList(kapi client.KeysAPI) []func() error {
return []func() error{
func() error {
opts := &client.SetOptions{PrevExist: client.PrevNoExist}
_, err := kapi.Set(context.Background(), "/setkey", "bar", opts)
return err
},
func() error {
_, err := kapi.Delete(context.Background(), "/delkey", nil)
return err
},
}
}
// rmdirCommandFunc executes the "rmdir" command.
func rmdirCommandFunc(c *cli.Context, ki client.KeysAPI) {
if len(c.Args()) == 0 {
handleError(ExitBadArgs, errors.New("key required"))
}
key := c.Args()[0]
resp, err := ki.Delete(context.TODO(), key, &client.DeleteOptions{Dir: true})
if err != nil {
handleError(ExitServerError, err)
}
if !resp.Node.Dir {
printResponseKey(resp, c.GlobalString("output"))
}
}
// rmdirCommandFunc executes the "rmdir" command.
func rmdirCommandFunc(c *cli.Context, ki client.KeysAPI) {
if len(c.Args()) == 0 {
handleError(c, ExitBadArgs, errors.New("key required"))
}
key := c.Args()[0]
ctx, cancel := contextWithTotalTimeout(c)
resp, err := ki.Delete(ctx, key, &client.DeleteOptions{Dir: true})
cancel()
if err != nil {
handleError(c, ExitServerError, err)
}
if !resp.Node.Dir || c.GlobalString("output") != "simple" {
printResponseKey(resp, c.GlobalString("output"))
}
}
// rmCommandFunc executes the "rm" command.
func rmCommandFunc(c *cli.Context, ki client.KeysAPI) {
if len(c.Args()) == 0 {
handleError(ExitBadArgs, errors.New("key required"))
}
key := c.Args()[0]
recursive := c.Bool("recursive")
dir := c.Bool("dir")
prevValue := c.String("with-value")
prevIndex := c.Int("with-index")
ctx, cancel := contextWithTotalTimeout(c)
resp, err := ki.Delete(ctx, key, &client.DeleteOptions{PrevIndex: uint64(prevIndex), PrevValue: prevValue, Dir: dir, Recursive: recursive})
cancel()
if err != nil {
handleError(ExitServerError, err)
}
if !resp.Node.Dir || c.GlobalString("output") != "simple" {
printResponseKey(resp, c.GlobalString("output"))
}
}
// rmCommandFunc executes the "rm" command.
func rmCommandFunc(c *cli.Context, ki client.KeysAPI) {
if len(c.Args()) == 0 {
handleError(ExitBadArgs, errors.New("key required"))
}
key := c.Args()[0]
recursive := c.Bool("recursive")
dir := c.Bool("dir")
prevValue := c.String("with-value")
prevIndex := c.Int("with-index")
// TODO: handle transport timeout
resp, err := ki.Delete(context.TODO(), key, &client.DeleteOptions{PrevIndex: uint64(prevIndex), PrevValue: prevValue, Dir: dir, Recursive: recursive})
if err != nil {
handleError(ExitServerError, err)
}
if !resp.Node.Dir {
printResponseKey(resp, c.GlobalString("output"))
}
}
func (s *SchedulerServer) fetchFrameworkID(client etcd.KeysAPI) (*mesos.FrameworkID, error) {
if s.failoverTimeout > 0 {
if response, err := client.Get(context.TODO(), meta.FrameworkIDKey, nil); err != nil {
if !etcdutil.IsEtcdNotFound(err) {
return nil, fmt.Errorf("unexpected failure attempting to load framework ID from etcd: %v", err)
}
log.V(1).Infof("did not find framework ID in etcd")
} else if response.Node.Value != "" {
log.Infof("configuring FrameworkInfo with Id found in etcd: '%s'", response.Node.Value)
return mutil.NewFrameworkID(response.Node.Value), nil
}
} else {
//TODO(jdef) this seems like a totally hackish way to clean up the framework ID
if _, err := client.Delete(context.TODO(), meta.FrameworkIDKey, &etcd.DeleteOptions{Recursive: true}); err != nil {
if !etcdutil.IsEtcdNotFound(err) {
return nil, fmt.Errorf("failed to delete framework ID from etcd: %v", err)
}
log.V(1).Infof("nothing to delete: did not find framework ID in etcd")
}
}
return nil, nil
}
func purge(kAPI client.KeysAPI, dir string, limit uint64, dry, oldv2 bool) {
resp, err := kAPI.Get(context.TODO(), dir, &client.GetOptions{})
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
os.Exit(1)
}
total := 0
all := 0
// now we traverse all {UUID}
for _, n := range resp.Node.Nodes {
all++
// do not overload discovery service
time.Sleep(10 * time.Millisecond)
var (
gresp *client.Response
err error
)
for i := 0; ; i++ {
gresp, err = kAPI.Get(context.TODO(), n.Key, &client.GetOptions{})
if err == nil {
break
}
if i >= 10 {
fmt.Fprintln(os.Stderr, "failed after 10 retries:", err.Error())
os.Exit(1)
}
}
if gresp.Node.CreatedIndex > limit {
fmt.Printf("skipped young uuid directory %s with index %d\n", n.Key, gresp.Node.CreatedIndex)
continue
}
// _config is a hidden dir, so we only purge "empty" directory.
if len(gresp.Node.Nodes) != 0 {
if !oldv2 {
fmt.Printf("skipped non-empty uuid directory %s\n", n.Key)
continue
}
for _, n := range gresp.Node.Nodes {
if n.TTL != 0 {
fmt.Println("skipped 0.4 uuid directory %s\n", n.Key)
continue
}
}
}
fmt.Printf("found empty/old uuid directory %s and start to purge...\n", n.Key)
for i := 0; ; i++ {
if dry {
break
}
_, err = kAPI.Delete(context.TODO(), n.Key, &client.DeleteOptions{Recursive: true})
if err == nil {
break
}
if eerr, ok := err.(client.Error); ok {
if eerr.Code == client.ErrorCodeKeyNotFound {
break
}
}
if i >= 10 {
fmt.Fprintln(os.Stderr, "failed after 10 retries:", err.Error())
os.Exit(1)
}
}
fmt.Printf("successfully purged uuid directory %s\n", n.Key)
total++
if total%10 == 0 {
fmt.Printf("already purged %d directories\n", total)
fmt.Printf("empty ratio = %f\n", float64(total)/float64(all))
}
}
}
func applyVulcanConf(kapi client.KeysAPI, vc vulcanConf) {
newConf := vulcanConfToEtcdKeys(vc)
existing, err := readAllKeysFromEtcd(kapi, "/vulcand/")
if err != nil {
panic(err)
}
for k, v := range existing {
// keep the keys not created by us
if !strings.HasPrefix(k, "/vulcand/backends/vcb-") && !strings.HasPrefix(k, "/vulcand/frontends/vcb-") {
newConf[k] = v
}
}
// remove unwanted frontends
for k, _ := range existing {
if strings.HasPrefix(k, "/vulcand/frontends/vcb-") {
_, found := newConf[k]
if !found {
log.Printf("deleting frontend %s\n", k)
_, err := kapi.Delete(context.Background(), k, &client.DeleteOptions{Recursive: false})
if err != nil {
log.Printf("error deleting frontend %v\n", k)
}
}
}
}
// remove unwanted backends
for k, _ := range existing {
if strings.HasPrefix(k, "/vulcand/backends/vcb-") {
_, found := newConf[k]
if !found {
log.Printf("deleting backend%s\n", k)
_, err := kapi.Delete(context.Background(), k, &client.DeleteOptions{Recursive: false})
if err != nil {
log.Printf("error deleting backend %v\n", k)
}
}
}
}
// add or modify backends
for k, v := range newConf {
if strings.HasPrefix(k, "/vulcand/backends") {
oldVal := existing[k]
if v != oldVal {
log.Printf("setting backend %s to %s\n", k, v)
if _, err := kapi.Set(context.Background(), k, v, nil); err != nil {
log.Printf("error setting %s to %s\n", k, v)
}
}
}
}
// add or modify frontends
for k, v := range newConf {
if strings.HasPrefix(k, "/vulcand/frontends") && !strings.HasSuffix(k, "/middlewares/rewrite") {
oldVal := existing[k]
if v != oldVal {
log.Printf("setting frontend %s to %s\n", k, v)
if _, err := kapi.Set(context.Background(), k, v, nil); err != nil {
log.Printf("error setting %s to %s\n", k, v)
}
}
}
}
// add or modify everything else
for k, v := range newConf {
oldVal := existing[k]
if v != oldVal {
log.Printf("setting %s to %s\n", k, v)
if _, err := kapi.Set(context.Background(), k, v, nil); err != nil {
log.Printf("error setting %s to %s\n", k, v)
}
}
}
}