Golang Client.SetDir方法代码示例

func etcdClientSetUp(t *testing.T, rawClient *etcd.Client) map[string]interface{} {
	var err error
	if _, err = rawClient.SetDir("test", 0); err != nil {
		t.Fatal(err)
	}
	if _, err = rawClient.Set("test/index", "1", 0); err != nil {
		t.Fatal(err)
	}
	if _, err = rawClient.SetDir("test/values", 0); err != nil {
		t.Fatal(err)
	}
	if _, err = rawClient.Set("test/values/a", "aye", 0); err != nil {
		t.Fatal(err)
	}
	if _, err = rawClient.Set("test/values/b", "bee", 0); err != nil {
		t.Fatal(err)
	}

	want := make(map[string]interface{})
	wantValues := make(map[string]interface{})
	wantValues["a"] = "aye"
	wantValues["b"] = "bee"
	want["values"] = wantValues
	want["index"] = "1"
	return want
}

func EtcdMkDir(client *etcd.Client, path string, ttl uint64) error {
	_, err := client.SetDir(path, ttl)
	if err != nil {
		return err
	}
	return nil
}

func setDirCommandFunc(cmd *cobra.Command, args []string, client *etcd.Client) (*etcd.Response, error) {
	if len(args) == 0 {
		return nil, errors.New("Key required")
	}
	key := args[0]
	ttl := ttlFlag

	return client.SetDir(key, uint64(ttl))
}

func RegisterService(client *etcd.Client, service services.Service, ttl time.Duration) {
	keyPrefix := fmt.Sprintf("/services/%s/%s/", service.Service, service.Id)
	var attributes map[string]string = make(map[string]string)
	attributes["address"] = service.Address
	for key, value := range service.Labels {
		if key == "address" {
			fmt.Println("WARNING: overriding address(%s) with label: %s", service.Address, value)
		}
		attributes[key] = value
	}

	// create service/id dir with ttl
	client.SetDir(keyPrefix, uint64(ttl.Seconds()))
	for key, value := range attributes {
		_, err := client.Set(keyPrefix+key, value, 0)
		if err != nil {
			fmt.Println(err)
			// abort current registration
			return
		}
	}
}

func TestNodeFs(t *testing.T) {
	g := Goblin(t)

	g.Describe("File", func() {
		var etcd *etcdm.Client
		var fs testEtcdFsMount

		g.Before(func() {
			etcd = etcdm.NewClient([]string{testEtcdEndpoint})
		})

		g.BeforeEach(func() {
			etcd.RawDelete("/test", true, true)
			etcd.SetDir("/test", 0)
			fs = NewTestEtcdFsMount()
		})

		g.AfterEach(func() {
			fs.Unmount()
		})

		g.Describe("Open", func() {
			g.It("Should be supported", func() {
				if _, e := etcd.Set("/test/foo", "bar", 0); e != nil {
					g.Fail(e)
				}

				file, err := os.Open(fs.Path() + "/test/foo")

				if err != nil {
					g.Fail(err)
				}

				file.Close()
			})
		})
		g.Describe("Create", func() {
			g.It("Should be supported", func() {
				file, err := os.Create(fs.Path() + "/test/bar")

				if err != nil {
					g.Fail(err)
				}
				file.Close()

				if _, er := etcd.Get("/test/bar", false, false); er != nil {
					g.Fail(er)
				}
			})
		})
		g.Describe("Delete", func() {
			g.It("Should be supported", func() {
				etcd.Set("/test/barfoo", "lala", 0)

				err := os.Remove(fs.Path() + "/test/barfoo")

				if err != nil {
					g.Fail(err)
				}

				if _, er := etcd.Get("/test/barfoo", false, false); er == nil {
					g.Fail("The key [/test/barfoo] should not exist")
				}
			})
		})
		g.Describe("Read", func() {
			g.It("Should be supported", func() {
				etcd.Set("/test/bar", "foo", 0)

				data, err := ioutil.ReadFile(fs.Path() + "/test/bar")

				if err != nil {
					g.Fail(err)
				}

				g.Assert(string(data)).Equal("foo")
			})
		})
		g.Describe("Write", func() {
			g.It("Should be supported", func() {
				if err := ioutil.WriteFile(fs.Path()+"/test/foobar", []byte("hello world"), 0666); err != nil {
					g.Fail(err)
				}

				res, err := etcd.Get("/test/foobar", false, false)

				if err != nil {
					g.Fail(err)
				}

				g.Assert(res.Node.Value).Equal("hello world")
			})
		})
	})
}

