Golang zx.Tree類代碼示例

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
}

func StatsBench(b *testing.B, fs zx.Tree) {
	for bi := 0; bi < b.N; bi++ {
		i := bi%len(StatTests)
		st := StatTests[i]
		if st.Fails {
			continue
		}
		dc := fs.Stat(st.Path)
		d := <-dc
		if d == nil {
			b.Fatalf("stat %s: %s", st.Path, cerror(dc))
		}
	}
}

// Facade that serves t at the given address by using the ds
// to serve and calling Serve for each client.
func Server(t zx.Tree, addr string) {
	dbg.Warn("serve %s at %s...", t.Name(), addr)
	cc, ec, err := ds.Serve(os.Args[0], addr)
	if err != nil {
		dbg.Warn("serve: %s", err)
		return
	}
	go func() {
		for c := range cc {
			if c != nil {
				go serveFor(t, *c)
			}
		}
		if err := cerror(cc); err != nil {
			dbg.Warn("serve: %s", err)
		}
		close(ec, "done")
	}()
}

// returns true if the caller must poll itself rfs for changes
func newInvalQ(tag string, dbgf *bool, rfs zx.Tree) (*invalQ, bool) {
	iq := &invalQ{
		Tag: tag,
		Dbg: dbgf,
		cchgc: make(chan bool, 1),
		rfs: rfs,
		invalsc: make(chan bool, 1),
	}
	go iq.postinvalproc()
	if rfs == nil {
		return iq, false
	}
	// Use /Chg from rfs or poll rfs it if there's no other way.
	dc := rfs.Get("/Chg", 0, zx.All, "")
	msg := <-dc
	if len(msg) == 0 {
		dbg.Warn("no invalidations: %s", cerror(dc))
		return iq, true
	}
	go iq.getinvalproc(dc)
	return iq, false
}

func mkfs(addr string) (zx.Tree, func(), error) {
	if len(addr) == 0 {
		opts.Usage(os.Stderr)
		dbg.Fatal("usage")
	}
	var fs zx.Tree
	var st *zx.IOstats
	var err error
	if _, err := os.Stat(addr); err == nil {
		fs, st, err = mklfs(addr)
	} else {
		fs, st, err = mkrfs(addr)
	}
	if err != nil {
		return nil, nil, err
	}
	fn := func() {}
	if sflag {
		fn = func() {
			st.Averages()
			dbg.Warn("%s iostats:\n%s\n", fs.Name(), st)
		}
	}
	if mfscfs {
		dbg.Warn("%s: mfs cache", addr)
		return mfscache(fs, fn)
	}
	if lfsdir != "" {
		dbg.Warn("%s: lfs cache", addr)
		return lfscache(fs, fn)
	}
	if !nocaching && !delayed {
		dbg.Warn("%s: old cache", addr)
		return cache(fs, fn)
	}
	dbg.Warn("%s: uncached", addr)
	return fs, fn, nil
}

func chkok(fs zx.Tree, attr string) error {
	d, err := zx.Stat(fs, "/")
	if err != nil  {
		return fmt.Errorf("%s: %s", fs.Name(), err)
	}
	rwfs, ok := fs.(zx.RWTree)
	if !ok {
		return nil
	}
	if err := <-rwfs.Wstat("/", zx.Dir{attr: "666"}); err != nil {
		return err
	}
	d, err = zx.Stat(fs, "/")
	if err != nil  {
		return fmt.Errorf("%s: %s", fs.Name(), err)
	}
	if d[attr] != "666" {
		return fmt.Errorf("%s: does not preserve %s", fs.Name(), attr)
	}
	if err := <-rwfs.Wstat("/", zx.Dir{attr: ""}); err != nil {
		return err
	}
	return nil
}

