itd/fuse.go

package main

import (
	"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"
	"strconv"
	"io"
	"bytes"
)

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
}

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
}

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 []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)
}

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 := &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.
			Debug: false,
			SingleThreaded: true,
		},
	})
	if err != nil {
		log.Error("Mounting failed").
			Str("target", k.String("fuse.mountpoint")).
			Err(err).
			Send()
			return err
	}

	log.Info("Mounted on target").
		Str("target", k.String("fuse.mountpoint")).
		Send()

	properties[0].gen = func(ctx context.Context) (<-chan []byte, error) {
		ans, err := dev.WatchHeartRate(ctx)
		return converterU8(ctx, ans), err
	}
	properties[1].gen = func(ctx context.Context) (<-chan []byte, error) {
		ans, err := dev.WatchBatteryLevel(ctx)
		return converterU8(ctx, ans), err
	}
	properties[2].gen = func(ctx context.Context) (<-chan []byte, error) {
		ans, err := dev.WatchMotion(ctx)
		return converterMotionValues(ctx, ans), err
	}
	properties[3].gen = func(ctx context.Context) (<-chan []byte, error) {
		ans, err := dev.WatchStepCount(ctx)
		return converterU32(ctx, ans), err
	}
	properties[4].gen = func(ctx context.Context) (<-chan []byte, error) {
		ans, err := dev.Version()
		return converter1String(ctx, ans), err
	}
	properties[5].gen = func(ctx context.Context) (<-chan []byte, error) {
		ans := dev.Address()
		return converter1String(ctx, ans), nil
	}

	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()
	return nil
}