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" ) 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 } 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 }