func (t *Fs) remove(rid string, all bool, cs *zx.CallStat) chan error {
c := make(chan error, 1)
rid, err := zx.AbsPath(rid)
if rid=="/Ctl" || rid == "/" {
t.dprintf("remove %s: %s\n", rid, dbg.ErrPerm)
err := fmt.Errorf("%s: %s", rid, dbg.ErrPerm)
c <- err
close(c, err)
cs.End(true)
return c
}
f, _, err := t.walk(rid, nil)
if f != nil {
f.mlk.Lock()
}
if err == nil && !all && f.d["type"] == "d" && len(f.child) > 0 {
err = errors.New("directory is not empty")
}
if err == nil && !t.noPerms() && !f.d.CanWrite(t.ai) {
err = dbg.ErrPerm
}
if f != nil {
if err == nil {
f.d["rm"] = "y"
}
f.mlk.Unlock()
}
if err != nil {
t.dprintf("remove %s: %s\n", rid, err)
c <- err
close(c, err)
cs.End(true)
return c
}
t.detach(f)
t.dprintf("remove %s: ok\n", rid)
close(c)
cs.End(false)
return c
}
func (t *Rfs) getrpc(rid string, msg *Msg) <-chan []byte {
t.c.Debug = t.Dbg && VerbDebug
c := make(chan []byte, 10)
go func() {
reqc, repc := t.c.Rpc()
raw := msg.Pack()
cs := t.IOstats.NewCallSize(zx.Sget, len(raw))
reqc <- raw
close(reqc)
some := false
for rep := range repc {
cs.Send(int64(len(rep)))
if ok := c <- rep; !ok {
close(repc, cerror(c))
break
}
some = true
t.dprintf("get %s: ok\n", rid)
}
if !some {
c <- nil
}
err := cerror(repc)
cs.End(err != nil)
if err != nil {
if isHangup(err) {
t.Close(ErrHangUp)
}
t.dprintf("get %s: %s\n", rid, err)
} else {
t.dprintf("get %s: ok\n", rid)
}
close(c, err)
}()
return c
}
func (t *Rfs) Get(rid string, off, count int64, pred string) <-chan []byte {
t.dprintf("get %s %d %d %q\n", rid, off, count, pred)
msg := &Msg{Op: Tget, Rid: rid, Off: off, Count: count, Pred: pred}
return t.getrpc(rid, msg)
}
func (t *Rfs) putrpc(rid string, msg *Msg, dc <-chan []byte) chan zx.Dir {
t.c.Debug = t.Dbg && VerbDebug
c := make(chan zx.Dir, 1)
go func() {
reqc, repc := t.c.Rpc()
raw := msg.Pack()
cs := t.IOstats.NewCallSize(zx.Sput, len(raw))
reqc <- raw
nm := 0
tot := 0
for m := range dc {
nm++
cs.Recv(int64(len(m)))
if ok := reqc <- m; !ok {
err := cerror(reqc)
close(dc, err)
close(c, err)
cs.End(err != nil)
return
}
if len(m) == 0 {
break
}
tot += len(m)
}
close(reqc, cerror(dc))
rep := <-repc
var err error
var d zx.Dir
if len(rep) == 0 {
err = cerror(repc)
} else {
d, _, err = zx.UnpackDir(rep)
if err==nil && d==nil {
err = errors.New("null dir in put reply")
}
}
cs.End(err != nil)
if err == nil {
t.dprintf("put %s: %s\n", rid, d)
c <- d
} else {
if isHangup(err) {
t.Close(ErrHangUp)
}
t.dprintf("put %s: %s\n", rid, err)
}
close(c, err)
}()
return c
}
func (t *Rfs) Put(rid string, d zx.Dir, off int64, dc <-chan []byte, pred string) chan zx.Dir {
t.dprintf("put %s %v %d '%s'\n", rid, d, off, pred)
msg := &Msg{Op: Tput, Rid: rid, D: d, Off: off, Pred: pred}
return t.putrpc(rid, msg, dc)
}
func (t *Rfs) errrpc(rid, op string, msg *Msg, k int) chan error {
t.c.Debug = t.Dbg && VerbDebug
c := make(chan error, 1)
go func() {
reqc, repc := t.c.Rpc()
raw := msg.Pack()
var cs *zx.CallStat
if k >= 0 {
cs = t.IOstats.NewCallSize(k, len(raw))
}
reqc <- raw
close(reqc)
<-repc
err := cerror(repc)
cs.End(err != nil)
if err != nil {
if isHangup(err) {
t.Close(ErrHangUp)
}
t.dprintf("%s %s: %s\n", op, rid, err)
} else {
t.dprintf("%s %s: ok\n", op, rid)
}
c <- err
close(c, err)
cs.End(err != nil)
}()
return c
}
func (t *Rfs) Fsys(name string) <-chan error {
t.dprintf("fsys %s\n", name)
msg := &Msg{Op: Tfsys, Rid: name}
return t.errrpc(name, "fsys", msg, -1)
}
func (t *Rfs) Mkdir(rid string, d zx.Dir) chan error {
msg := &Msg{Op: Tmkdir, Rid: rid, D: d}
t.dprintf("mkdir %s %v\n", rid, d)
return t.errrpc(rid, "mkdir", msg, zx.Smkdir)
}
func (t *Rfs) Move(from, to string) chan error {
t.dprintf("move %s %s \n", from, to)
msg := &Msg{Op: Tmove, Rid: from, To: to}
return t.errrpc(from, "move", msg, zx.Smove)
}
func (t *Rfs) Remove(rid string) chan error {
t.dprintf("remove %s\n", rid)
msg := &Msg{Op: Tremove, Rid: rid}
return t.errrpc(rid, "remove", msg, zx.Sremove)
}
func (t *Rfs) RemoveAll(rid string) chan error {
t.dprintf("removeall %s\n", rid)
msg := &Msg{Op: Tremoveall, Rid: rid}
return t.errrpc(rid, "removeall", msg, zx.Sremoveall)
}
func (t *Rfs) Wstat(rid string, d zx.Dir) chan error {
t.dprintf("wstat %s %v\n", rid, d)
msg := &Msg{Op: Twstat, Rid: rid, D: d}
return t.errrpc(rid, "wstat", msg, zx.Swstat)
}
func (t *Rfs) Find(rid, pred, spref, dpref string, depth int) <-chan zx.Dir {
t.dprintf("find %s '%s' '%s' '%s' %d\n", rid, pred, spref, dpref, depth)
dc := make(chan zx.Dir)
msg := &Msg{Op: Tfind, Rid: rid, Pred: pred, Spref: spref, Dpref: dpref, Depth: depth}
go func() {
reqc, repc := t.c.Rpc()
raw := msg.Pack()
cs := t.IOstats.NewCallSize(zx.Sfind, len(raw))
reqc <- raw
close(reqc)
some := false
for rep := range repc {
cs.Send(int64(len(rep)))
d, _, _ := zx.UnpackDir(rep)
if d != nil {
d["addr"] = t.addr
d["proto"] = "zx"
}
if ok := dc <- d; !ok {
close(repc, cerror(dc))
break
}
some = true
t.dprintf(rid, "find", "<- %v\n", d)
}
if !some {
dc <- nil
}
err := cerror(repc)
cs.End(err != nil)
if err != nil {
if isHangup(err) {
t.Close(ErrHangUp)
}
t.dprintf("find %s: %s\n", rid, err)
} else {
t.dprintf("find %s: ok\n", rid)
}
close(dc, err)
cs.End(err != nil)
}()
return dc
}
func (t *Rfs) FindGet(rid, pred, spref, dpref string, depth int) <-chan zx.DirData {
t.dprintf("findget %s '%s' '%s' '%s' %d\n", rid, pred, spref, dpref, depth)
dc := make(chan zx.DirData)
msg := &Msg{Op: Tfindget, Rid: rid, Pred: pred, Spref: spref, Dpref: dpref, Depth: depth}
go func() {
reqc, repc := t.c.Rpc()
raw := msg.Pack()
cs := t.IOstats.NewCallSize(zx.Sfind, len(raw))
reqc <- raw
close(reqc)
for rep := range repc {
cs.Send(int64(len(rep)))
d, _, _ := zx.UnpackDir(rep)
if d != nil {
d["addr"] = t.addr
d["proto"] = "zx"
}
res := zx.DirData{Dir: d}
var datc chan []byte
if d["err"]=="" && d["type"]=="-" {
datc = make(chan []byte)
res.Datac = datc
}
if ok := dc <- res; !ok {
close(repc, cerror(dc))
break
}
t.dprintf(rid, "find", "<- %v\n", d)
if datc != nil {
for rep := range repc {
if len(rep) == 0 {
break
}
if ok := datc <- rep; !ok {
continue
}
}
close(datc, cerror(repc))
}
}
err := cerror(repc)
cs.End(err != nil)
if err != nil {
if isHangup(err) {
t.Close(ErrHangUp)
}
t.dprintf("find %s: %s\n", rid, err)
} else {
t.dprintf("find %s: ok\n", rid)
}
close(dc, err)
}()
return dc
}