// Create a new cfs given a local tree used as a cache of a remote one.
// Operations are performed on behalf of each file owner.
// The lfs tree must have permission checking disabled
// (cfs will want to update everything in it no matter the user who makes the requests)
func New(tag string, lfs zx.RWTree, rfs zx.Tree, rdonly bool) (*Cfs, error) {
	if lfs == nil || rfs == nil {
		return nil, errors.New("no lfs or rfs")
	}
	rwrfs, ok := rfs.(zx.RWTree)
	if !ok && !rdonly {
		rdonly = true
		rwrfs = zx.ROTreeFor(rfs)
		dbg.Warn("remote %T not rw: rdonly set", rfs)
	}
	if !rdonly {
		if err := chkok(lfs, "Rtime"); err != nil {
			return nil, err
		}
	}
	if tag == "" {
		tag = "cfs!" + rfs.Name()
	}
	fs := &Cfs {
		Tag: tag,
		lfs: lfs,
		cfs: lfs,		// but will keep its ai as nil to wstat uids
		rfs: rwrfs,
		rdonly: rdonly,
		noinvalproto: NoInvalProto,
		Flags: &zx.Flags{Dbg: Debug},
		cUsers: &cUsers {
			who: make(map[string]time.Time),
		},
		cache: cache.New(),
		closedc: make(chan bool),
		polldonec: make(chan bool),
	}
	if DebugLocks {
		fs.lktrz = &lockTrzs{}
	}
	fs.cache.Tag = tag
	fs.cache.Dbg = &fs.Flags.Dbg
	fs.tpath = fmt.Sprintf("cfs%p", fs)
	if fs.noinvalproto {
		fs.invalQ, _ = newInvalQ(tag, &fs.Flags.Dbg, nil)
		close(fs.polldonec)
	} else {
		var mustpoll bool
		fs.invalQ, mustpoll = newInvalQ(tag, &fs.Flags.Dbg, fs.rfs)
		if mustpoll {
			dbg.Warn("%s: polling %s for external changes", tag, fs.rfs)
			// runs with no ai
			go fs.pollproc()
		} else {
			close(fs.polldonec)
		}
	}
	go fs.invalproc()
	fs.Flags.Add("verbsync", &fs.cache.Verb)
	fs.Flags.Add("debug", &fs.Flags.Dbg)
	if d, ok := lfs.(zx.Debugger); ok {
		fs.Flags.Add("ldebug", d.Debug())
	}
	if d, ok := rfs.(zx.Debugger); ok {
		fs.Flags.Add("rdebug", d.Debug())
	}
	fs.Flags.AddRO("rdonly", &fs.rdonly)
	fs.Flags.AddRO("noperm", &fs.NoPermCheck)
	fs.Flags.Add("clear", func(...string)error{
		fs.IOstats.Clear()
		return nil
	})
	return fs, nil
}

func dump(dir string, t zx.Tree, ec chan bool) {
	defer func() {
		ec <- true
	}()
	name := t.Name()
	data := zx.Path(dir, "data")
	doskip := Skip
	for {
		if doskip {
			waitDumpTime(name)
			doskip = false
			continue
		}
		dbg.Warn("snap %s...", name)
		if err := os.MkdirAll(data, 0750); err != nil {
			dbg.Warn("%s: %s", data, err)
			return
		}
		rd, err := zx.Stat(t, "/")
		if err != nil {
			dbg.Warn("%s: %s", name, err)
			continue
		}
		// make sure it's not empty
		ds, err := zx.GetDir(t, "/")
		if err != nil {
			dbg.Warn("%s: %s", name, err)
			continue
		}
		if len(ds) == 0 {
			dbg.Warn("%s: file system is empty. ignored.", name)
			continue
		}
		s, err := dumpDir(data, name, zx.File{t, rd})
		if err != nil {
			dbg.Warn("%s: %s", name, err)
		}
		ts := time.Now().Format("2006/0102")
		tree := strings.Replace(name, "/", ".", -1)
		tspath0 := zx.Path(dir, tree, ts)
		os.MkdirAll(path.Dir(tspath0), 0755)
		spath := zx.Path(data, s)
		tspath := tspath0
		for i := 1; ; i++ {
			fi, _ := os.Stat(tspath)
			if fi == nil {
				break
			}
			tspath = fmt.Sprintf("%s.%d", tspath0, i)
		}
		os.MkdirAll(path.Dir(tspath), 0755)
		if err := os.Symlink(spath, tspath); err != nil {
			dbg.Warn("%s: %s", name, err)
		}
		dbg.Warn("snap %s %s", tspath, s)
		if Once {
			break
		}
		waitDumpTime(name)
	}
}