166 lines
3 KiB
Go
166 lines
3 KiB
Go
package kubelwagen
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/hanwen/go-fuse/fuse"
|
|
"github.com/hanwen/go-fuse/fuse/nodefs"
|
|
)
|
|
|
|
type WsFsFile struct {
|
|
nodefs.File
|
|
h int
|
|
fs *WsFs
|
|
}
|
|
|
|
func newWsFsFile(handle int, fs *WsFs) *WsFsFile {
|
|
return &WsFsFile{
|
|
File: nodefs.NewDefaultFile(),
|
|
h: handle,
|
|
fs: fs,
|
|
}
|
|
}
|
|
func (f *WsFsFile) String() string {
|
|
return fmt.Sprintf("WsFsFile:%d", f.h)
|
|
}
|
|
|
|
func (f *WsFsFile) Read(buf []byte, off int64) (fuse.ReadResult, fuse.Status) {
|
|
r := Request{
|
|
Method: MethodFileRead,
|
|
FileHandle: f.h,
|
|
Offset: off,
|
|
Size: uint32(len(buf)),
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return nil, fuse.ENOSYS
|
|
}
|
|
return fuse.ReadResultData(resp.Data), resp.Code
|
|
}
|
|
|
|
func (f *WsFsFile) Write(data []byte, off int64) (uint32, fuse.Status) {
|
|
r := Request{
|
|
Method: MethodFileWrite,
|
|
FileHandle: f.h,
|
|
Offset: off,
|
|
Data: data,
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return 0, fuse.ENOSYS
|
|
}
|
|
return uint32(resp.WriteSize), resp.Code
|
|
}
|
|
|
|
func (f *WsFsFile) Flock(flags int) fuse.Status {
|
|
r := Request{
|
|
Method: MethodFileFlock,
|
|
FileHandle: f.h,
|
|
Flags: uint32(flags),
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return fuse.ENOSYS
|
|
}
|
|
return resp.Code
|
|
}
|
|
|
|
func (f *WsFsFile) Flush() fuse.Status {
|
|
return f.Fsync(0)
|
|
}
|
|
|
|
func (f *WsFsFile) Release() {
|
|
r := Request{
|
|
Method: MethodFileRelease,
|
|
FileHandle: f.h,
|
|
}
|
|
f.fs.getResponse(&r)
|
|
}
|
|
|
|
func (f *WsFsFile) GetAttr(attr *fuse.Attr) fuse.Status {
|
|
r := Request{
|
|
Method: MethodFileGetAttr,
|
|
FileHandle: f.h,
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return fuse.ENOSYS
|
|
}
|
|
if resp.Stat != nil {
|
|
*attr = *resp.Stat
|
|
}
|
|
return resp.Code
|
|
}
|
|
|
|
func (f *WsFsFile) Fsync(flags int) (code fuse.Status) {
|
|
r := Request{
|
|
Method: MethodFileFsync,
|
|
FileHandle: f.h,
|
|
Flags: uint32(flags),
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return fuse.ENOSYS
|
|
}
|
|
return resp.Code
|
|
}
|
|
|
|
func (f *WsFsFile) Utimens(atime *time.Time, mtime *time.Time) fuse.Status {
|
|
return fuse.ENOSYS
|
|
}
|
|
|
|
func (f *WsFsFile) Truncate(size uint64) fuse.Status {
|
|
r := Request{
|
|
Method: MethodFileTruncate,
|
|
FileHandle: f.h,
|
|
Size: uint32(size),
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return fuse.ENOSYS
|
|
}
|
|
return resp.Code
|
|
}
|
|
|
|
func (f *WsFsFile) Chown(uid uint32, gid uint32) fuse.Status {
|
|
r := Request{
|
|
Method: MethodFileChown,
|
|
FileHandle: f.h,
|
|
UID: uid,
|
|
GID: gid,
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return fuse.ENOSYS
|
|
}
|
|
return resp.Code
|
|
}
|
|
|
|
func (f *WsFsFile) Chmod(perms uint32) fuse.Status {
|
|
r := Request{
|
|
Method: MethodFileChmod,
|
|
FileHandle: f.h,
|
|
Flags: perms,
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return fuse.ENOSYS
|
|
}
|
|
return resp.Code
|
|
}
|
|
|
|
func (f *WsFsFile) Allocate(off uint64, size uint64, mode uint32) (code fuse.Status) {
|
|
r := Request{
|
|
Method: MethodFileAllocate,
|
|
FileHandle: f.h,
|
|
Mode: mode,
|
|
Size: uint32(size),
|
|
Offset: int64(off),
|
|
}
|
|
resp, ok := f.fs.getResponse(&r)
|
|
if !ok {
|
|
return fuse.ENOSYS
|
|
}
|
|
return resp.Code
|
|
}
|