func chkdirs(t Fataler, fs zx.Tree, d zx.Dir, recur bool) { if d["path"] == "" { t.Fatalf("no path in <%s>", d) } if d["type"] != "d" { return } dents, err := zx.GetDir(fs, d["path"]) if err != nil { t.Fatalf("getdir: %s: %s", d["path"], err) } if d["size"] != fmt.Sprintf("%d", len(dents)) { t.Logf("%s: size %s len(dents) %d", d["path"], d["size"], len(dents)) t.Logf("d: %s\n", d.Long()) for _, cd := range dents { t.Logf("\t%s\n", cd.Long()) } t.Fatalf("bad dir size") } if recur { for _, cd := range dents { chkdirs(t, fs, cd, true) } } }
// d is a dup and can be changed. func (f *mFile) find(d zx.Dir, p *pred.Pred, spref, dpref string, lvl int, c chan<- zx.Dir, ai *auth.Info) { match, pruned, err := p.EvalAt(d, lvl) f.dprintf("find at %d %s\n\t%v\n\t%v %v %v\n\n", lvl, d.Long(), p, match, pruned, err) if pruned { if !match { d["err"] = "pruned" } c <- d return } if d["type"] == "d" && err == nil { f.mlk.Lock() if !f.t.NoPermCheck && !f.d.CanWalk(ai) { err = dbg.ErrPerm } f.mlk.Unlock() } if err != nil { d["err"] = err.Error() c <-d return } if d["rm"] != "" { return } if match { if ok := c <- d; !ok { return } } if d["type"] != "d" { return } f.clk.Lock() child := make([]*mFile, len(f.child)) copy(child, f.child) f.clk.Unlock() if f.name == "/" { nc := []*mFile{ &mFile{name: "Ctl", d: ctldir.Dup(), t: f.t}, } nc[0].d["tpath"] = f.t.path child = append(nc, child...) } for _, cf := range child { cf.mlk.Lock() cd := cf.d.Dup() cf.mlk.Unlock() // fmt.Printf("child %s\n", cd) if cd["rm"] != "" { continue } if spref != dpref { cpath := cd["path"] suff := zx.Suffix(cpath, spref) cd["path"] = zx.Path(dpref, suff) } cf.find(cd, p, spref, dpref, lvl+1, c, ai) } } func (t *Fs) Find(rid, fpred, spref, dpref string, depth int) <-chan zx.Dir { t.dprintf("find %s '%s' '%s' '%s' %d\n", rid, fpred, spref, dpref, depth) cs := t.IOstats.NewCall(zx.Sfind) dc := make(chan zx.Dir) go func() { rid, err := zx.AbsPath(rid) if err != nil { cs.End(err != nil) t.dprintf("find %s: %s\n", rid, err) close(dc, err) return } f, _, err := t.walk(rid, nil) if err != nil { cs.End(err != nil) t.dprintf("find %s: %s\n", rid, err) close(dc, err) return } p, err := pred.New(fpred) if err != nil { cs.End(err != nil) t.dprintf("find %s: %s\n", rid, err) close(dc, err) return } cs.Sending() f.mlk.Lock() d := f.d.Dup() f.mlk.Unlock() if spref != dpref { suff := zx.Suffix(rid, spref) d["path"] = zx.Path(dpref, suff) } f.find(d, p, spref, dpref, depth, dc, t.ai) cs.End(err != nil) t.dprintf("find %s: ok\n", rid) close(dc) }() return dc } func (t *Fs) FindGet(rid, fpred, spref, dpref string, depth int) <-chan zx.DirData { t.dprintf("findget %s '%s' '%s' '%s' %d\n", rid, fpred, spref, dpref, depth) gc := make(chan zx.DirData) cs := t.IOstats.NewCall(zx.Sfindget) go func() { dc := t.Find(rid, fpred, spref, dpref, depth) // BUG: will stat a Sfind for d := range dc { g := zx.DirData{Dir: d} var datac chan []byte if d["err"]=="" && d["type"]=="-" { datac = make(chan []byte) g.Datac = datac } if ok := gc <- g; !ok { close(dc, cerror(gc)) break } if datac != nil { err := t.get(d["spath"], 0, zx.All, datac, nil) close(datac, err) } } err := cerror(dc) cs.End(err != nil) if err != nil { t.dprintf("find %s: %s\n", rid, err) } else { t.dprintf("find %s: ok\n", rid) } close(gc, err) }() return gc } func (t *Fs) Dump(w io.Writer) { if t == nil { fmt.Fprintf(w, "<nil tree>\n") return } fmt.Fprintf(w, "tree [%s] path %s\n", t.name, t.path) t.root.Dump(w, 0) fmt.Fprintf(w, "\n") } func (f *mFile) Dump(w io.Writer, lvl int) { tabs := strings.Repeat(" ", lvl) if f == nil { fmt.Fprintf(w, "%s<nil file>\n", tabs) return } d := f.d.Dup() if d["path"] == "/" { d["size"] = "0" } fmt.Fprintf(w, "%s%s\n", tabs, d.TestFmt()) if d["type"] != "d" { fmt.Fprintf(w, "%s %d bytes\n", tabs, f.data.Len()) return } for _, c := range f.child { c.Dump(w, lvl+1) } }