Golang zx.RWTree類代碼示例

func (ch Chg) applyMeta(lfs zx.RWTree) error {
	nd := ch.D.UsrAttrs()
	for _, k := range ignoredPutAttrs {
		delete(nd, k)
	}
	ec := lfs.Wstat(ch.D["path"], nd)
	return <-ec
}

func (ch Chg) applyData(lfs zx.RWTree, rfs zx.Tree) error {
	nd := ch.D.UsrAttrs()
	for _, k := range ignoredPutAttrs {
		delete(nd, k)
	}
	datc := rfs.Get(ch.D["path"], 0, zx.All, "")
	dc := lfs.Put(ch.D["path"], nd, 0, datc, "")
	<-dc
	return cerror(dc)
}

func (ch Chg) applyAdd(lfs zx.RWTree, rfs zx.Tree, pred string, ec chan<- error) error {
	var err error
	gc := rfs.FindGet(ch.D["path"], pred, "", "", 0)
	for g := range gc {
		dprintf("get %s\n", g)
		d := g.Dir
		if d == nil {
			break
		}
		for _, k := range ignoredPutAttrs {
			delete(d, k)
		}
		if d["err"] != "" {
			e := errors.New(d["err"])
			perr(ec, e)
			dprintf("%s: %s\n", d["path"], d["err"])
			if err == nil {
				err = e
			}
			continue
		}
		if g.Datac == nil && d["type"] != "d" {
			g.Datac = nchan.Null
		}
		if d["type"] == "d" {
			e := <-lfs.Mkdir(d["path"], d)
			if e != nil {
				perr(ec, e)
				if err == nil {
					err = e
				}
			}
			continue
		}
		dc := lfs.Put(d["path"], d, 0, g.Datac, "")
		<-dc
		if e := cerror(dc); e != nil {
			dprintf("%s: put: %s\n", d["path"], e)
			perr(ec, e)
			if err == nil {
				err = e
			}
		}
	}
	close(gc)
	if e := cerror(gc); e != nil {
		dprintf("get: %s\n", e)
		perr(ec, e)
		if err == nil {
			err = e
		}
	}
	return err
}

// Make some changes in the test zx tree.
//	- Touch /a/a1
//	- Chmod /a/a2
//	- Remove /a/b/c /a/b/c/c3
//	- Create /a/n /a/n/m /a/n/m/m1
func MkZXChgs(t Fataler, fs zx.RWTree) {
	TouchZX(fs, "/a/a1")
	if err := <- fs.Wstat("/a/a2", zx.Dir{"mode": "0750"}); err != nil {
		t.Fatalf("chmod: %s", err)
	}
	if err := <-fs.RemoveAll("/a/b/c"); err != nil {
		t.Fatalf("rm: %s", err)
	}
	<-fs.Mkdir("/a", zx.Dir{"mode": "0750"})
	<-fs.Mkdir("/a/n", zx.Dir{"mode": "0750"})
	if err := <-fs.Mkdir("/a/n/m", zx.Dir{"mode": "0750"}); err != nil {
		t.Fatalf("mkdir: %s", err)
	}
	err := zx.PutAll(fs, "/a/n/m/m1", zx.Dir{"mode": "0640"}, []byte("a new file\n"))
	if err != nil {
		t.Fatalf("new file: %s", err)
	}
	TouchZX(fs, "/a/n/m/m1")
	TouchZX(fs, "/a/n/m")
	TouchZX(fs, "/a/n")
	TouchZX(fs, "/a")
}

// Make some changes in the test zx tree, another version.
//	- Remove /2
//	- Create /2/n2
//	- Truncate /1
func MkZXChgs2(t Fataler, fs zx.RWTree) {
	if err := <-fs.Remove("/2"); err != nil {
		t.Fatalf("rm: %s", err)
	}
	<-fs.Mkdir("/2", zx.Dir{"mode": "0750"})
	if err := <-fs.Mkdir("/2/n2", zx.Dir{"mode": "0750"}); err != nil {
		t.Fatalf("mkdir: %s", err)
	}
	TouchZX(fs, "/2/n2")
	TouchZX(fs, "/2")
	if err := <-fs.Wstat("/1", zx.Dir{"size": "50"}); err != nil {
		t.Fatalf("truncate: %s", err)
	}
	TouchZX(fs, "/1")
}