//.........这里部分代码省略.........
	}

	configInfo := config.ConfigInfo{
		Repo:    repo,
		Branch:  branch,
		Version: commitHash,
		Commit: config.CommitInfo{
			TimeStamp:      timestamp,
			CommitterEmail: email,
			Subject:        subject,
		},
		ModFiles:   *modFiles,
		PathToRepo: pathToRepo,
	}

	jsonBytes, err := json.Marshal(configInfo)
	if err != nil {
		log.Fatalf("error when marshal configInfo, err: %s", err)
	}
	fmt.Printf("ConfigInfo json: %s\n", string(jsonBytes[:len(jsonBytes)]))

	// Get previous pusher information from root node for sanity check.
	if !etcdHasCommit {
		promptUser("There is no existing commit in remote tree. It could because " +
			"you're pushing to a clean tree. Do you want to continue?")
	} else {
		// Sanity check of pusher info.
		if configInfo.Repo != prevCFG.Repo {
			promptUser("Repo to be pushed <%s> != remote repo name <%s>. Continue?",
				configInfo.Repo, prevCFG.Repo)
		}
		if configInfo.Branch != prevCFG.Branch {
			promptUser("Branch to be pushed <%s> != remote branch <%s>. Continue?",
				configInfo.Branch, prevCFG.Branch)
		}
		if configInfo.PathToRepo != prevCFG.PathToRepo {
			promptUser("Path to repo <%s> != remote path <%s>. Continue?",
				configInfo.PathToRepo, prevCFG.PathToRepo)
		}
	}

	keys := make([]string, len(content))
	// sort content's keys
	i := 0
	for k := range content {
		keys[i] = k
		i++
	}
	sort.Strings(keys)

	// set etcd content.
	for _, k := range keys {
		fileP := filepath.Join(remoteRoot, k)
		fmt.Printf("creating or setting %s\n", fileP)
		if content[k].isDir {
			if _, err := etcdConn.Get(fileP, true, false); err != nil {
				// dir doesn't exist
				resp, err = etcdConn.SetDir(fileP, 0)
			}
		} else {
			resp, err = etcdConn.Set(fileP, string(content[k].content), 0)
		}
		if err != nil {
			log.Fatalf("error when setting znode >%s(%s + %s)<. Config server will be inconsistent: %s",
				fileP, remoteRoot, k, err)
		}
	}

	// go over deletes in commit
	for _, mod := range *modFiles {
		if strings.ToLower(mod.Op) != "d" {
			continue
		}
		// it's a delete
		// Find the relative path to etcd root.
		fileP := filepath.Join(remoteRoot, mod.Path)
		fmt.Printf("deleting %s (%s + %s)\n", fileP, remoteRoot, mod.Path)
		_, err = etcdConn.Delete(fileP, true)
		if err != nil {
			log.Errorf("error deleting file >%s<. Will continue. error: %s\n", fileP, err)
		}
		// since git uses a file as  a commit unit, there is nothing to do with folder.
		// what we are going to do is to delete each fileP which is modified with "d" and its corresponding folder.
		// If we still have children under that folder, deleting the folder will fail but we do not care.
		pDir := filepath.Join(remoteRoot, path.Dir(mod.Path))
		_, err = etcdConn.DeleteDir(pDir)
		// In normal case, we should get an error.
		// so just logging, if we have no error here.
		if err == nil {
			log.Errorf("error deleting dir >%s<.\n", pDir)
		}
	}

	// touch the root node with commit info
	_, err = etcdConn.Set(infoPath, string(jsonBytes), 0)
	if err != nil {
		log.Fatalf("error setting remoteRoot >%s<: %s\n", remoteRoot, err)
	}
	fmt.Printf("All done\n")
}