// Pass sequential writes on to the correct handle for uploading
func (sc *serveConn) write(req *fuse.WriteRequest) {
if *readOnly {
req.RespondError(fuse.EPERM)
return
}
// TODO: if allow_other, require uid == invoking uid to allow writes
h, err := sc.handleById(req.Handle)
if err != nil {
fuse.Debug(fmt.Sprintf("inodeByNodeID(%v): %v", req.Handle, err))
req.RespondError(fuse.ESTALE)
return
}
if h.lastByte != req.Offset {
fuse.Debug(fmt.Sprintf("non-sequential write: got %v, expected %v", req.Offset, h.lastByte))
req.RespondError(fuse.EIO)
return
}
n, err := h.writer.Write(req.Data)
if err != nil {
req.RespondError(fuse.EIO)
return
}
sc.Lock()
h.lastByte += int64(n)
sc.handles[req.Handle] = h
sc.Unlock()
req.Respond(&fuse.WriteResponse{n})
}
func (f *fs) handleWrite(r *fuse.WriteRequest) {
log.Println("Inside handleWrite")
log.Printf("Writing %d bytes at offset %d", len(r.Data), r.Offset)
log.Println(r)
// TODO: Implement write
// Currently this is stupid simple and doesn't handle all the possibilities
resp := &fuse.WriteResponse{}
w, err := f.rpc.api.Write(f.getContext(), &pb.WriteRequest{Inode: uint64(r.Node), Offset: r.Offset, Payload: r.Data})
if err != nil {
log.Fatalf("Write to file failed: %v", err)
}
if w.Status != 0 {
log.Printf("Write status non zero(%d)\n", w.Status)
}
resp.Size = len(r.Data)
r.Respond(resp)
}