// see if fn has errors (permissions) or not for the given path and 1,2,4 perm. bit.
// returns xxxxxxxxxxxx where x is y or n
// for ugo and masks 777 770 700 000
// Expected result is always yyyyynynnnnn
func ugo(t Fataler, fs zx.RWTree, p string, bit uint, fn func(zx.RWTree) error) string {
	err := <-fs.Wstat(p, zx.Dir{"mode": "0777"})
	if err != nil {
		t.Fatalf("wstat: %s", err)
	}
	defer func() {
		// so we can later remove it
		<-fs.Wstat(p, zx.Dir{"mode": "0755"})
	}()
	// /chkd is nemo gid1
	usrs := []usr{
		usr{who: "uid", ai: &auth.Info{Uid: dbg.Usr, SpeaksFor: dbg.Usr, Ok: true,
			Gids: map[string]bool{}}},
		usr{who: "gid", ai: &auth.Info{Uid: "gid1", SpeaksFor: dbg.Usr, Ok: true,
			Gids: map[string]bool{}}},
		usr{who: "oid", ai: &auth.Info{Uid: "other", SpeaksFor: dbg.Usr, Ok: true,
			Gids: map[string]bool{}}},
	}
	shift := uint(0)
	m := uint(0777)
	out := ""
	for i := 0; i < 4; i++ {
		printf("mode %o\n", m)
		err := <-fs.Wstat(p, zx.Dir{"mode": fmt.Sprintf("0%o", m)})
		if err != nil {
			t.Fatalf("wstat: %s", err)
		}
		for _, u := range usrs {
			if err := fn(authfor(t, fs, u.ai)); err != nil {
				out += "n"
				printf("%s can't for %o\n", u.who, m)
			} else {
				out += "y"
				printf("%s can for %o\n", u.who, m)
			}
		}
		m &^= (bit << shift)
		shift += 3
	}
	return out
}

// set a fake mtime that can be predicted.
func TouchZX(fs zx.RWTree, path string) error {
	d := zx.Dir{}
	d.SetTime("mtime", time.Unix(xt/1e9, xt%1e9))
	xt += 1e9
	return <-fs.Wstat(path, d)
}

func (ch Chg) applyDel(lfs zx.RWTree) error {
	return <-lfs.RemoveAll(ch.D["path"])
}

func rmove(t Fataler, fs zx.RWTree, fname string) {
	<-fs.Move(fname, fname+"o")
	<-fs.Move(fname+"o", fname)
}

func rwstat(t Fataler, fs zx.RWTree, fname string) {
	<-fs.Wstat(fname, zx.Dir{"mode": "0700", "Foo": "Bar"})
}

func rmkdir(t Fataler, fs zx.RWTree, fname string) {
	<-fs.Mkdir(fname, zx.Dir{"mode": "0755"})
}

func rremove(t Fataler, fs zx.RWTree, fname string) {
	<-fs.Remove(fname)
}

func mkfs(addr string, quiet bool) (zx.Tree, func(), error) {
	if len(addr) == 0 {
		dbg.Warn("missing address")
		opts.Usage()
		dbg.Fatal("usage")
	}
	dbp := &fs.Debug
	var m, fs zx.RWTree
	var fsst *zx.IOstats
	var err error
	var lflags, flags *zx.Flags
	if _, err = os.Stat(addr); err == nil {
		fs, flags, fsst, err = mklfs(addr)
	} else {
		fs, flags, fsst, err = mkrfs(addr)
	}
	if err != nil {
		return nil, nil, err
	}

	switch {
	case nocache:
		dbg.Warn("%s: uncached", addr)
		if xaddr != "" {
			rfs.Server(fs, xaddr)
		}
		fn := func() {}
		if sflag {
			fn = func() {
				fsst.Averages()
				dbg.Warn("%s iostats:\n%s\n", fs.Name(), fsst)
			}
		}
		return fs, fn, nil
	case lfscache != "":
		dbg.Warn("%s: lfs cache %s", addr, lfscache)
		m, lflags, err = dcache()
	case mlfscache != "":
		dbg.Warn("%s: mdfs cache %s", addr, mlfscache)
		m, lflags, err = mdcache()
	default:
		dbg.Warn("%s: mfs cache", addr)
		m, lflags, err = mcache()
	}
	if err != nil {
		return nil, nil, err
	}

	cfs.Debug = zxdebug
	xfs, err := cfs.New("cfs", m, fs, rflag)
	if err != nil {
		return nil, nil, fmt.Errorf("cfs: %s", err)
	}
	xfs.Flags.Add("rdebug", &flags.Dbg)
	if lflags != nil {
		xfs.Flags.Add("ldebug", &lflags.Dbg)
	}
	xfs.Flags.Add("fdebug", &zxfs.Debug)
	xfs.Flags.Add("vdebug", dbp)
	xfs.Flags.Set("verbsync", !quiet)
	st := &zx.IOstats{}
	xfs.IOstats = st
	if xaddr != "" {
		rfs.Server(xfs, xaddr)
	}
	fn := func() {}
	if sflag {
		fn = func() {
			st.Averages()
			dbg.Warn("%s iostats:\n%s\n", xfs.Name(), st)
			fsst.Averages()
			dbg.Warn("%s iostats:\n%s\n", fs.Name(), fsst)
		}
	}
	return xfs, fn, nil
}