fuse.go

@@ -1,18 +1,537 @@
 package main
+
 import (
-	"go.arsenm.dev/itd/internal/fusefs"
+	"go.arsenm.dev/infinitime"
+	"go.arsenm.dev/infinitime/blefs"
+	"go.arsenm.dev/logger/log"
 	"os"
+	"context"
+	"syscall"
 	"github.com/hanwen/go-fuse/v2/fs"
 	"github.com/hanwen/go-fuse/v2/fuse"
-	"go.arsenm.dev/logger/log"
+	"strconv"
-	"context"
+	"io"
-	"go.arsenm.dev/infinitime"
+	"bytes"
 )
 
+type Device struct {
+	dev *infinitime.Device
+}
+
+func (i Device) HeartRateBytes() ([]byte, error) {
+	v, err := i.dev.HeartRate()
+	return []byte(strconv.Itoa(int(v)) + "\n"), err
+}
+func (i Device) BatteryLevelBytes() ([]byte, error) {
+	v, err := i.dev.BatteryLevel()
+	return []byte(strconv.Itoa(int(v)) + "\n"), err
+}
+func (i Device) StepCountBytes() ([]byte, error) {
+	v, err := i.dev.StepCount()
+	return []byte(strconv.Itoa(int(v)) + "\n"), err
+}
+func (i Device) MotionBytes() ([]byte, error) {
+	v, err := i.dev.Motion()
+	return []byte(strconv.Itoa(int(v.X)) + " " + strconv.Itoa(int(v.Y)) + " " + strconv.Itoa(int(v.Z)) + "\n"), err
+}
+func (i Device) AddressBytes() ([]byte, error) {
+	v := i.dev.Address()
+	return []byte(v + "\n"), nil
+}
+func (i Device) VersionBytes() ([]byte, error) {
+	v, err := i.dev.Version()
+	return []byte(v + "\n"), err
+}
+
+
+type ITProperty struct {
+	name string
+	Ino uint64
+	gen func(context.Context) (<-chan uint8, error)
+}
+
+
+type DirEntry struct {
+	isDir    bool
+	modtime  uint64
+	size     uint32
+	path     string
+}
+
+type ITNode struct {
+	fs.Inode
+	kind int
+	Ino uint64
+
+	lst []DirEntry
+	self DirEntry
+	path string
+}
+
+var properties = []ITProperty {
+	ITProperty{"heartrate", 2, nil},
+	ITProperty{"battery", 3, nil},
+	ITProperty{"motion", 4, nil},
+	ITProperty{"stepcount", 5, nil},
+	ITProperty{"version", 6, nil},
+	ITProperty{"address", 7, nil},
+}
+var myfs *blefs.FS = nil;
+var inodemap map[string]uint64 = nil;
+
+var _ = (fs.NodeReaddirer)((*ITNode)(nil))
+
+// Readdir is part of the NodeReaddirer interface
+func (n *ITNode) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
+	switch n.kind {
+	case 0:
+		// root folder
+		r := make([]fuse.DirEntry, 2)
+		r[0] = fuse.DirEntry{
+			Name: "device",
+			Ino:  0,
+			Mode: fuse.S_IFDIR,
+		}
+		r[1] = fuse.DirEntry{
+			Name: "fs",
+			Ino:  1,
+			Mode: fuse.S_IFDIR,
+		}
+		return fs.NewListDirStream(r), 0
+
+	case 1:
+		// device folder
+		r := make([]fuse.DirEntry, 6)
+		for ind, value := range properties {
+			r[ind] = fuse.DirEntry{
+				Name: value.name,
+				Ino:  value.Ino,
+				Mode: fuse.S_IFREG,
+			}
+		}
+
+		return fs.NewListDirStream(r), 0
+
+	case 2:
+		// on device
+		files, _ := myfs.ReadDir(n.path)
+		log.Info("readdir").Str("path", n.path).Int("objects", len(files)).Send()
+		r := make([]fuse.DirEntry, len(files))
+		n.lst = make([]DirEntry, len(files))
+		for ind, entry := range files {
+			info, _ := entry.Info()
+			name := info.Name()
+
+			file := DirEntry{
+				path: n.path + "/" + name,
+				size: uint32(info.Size()),
+				modtime: uint64(info.ModTime().Unix()),
+				isDir: info.IsDir(),
+			}
+			n.lst[ind] = file
+
+			ino := inodemap[file.path]
+			if ino == 0 {
+				ino = uint64(len(inodemap)) + 1
+				inodemap[file.path] = ino
+			}
+
+			if file.isDir {
+				r[ind] = fuse.DirEntry{
+					Name: name,
+					Mode: fuse.S_IFDIR,
+					Ino : ino + 10,
+				}
+			} else {
+				r[ind] = fuse.DirEntry{
+					Name: name,
+					Mode: fuse.S_IFREG,
+					Ino : ino + 10,
+				}
+			}
+		}
+		return fs.NewListDirStream(r), 0
+	}
+	r := make([]fuse.DirEntry, 0)
+	return fs.NewListDirStream(r), 0
+}
+
+var _ = (fs.NodeLookuper)((*ITNode)(nil))
+func (n *ITNode) Lookup(ctx context.Context, name string, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
+	switch n.kind {
+	case 0:
+		// root folder
+		if name == "device" {
+			stable := fs.StableAttr{
+				Mode: fuse.S_IFDIR,
+				Ino: uint64(0),
+			}
+			operations := &ITNode{kind: 1, Ino: 0}
+			child := n.NewInode(ctx, operations, stable)
+			return child, 0
+		} else if name == "fs" {
+			stable := fs.StableAttr{
+				Mode: fuse.S_IFDIR,
+				Ino: uint64(1),
+			}
+			operations := &ITNode{kind: 2, Ino: 1, path : ""}
+			child := n.NewInode(ctx, operations, stable)
+			return child, 0
+		}
+	case 1:
+		// device folder
+		for _, value := range properties {
+			if value.name == name {
+				stable := fs.StableAttr{
+					Mode: fuse.S_IFREG,
+					Ino: uint64(value.Ino),
+				}
+				operations := &ITNode{kind: 3, Ino: value.Ino}
+				child := n.NewInode(ctx, operations, stable)
+				return child, 0
+			}
+		}
+		return nil, syscall.ENOENT
+
+	case 2:
+		// FS object
+		if len(n.lst) == 0 {
+			n.Readdir(ctx)
+		}
+
+		for _, file := range n.lst {
+			if file.path != n.path + "/" + name {
+				continue;
+			}
+			log.Info("LookUp successful").Str("path", file.path).Send()
+
+			if file.isDir {
+				stable := fs.StableAttr{
+					Mode: fuse.S_IFDIR,
+					Ino: inodemap[file.path],
+				}
+				operations := &ITNode{kind: 2, path: file.path}
+				child := n.NewInode(ctx, operations, stable)
+				return child, 0
+			} else {
+				stable := fs.StableAttr{
+					Mode: fuse.S_IFREG,
+					Ino: inodemap[file.path],
+				}
+				operations := &ITNode{
+					kind: 2, path: file.path,
+					self: file,
+				}
+				child := n.NewInode(ctx, operations, stable)
+				return child, 0
+			}
+			break;
+		}
+		log.Warn("LookUp failed").Str("path", n.path + "/" + name).Send()
+	}
+	return nil, syscall.ENOENT
+}
+
+type bytesFileReadHandle struct {
+	content []byte
+}
+var _ = (fs.FileReader)((*bytesFileReadHandle)(nil))
+
+func (fh *bytesFileReadHandle) Read(ctx context.Context, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {
+	log.Info("Executing Read").Int("size", len(fh.content)).Send()
+	end := off + int64(len(dest))
+	if end > int64(len(fh.content)) {
+		end = int64(len(fh.content))
+	}
+	return fuse.ReadResultData(fh.content[off:end]), 0
+}
+
+type sensorFileReadHandle struct {
+	ch <-chan uint8
+}
+var _ = (fs.FileReader)((*sensorFileReadHandle)(nil))
+func (fh *sensorFileReadHandle) Read(ctx context.Context, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {
+	v := <-fh.ch
+	content := []byte(strconv.Itoa(int(v)) + "\n")
+	return fuse.ReadResultData(content), 0
+}
+
+
+type bytesFileWriteHandle struct {
+	content []byte
+	path string
+}
+
+var _ = (fs.FileWriter)((*bytesFileWriteHandle)(nil))
+func (fh *bytesFileWriteHandle) Write(ctx context.Context, data []byte, off int64) (written uint32, errno syscall.Errno) {
+	log.Info("Executing Write").Str("path", fh.path).Int("prev_size", len(fh.content)).Int("next_size", len(data)).Send()
+	if off != int64(len(fh.content)) {
+	}
+	fh.content = append(fh.content[:], data[:]...)
+	return uint32(len(data)), 0
+}
+
+var _ = (fs.FileFlusher)((*bytesFileWriteHandle)(nil))
+func (fh *bytesFileWriteHandle) Flush(ctx context.Context) (errno syscall.Errno) {
+	if len(fh.content) == 0 {
+		return 0
+	}
+
+	log.Info("Attempting flush").Str("path", fh.path).Send()
+	fp, err := myfs.Create(fh.path, uint32(len(fh.content)))
+	if err != nil {
+		log.Error("Flush failed: create").Str("path", fh.path).Err(err).Send()
+		return syscall.EROFS
+	}
+
+	go func() {
+		// For every progress event
+		for sent := range fp.Progress() {
+			log.Info("Progress").Int("bytes", int(sent)).Int("of", len(fh.content)).Send();
+		}
+	}()
+
+	r := bytes.NewReader(fh.content)
+	nread, err := io.Copy(fp, r)
+	if err != nil {
+		log.Error("Flush failed: write").Str("path", fh.path).Err(err).Send()
+		fp.Close()
+		return syscall.EROFS
+	}
+	if int(nread) != len(fh.content) {
+		log.Error("Flush failed: write").Str("path", fh.path).Int("expect", len(fh.content)).Int("got", int(nread)).Send()
+		fp.Close()
+		return syscall.EROFS
+	}
+	err = fp.Close()
+	if err != nil {
+		log.Error("Flush failed: close").Str("path", fh.path).Err(err).Send()
+		return syscall.EROFS
+	}
+	log.Info("Flush done").Str("path", fh.path).Int("size", len(fh.content)).Send()
+
+	return 0
+}
+var _ = (fs.FileFsyncer)((*bytesFileWriteHandle)(nil))
+func (fh *bytesFileWriteHandle) Fsync(ctx context.Context, flags uint32) (errno syscall.Errno) {
+	return fh.Flush(ctx)
+}
+
+var _ = (fs.NodeGetattrer)((*ITNode)(nil))
+func (bn *ITNode) Getattr(ctx context.Context, f fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
+	log.Info("getattr").Str("path", bn.path).Send();
+	out.Ino = bn.Ino
+	out.Mtime = bn.self.modtime
+	out.Ctime = bn.self.modtime
+	out.Atime = bn.self.modtime
+	out.Size = uint64(bn.self.size)
+	return 0
+}
+
+var _ = (fs.NodeSetattrer)((*ITNode)(nil))
+func (bn *ITNode) Setattr(ctx context.Context, fh fs.FileHandle, in *fuse.SetAttrIn, out *fuse.AttrOut) syscall.Errno {
+	log.Info("setattr").Str("path", bn.path).Send()
+	out.Size = 0;
+	out.Mtime = 0;
+	return 0
+}
+
+var _ = (fs.NodeOpener)((*ITNode)(nil))
+func (f *ITNode) Open(ctx context.Context, openFlags uint32) (fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
+	switch f.kind {
+	case 2:
+		// FS file
+		if openFlags&syscall.O_RDWR != 0 {
+			log.Warn("open: failed RDWR").Str("path", f.path).Send()
+			return nil, 0, syscall.EROFS
+		}
+
+		if openFlags & syscall.O_WRONLY != 0 {
+			log.Info("Opening file: write").Str("path", f.path).Send()
+			fh = &bytesFileWriteHandle{
+				path : f.path,
+				content : make([]byte, 0),
+			}
+			return fh, fuse.FOPEN_DIRECT_IO, 0
+		} else {
+			log.Info("Opening file: read").Str("path", f.path).Send();
+			fp, err := myfs.Open(f.path)
+			if err != nil {
+				log.Error("Opening file failed").Str("path", f.path).Err(err).Send();
+				return nil, 0, syscall.EROFS
+			}
+
+			defer fp.Close()
+
+			b := &bytes.Buffer{}
+
+			go func() {
+				// For every progress event
+				for sent := range fp.Progress() {
+					log.Info("Progress").Int("bytes", int(sent)).Int("of", int(f.self.size)).Send();
+				}
+			}()
+
+			_, err = io.Copy(b, fp)
+			if err != nil {
+				log.Error("Read failed").Str("path", f.path).Err(err).Send()
+				fp.Close()
+				return nil, 0, syscall.EROFS
+			}
+
+			fh = &bytesFileReadHandle{
+				content: b.Bytes(),
+			}
+			return fh, fuse.FOPEN_DIRECT_IO, 0
+		}
+
+	case 3:
+		// Device file
+
+		// disallow writes
+		if openFlags&(syscall.O_RDWR|syscall.O_WRONLY) != 0 {
+			return nil, 0, syscall.EROFS
+		}
+
+		for _, value := range properties {
+			if value.Ino == f.Ino {
+				ans, err := value.gen(ctx)
+				if err != nil {
+					return nil, 0, syscall.EROFS
+				}
+
+				fh = &sensorFileReadHandle{
+					ch: ans,
+				}
+				return fh, fuse.FOPEN_DIRECT_IO, 0
+			}
+		}
+	}
+	return nil, 0, syscall.EROFS
+}
+
+var _ = (fs.NodeCreater)((*ITNode)(nil))
+func (f *ITNode) Create(ctx context.Context, name string, flags uint32, mode uint32, out *fuse.EntryOut) (node *fs.Inode, fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
+	if f.kind != 2 {
+		return nil, nil, 0, syscall.EROFS
+	}
+
+	path := f.path + "/" + name
+	ino := uint64(len(inodemap)) + 11
+	inodemap[path] = ino
+
+	stable := fs.StableAttr{
+		Mode: fuse.S_IFREG,
+		Ino: ino,
+	}
+	operations := &ITNode{
+		kind: 2, Ino: ino,
+		path : path,
+	}
+	node = f.NewInode(ctx, operations, stable)
+
+	fh = &bytesFileWriteHandle{
+		path : path,
+		content : make([]byte, 0),
+	}
+
+	log.Info("Creating file").Str("path", path).Send()
+
+	errno = 0
+	return node, fh, fuseFlags, 0
+}
+
+var _ = (fs.NodeMkdirer)((*ITNode)(nil))
+func (f *ITNode) Mkdir(ctx context.Context, name string, mode uint32, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
+	if f.kind != 2 {
+		return nil, syscall.EROFS
+	}
+
+	path := f.path + "/" + name
+	err := myfs.Mkdir(path)
+	if err != nil {
+		log.Info("Mkdir failed").
+			Str("path", path).
+			Err(err).
+			Send()
+		return nil, syscall.EROFS
+	}
+
+	ino := uint64(len(inodemap)) + 11
+	inodemap[path] = ino
+
+	stable := fs.StableAttr{
+		Mode: fuse.S_IFDIR,
+		Ino: ino,
+	}
+	operations := &ITNode{
+		kind: 2, Ino: ino,
+		path : path,
+	}
+	node := f.NewInode(ctx, operations, stable)
+
+	log.Info("Mkdir sucess").
+		Str("path", path).
+		Int("ino", int(ino)).
+		Send()
+	return node, 0
+}
+
+var _ = (fs.NodeRenamer)((*ITNode)(nil))
+func (f *ITNode) Rename(ctx context.Context, name string, newParent fs.InodeEmbedder, newName string, flags uint32) syscall.Errno {
+	p1 := f.path + "/" + name
+	p2 := newParent.EmbeddedInode().Path(nil)[2:] + "/" + newName
+
+	err := myfs.Rename(p1, p2)
+	if err != nil {
+		log.Error("Rename failed").
+			Str("src", p1).
+			Str("dest", p2).
+			Err(err).
+			Send()
+
+		return syscall.EROFS
+	}
+	log.Info("Rename sucess").
+		Str("src", p1).
+		Str("dest", p2).
+		Send()
+
+	ino := inodemap[p1]
+	delete(inodemap, p1)
+	inodemap[p2] = ino
+
+	return 0
+}
+
+var _ = (fs.NodeUnlinker)((*ITNode)(nil))
+func (f *ITNode) Unlink(ctx context.Context, name string) syscall.Errno {
+	delete(inodemap, f.path + "/" + name)
+	err := myfs.Remove(f.path + "/" + name)
+	if err != nil {
+		log.Error("Unlink failed").
+			Str("file", f.path + "/" + name).
+			Err(err).
+			Send()
+
+		return syscall.EROFS
+	}
+
+	log.Info("Unlink success").
+		Str("file", f.path + "/" + name).
+		Send()
+	return 0
+}
+
+var _ = (fs.NodeRmdirer)((*ITNode)(nil))
+func (f *ITNode) Rmdir(ctx context.Context, name string) syscall.Errno {
+	return f.Unlink(ctx, name)
+}
+
 func startFuse(ctx context.Context, dev *infinitime.Device) error {
 	// This is where we'll mount the FS
 	os.Mkdir(k.String("fuse.mountpoint"), 0755)
-	root := fusefs.BuildRootNode(dev)
+	root := &ITNode{kind: 0}
 	server, err := fs.Mount(k.String("fuse.mountpoint"), root, &fs.Options{
 		MountOptions: fuse.MountOptions{
 			// Set to true to see how the file system works.
@@ -32,12 +551,22 @@ func startFuse(ctx context.Context, dev *infinitime.Device) error {
 		Str("target", k.String("fuse.mountpoint")).
 		Send()
 
-	fusefs.BuildProperties(dev)
+	mydev := Device{dev : dev};
 
+	properties[0].gen = mydev.dev.WatchHeartRate;
+	// properties[0].f = mydev.HeartRateBytes;
+	// properties[1].f = mydev.BatteryLevelBytes;
+	// properties[2].f = mydev.MotionBytes;
+	// properties[3].f = mydev.StepCountBytes;
+	// properties[4].f = mydev.VersionBytes;
+	// properties[5].f = mydev.AddressBytes;
+
+	myfs, err = dev.FS()
 	if err != nil {
 		log.Warn("Error getting BLE filesystem").Err(err).Send()
 		return err
 	}
+	inodemap = make(map[string]uint64)
 
 	// Wait until unmount before exiting
 	go server.Serve()

internal/fusefs/converters.go

@@ -1,61 +0,0 @@
-package fusefs
-
-import (
-	"go.arsenm.dev/infinitime"
-	"context"
-	"strconv"
-)
-
-func converterU8(ctx context.Context, in <-chan uint8) <-chan []byte {
-	out := make(chan []byte, 2)
-	go func() {
-		for {
-			select {
-			case <- ctx.Done():
-				return
-			case event := <-in:
-				out <- []byte(strconv.Itoa(int(event)) + "\n")
-			}
-		}
-	}()
-	return out
-}
-
-func converterU32(ctx context.Context, in <-chan uint32) <-chan []byte {
-	out := make(chan []byte, 2)
-	go func() {
-		for {
-			select {
-			case <- ctx.Done():
-				return
-			case event := <-in:
-				out <- []byte(strconv.Itoa(int(event)) + "\n")
-			}
-		}
-	}()
-	return out
-}
-
-func converterMotionValues(ctx context.Context, in <-chan infinitime.MotionValues) <-chan []byte {
-	out := make(chan []byte, 2)
-	go func() {
-		for {
-			select {
-			case <- ctx.Done():
-				return
-			case event := <-in:
-				out <- []byte(strconv.Itoa(int(event.X)) + " " + strconv.Itoa(int(event.Y)) + " " + strconv.Itoa(int(event.Z)) + "\n")
-			}
-		}
-	}()
-	return out
-}
-
-func converter1String(ctx context.Context, in string) <-chan []byte {
-	out := make(chan []byte, 2)
-	out <- []byte(in + "\n")
-	close(out)
-	return out
-}
-
-

internal/fusefs/fuse.go

@@ -1,542 +0,0 @@
-package fusefs
-
-import (
-	"go.arsenm.dev/infinitime"
-	"go.arsenm.dev/infinitime/blefs"
-	"go.arsenm.dev/logger/log"
-	"context"
-	"syscall"
-	"github.com/hanwen/go-fuse/v2/fs"
-	"github.com/hanwen/go-fuse/v2/fuse"
-	"io"
-	"bytes"
-)
-
-type ITProperty struct {
-	name string
-	Ino uint64
-	gen func(context.Context) (<-chan []byte, error)
-}
-
-
-type DirEntry struct {
-	isDir    bool
-	modtime  uint64
-	size     uint32
-	path     string
-}
-
-type ITNode struct {
-	fs.Inode
-	kind int
-	Ino uint64
-
-	lst []DirEntry
-	self DirEntry
-	path string
-}
-
-func BuildRootNode(dev *infinitime.Device) *ITNode {
-	inodemap = make(map[string]uint64)
-	myfs, _ = dev.FS()
-
-	return &ITNode{kind: 0}
-}
-
-var properties = make([]ITProperty, 6)
-
-func BuildProperties(dev *infinitime.Device) {
-	properties[0] = ITProperty{"heartrate", 2,
-		func(ctx context.Context) (<-chan []byte, error) {
-			ans, err := dev.WatchHeartRate(ctx)
-			return converterU8(ctx, ans), err
-	}}
-	properties[1] = ITProperty{"battery", 3,
-		func(ctx context.Context) (<-chan []byte, error) {
-			ans, err := dev.WatchBatteryLevel(ctx)
-			return converterU8(ctx, ans), err
-	}}
-	properties[2] = ITProperty{"motion", 4,
-		func(ctx context.Context) (<-chan []byte, error) {
-			ans, err := dev.WatchMotion(ctx)
-			return converterMotionValues(ctx, ans), err
-	}}
-	properties[3] = ITProperty{"stepcount", 5,
-		func(ctx context.Context) (<-chan []byte, error) {
-			ans, err := dev.WatchStepCount(ctx)
-			return converterU32(ctx, ans), err
-	}}
-	properties[4] = ITProperty{"version", 6,
-		func(ctx context.Context) (<-chan []byte, error) {
-			ans, err := dev.Version()
-			return converter1String(ctx, ans), err
-	}}
-	properties[5] = ITProperty{"address", 7,
-		func(ctx context.Context) (<-chan []byte, error) {
-			ans := dev.Address()
-			return converter1String(ctx, ans), nil
-	}}
-
-}
-
-
-
-var myfs *blefs.FS = nil;
-var inodemap map[string]uint64 = nil;
-
-var _ = (fs.NodeReaddirer)((*ITNode)(nil))
-
-// Readdir is part of the NodeReaddirer interface
-func (n *ITNode) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
-	switch n.kind {
-	case 0:
-		// root folder
-		r := make([]fuse.DirEntry, 2)
-		r[0] = fuse.DirEntry{
-			Name: "device",
-			Ino:  0,
-			Mode: fuse.S_IFDIR,
-		}
-		r[1] = fuse.DirEntry{
-			Name: "fs",
-			Ino:  1,
-			Mode: fuse.S_IFDIR,
-		}
-		return fs.NewListDirStream(r), 0
-
-	case 1:
-		// device folder
-		r := make([]fuse.DirEntry, 6)
-		for ind, value := range properties {
-			r[ind] = fuse.DirEntry{
-				Name: value.name,
-				Ino:  value.Ino,
-				Mode: fuse.S_IFREG,
-			}
-		}
-
-		return fs.NewListDirStream(r), 0
-
-	case 2:
-		// on device
-		files, _ := myfs.ReadDir(n.path)
-		log.Info("readdir").Str("path", n.path).Int("objects", len(files)).Send()
-		r := make([]fuse.DirEntry, len(files))
-		n.lst = make([]DirEntry, len(files))
-		for ind, entry := range files {
-			info, _ := entry.Info()
-			name := info.Name()
-
-			file := DirEntry{
-				path: n.path + "/" + name,
-				size: uint32(info.Size()),
-				modtime: uint64(info.ModTime().Unix()),
-				isDir: info.IsDir(),
-			}
-			n.lst[ind] = file
-
-			ino := inodemap[file.path]
-			if ino == 0 {
-				ino = uint64(len(inodemap)) + 1
-				inodemap[file.path] = ino
-			}
-
-			if file.isDir {
-				r[ind] = fuse.DirEntry{
-					Name: name,
-					Mode: fuse.S_IFDIR,
-					Ino : ino + 10,
-				}
-			} else {
-				r[ind] = fuse.DirEntry{
-					Name: name,
-					Mode: fuse.S_IFREG,
-					Ino : ino + 10,
-				}
-			}
-		}
-		return fs.NewListDirStream(r), 0
-	}
-	r := make([]fuse.DirEntry, 0)
-	return fs.NewListDirStream(r), 0
-}
-
-var _ = (fs.NodeLookuper)((*ITNode)(nil))
-func (n *ITNode) Lookup(ctx context.Context, name string, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
-	switch n.kind {
-	case 0:
-		// root folder
-		if name == "device" {
-			stable := fs.StableAttr{
-				Mode: fuse.S_IFDIR,
-				Ino: uint64(0),
-			}
-			operations := &ITNode{kind: 1, Ino: 0}
-			child := n.NewInode(ctx, operations, stable)
-			return child, 0
-		} else if name == "fs" {
-			stable := fs.StableAttr{
-				Mode: fuse.S_IFDIR,
-				Ino: uint64(1),
-			}
-			operations := &ITNode{kind: 2, Ino: 1, path : ""}
-			child := n.NewInode(ctx, operations, stable)
-			return child, 0
-		}
-	case 1:
-		// device folder
-		for _, value := range properties {
-			if value.name == name {
-				stable := fs.StableAttr{
-					Mode: fuse.S_IFREG,
-					Ino: uint64(value.Ino),
-				}
-				operations := &ITNode{kind: 3, Ino: value.Ino}
-				child := n.NewInode(ctx, operations, stable)
-				return child, 0
-			}
-		}
-		return nil, syscall.ENOENT
-
-	case 2:
-		// FS object
-		if len(n.lst) == 0 {
-			n.Readdir(ctx)
-		}
-
-		for _, file := range n.lst {
-			if file.path != n.path + "/" + name {
-				continue;
-			}
-			log.Info("LookUp successful").Str("path", file.path).Send()
-
-			if file.isDir {
-				stable := fs.StableAttr{
-					Mode: fuse.S_IFDIR,
-					Ino: inodemap[file.path],
-				}
-				operations := &ITNode{kind: 2, path: file.path}
-				child := n.NewInode(ctx, operations, stable)
-				return child, 0
-			} else {
-				stable := fs.StableAttr{
-					Mode: fuse.S_IFREG,
-					Ino: inodemap[file.path],
-				}
-				operations := &ITNode{
-					kind: 2, path: file.path,
-					self: file,
-				}
-				child := n.NewInode(ctx, operations, stable)
-				return child, 0
-			}
-			break;
-		}
-		log.Warn("LookUp failed").Str("path", n.path + "/" + name).Send()
-	}
-	return nil, syscall.ENOENT
-}
-
-type bytesFileReadHandle struct {
-	content []byte
-}
-var _ = (fs.FileReader)((*bytesFileReadHandle)(nil))
-
-func (fh *bytesFileReadHandle) Read(ctx context.Context, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {
-	log.Info("Executing Read").Int("size", len(fh.content)).Send()
-	end := off + int64(len(dest))
-	if end > int64(len(fh.content)) {
-		end = int64(len(fh.content))
-	}
-	return fuse.ReadResultData(fh.content[off:end]), 0
-}
-
-type sensorFileReadHandle struct {
-	ch <-chan []byte
-	cancel context.CancelFunc
-}
-var _ = (fs.FileReader)((*sensorFileReadHandle)(nil))
-func (fh *sensorFileReadHandle) Read(ctx context.Context, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {
-	content := <-fh.ch
-	return fuse.ReadResultData(content), 0
-}
-
-var _ = (fs.FileFlusher)((*sensorFileReadHandle)(nil))
-func (fh *sensorFileReadHandle) Flush(ctx context.Context) (errno syscall.Errno) {
-	fh.cancel()
-	return 0
-}
-
-
-type bytesFileWriteHandle struct {
-	content []byte
-	path string
-}
-
-var _ = (fs.FileWriter)((*bytesFileWriteHandle)(nil))
-func (fh *bytesFileWriteHandle) Write(ctx context.Context, data []byte, off int64) (written uint32, errno syscall.Errno) {
-	log.Info("Executing Write").Str("path", fh.path).Int("prev_size", len(fh.content)).Int("next_size", len(data)).Send()
-	if off != int64(len(fh.content)) {
-	}
-	fh.content = append(fh.content[:], data[:]...)
-	return uint32(len(data)), 0
-}
-
-var _ = (fs.FileFlusher)((*bytesFileWriteHandle)(nil))
-func (fh *bytesFileWriteHandle) Flush(ctx context.Context) (errno syscall.Errno) {
-	if len(fh.content) == 0 {
-		return 0
-	}
-
-	log.Info("Attempting flush").Str("path", fh.path).Send()
-	fp, err := myfs.Create(fh.path, uint32(len(fh.content)))
-	if err != nil {
-		log.Error("Flush failed: create").Str("path", fh.path).Err(err).Send()
-		return syscall.EROFS
-	}
-
-	go func() {
-		// For every progress event
-		for sent := range fp.Progress() {
-			log.Info("Progress").Int("bytes", int(sent)).Int("of", len(fh.content)).Send();
-		}
-	}()
-
-	r := bytes.NewReader(fh.content)
-	nread, err := io.Copy(fp, r)
-	if err != nil {
-		log.Error("Flush failed: write").Str("path", fh.path).Err(err).Send()
-		fp.Close()
-		return syscall.EROFS
-	}
-	if int(nread) != len(fh.content) {
-		log.Error("Flush failed: write").Str("path", fh.path).Int("expect", len(fh.content)).Int("got", int(nread)).Send()
-		fp.Close()
-		return syscall.EROFS
-	}
-	err = fp.Close()
-	if err != nil {
-		log.Error("Flush failed: close").Str("path", fh.path).Err(err).Send()
-		return syscall.EROFS
-	}
-	log.Info("Flush done").Str("path", fh.path).Int("size", len(fh.content)).Send()
-
-	return 0
-}
-var _ = (fs.FileFsyncer)((*bytesFileWriteHandle)(nil))
-func (fh *bytesFileWriteHandle) Fsync(ctx context.Context, flags uint32) (errno syscall.Errno) {
-	return fh.Flush(ctx)
-}
-
-var _ = (fs.NodeGetattrer)((*ITNode)(nil))
-func (bn *ITNode) Getattr(ctx context.Context, f fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
-	log.Info("getattr").Str("path", bn.path).Send();
-	out.Ino = bn.Ino
-	out.Mtime = bn.self.modtime
-	out.Ctime = bn.self.modtime
-	out.Atime = bn.self.modtime
-	out.Size = uint64(bn.self.size)
-	return 0
-}
-
-var _ = (fs.NodeSetattrer)((*ITNode)(nil))
-func (bn *ITNode) Setattr(ctx context.Context, fh fs.FileHandle, in *fuse.SetAttrIn, out *fuse.AttrOut) syscall.Errno {
-	log.Info("setattr").Str("path", bn.path).Send()
-	out.Size = 0;
-	out.Mtime = 0;
-	return 0
-}
-
-var _ = (fs.NodeOpener)((*ITNode)(nil))
-func (f *ITNode) Open(ctx context.Context, openFlags uint32) (fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
-	switch f.kind {
-	case 2:
-		// FS file
-		if openFlags&syscall.O_RDWR != 0 {
-			log.Warn("open: failed RDWR").Str("path", f.path).Send()
-			return nil, 0, syscall.EROFS
-		}
-
-		if openFlags & syscall.O_WRONLY != 0 {
-			log.Info("Opening file: write").Str("path", f.path).Send()
-			fh = &bytesFileWriteHandle{
-				path : f.path,
-				content : make([]byte, 0),
-			}
-			return fh, fuse.FOPEN_DIRECT_IO, 0
-		} else {
-			log.Info("Opening file: read").Str("path", f.path).Send();
-			fp, err := myfs.Open(f.path)
-			if err != nil {
-				log.Error("Opening file failed").Str("path", f.path).Err(err).Send();
-				return nil, 0, syscall.EROFS
-			}
-
-			defer fp.Close()
-
-			b := &bytes.Buffer{}
-
-			go func() {
-				// For every progress event
-				for sent := range fp.Progress() {
-					log.Info("Progress").Int("bytes", int(sent)).Int("of", int(f.self.size)).Send();
-				}
-			}()
-
-			_, err = io.Copy(b, fp)
-			if err != nil {
-				log.Error("Read failed").Str("path", f.path).Err(err).Send()
-				fp.Close()
-				return nil, 0, syscall.EROFS
-			}
-
-			fh = &bytesFileReadHandle{
-				content: b.Bytes(),
-			}
-			return fh, fuse.FOPEN_DIRECT_IO, 0
-		}
-
-	case 3:
-		// Device file
-
-		// disallow writes
-		if openFlags&(syscall.O_RDWR|syscall.O_WRONLY) != 0 {
-			return nil, 0, syscall.EROFS
-		}
-
-		for _, value := range properties {
-			if value.Ino == f.Ino {
-				sub_ctx, cancel := context.WithCancel(ctx)
-				ans, err := value.gen(sub_ctx)
-				if err != nil {
-					return nil, 0, syscall.EROFS
-				}
-
-				fh = &sensorFileReadHandle{
-					ch: ans,
-					cancel : cancel,
-				}
-				return fh, fuse.FOPEN_DIRECT_IO, 0
-			}
-		}
-	}
-	return nil, 0, syscall.EROFS
-}
-
-var _ = (fs.NodeCreater)((*ITNode)(nil))
-func (f *ITNode) Create(ctx context.Context, name string, flags uint32, mode uint32, out *fuse.EntryOut) (node *fs.Inode, fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
-	if f.kind != 2 {
-		return nil, nil, 0, syscall.EROFS
-	}
-
-	path := f.path + "/" + name
-	ino := uint64(len(inodemap)) + 11
-	inodemap[path] = ino
-
-	stable := fs.StableAttr{
-		Mode: fuse.S_IFREG,
-		Ino: ino,
-	}
-	operations := &ITNode{
-		kind: 2, Ino: ino,
-		path : path,
-	}
-	node = f.NewInode(ctx, operations, stable)
-
-	fh = &bytesFileWriteHandle{
-		path : path,
-		content : make([]byte, 0),
-	}
-
-	log.Info("Creating file").Str("path", path).Send()
-
-	errno = 0
-	return node, fh, fuseFlags, 0
-}
-
-var _ = (fs.NodeMkdirer)((*ITNode)(nil))
-func (f *ITNode) Mkdir(ctx context.Context, name string, mode uint32, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
-	if f.kind != 2 {
-		return nil, syscall.EROFS
-	}
-
-	path := f.path + "/" + name
-	err := myfs.Mkdir(path)
-	if err != nil {
-		log.Info("Mkdir failed").
-			Str("path", path).
-			Err(err).
-			Send()
-		return nil, syscall.EROFS
-	}
-
-	ino := uint64(len(inodemap)) + 11
-	inodemap[path] = ino
-
-	stable := fs.StableAttr{
-		Mode: fuse.S_IFDIR,
-		Ino: ino,
-	}
-	operations := &ITNode{
-		kind: 2, Ino: ino,
-		path : path,
-	}
-	node := f.NewInode(ctx, operations, stable)
-
-	log.Info("Mkdir sucess").
-		Str("path", path).
-		Int("ino", int(ino)).
-		Send()
-	return node, 0
-}
-
-var _ = (fs.NodeRenamer)((*ITNode)(nil))
-func (f *ITNode) Rename(ctx context.Context, name string, newParent fs.InodeEmbedder, newName string, flags uint32) syscall.Errno {
-	p1 := f.path + "/" + name
-	p2 := newParent.EmbeddedInode().Path(nil)[2:] + "/" + newName
-
-	err := myfs.Rename(p1, p2)
-	if err != nil {
-		log.Error("Rename failed").
-			Str("src", p1).
-			Str("dest", p2).
-			Err(err).
-			Send()
-
-		return syscall.EROFS
-	}
-	log.Info("Rename sucess").
-		Str("src", p1).
-		Str("dest", p2).
-		Send()
-
-	ino := inodemap[p1]
-	delete(inodemap, p1)
-	inodemap[p2] = ino
-
-	return 0
-}
-
-var _ = (fs.NodeUnlinker)((*ITNode)(nil))
-func (f *ITNode) Unlink(ctx context.Context, name string) syscall.Errno {
-	delete(inodemap, f.path + "/" + name)
-	err := myfs.Remove(f.path + "/" + name)
-	if err != nil {
-		log.Error("Unlink failed").
-			Str("file", f.path + "/" + name).
-			Err(err).
-			Send()
-
-		return syscall.EROFS
-	}
-
-	log.Info("Unlink success").
-		Str("file", f.path + "/" + name).
-		Send()
-	return 0
-}
-
-var _ = (fs.NodeRmdirer)((*ITNode)(nil))
-func (f *ITNode) Rmdir(ctx context.Context, name string) syscall.Errno {
-	return f.Unlink(ctx, name)
-}