itd/socket.go
2023-04-20 19:54:58 -07:00

461 lines
10 KiB
Go

/*
* itd uses bluetooth low energy to communicate with InfiniTime devices
* Copyright (C) 2021 Arsen Musayelyan
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package main
import (
"context"
"errors"
"io"
"net"
"os"
"path/filepath"
"time"
"go.elara.ws/drpc/muxserver"
"go.elara.ws/infinitime"
"go.elara.ws/infinitime/blefs"
"go.elara.ws/itd/internal/rpc"
"go.elara.ws/logger/log"
"storj.io/drpc/drpcmux"
)
var (
ErrDFUInvalidFile = errors.New("provided file is invalid for given upgrade type")
ErrDFUNotEnoughFiles = errors.New("not enough files provided for given upgrade type")
ErrDFUInvalidUpgType = errors.New("invalid upgrade type")
)
func startSocket(ctx context.Context, wg WaitGroup, dev *infinitime.Device) error {
// Make socket directory if non-existant
err := os.MkdirAll(filepath.Dir(k.String("socket.path")), 0o755)
if err != nil {
return err
}
// Remove old socket if it exists
err = os.RemoveAll(k.String("socket.path"))
if err != nil {
return err
}
// Listen on socket path
ln, err := net.Listen("unix", k.String("socket.path"))
if err != nil {
return err
}
fs, err := dev.FS()
if err != nil {
log.Warn("Error getting BLE filesystem").Err(err).Send()
}
mux := drpcmux.New()
err = rpc.DRPCRegisterITD(mux, &ITD{dev})
if err != nil {
return err
}
err = rpc.DRPCRegisterFS(mux, &FS{dev, fs})
if err != nil {
return err
}
log.Info("Starting control socket").Str("path", k.String("socket.path")).Send()
wg.Add(1)
go func() {
defer wg.Done("socket")
muxserver.New(mux).Serve(ctx, ln)
}()
return nil
}
type ITD struct {
dev *infinitime.Device
}
func (i *ITD) HeartRate(_ context.Context, _ *rpc.Empty) (*rpc.IntResponse, error) {
hr, err := i.dev.HeartRate()
return &rpc.IntResponse{Value: uint32(hr)}, err
}
func (i *ITD) WatchHeartRate(_ *rpc.Empty, s rpc.DRPCITD_WatchHeartRateStream) error {
heartRateCh, err := i.dev.WatchHeartRate(s.Context())
if err != nil {
return err
}
for heartRate := range heartRateCh {
err = s.Send(&rpc.IntResponse{Value: uint32(heartRate)})
if err != nil {
return err
}
}
return nil
}
func (i *ITD) BatteryLevel(_ context.Context, _ *rpc.Empty) (*rpc.IntResponse, error) {
bl, err := i.dev.BatteryLevel()
return &rpc.IntResponse{Value: uint32(bl)}, err
}
func (i *ITD) WatchBatteryLevel(_ *rpc.Empty, s rpc.DRPCITD_WatchBatteryLevelStream) error {
battLevelCh, err := i.dev.WatchBatteryLevel(s.Context())
if err != nil {
return err
}
for battLevel := range battLevelCh {
err = s.Send(&rpc.IntResponse{Value: uint32(battLevel)})
if err != nil {
return err
}
}
return nil
}
func (i *ITD) Motion(_ context.Context, _ *rpc.Empty) (*rpc.MotionResponse, error) {
motionVals, err := i.dev.Motion()
return &rpc.MotionResponse{
X: int32(motionVals.X),
Y: int32(motionVals.Y),
Z: int32(motionVals.Z),
}, err
}
func (i *ITD) WatchMotion(_ *rpc.Empty, s rpc.DRPCITD_WatchMotionStream) error {
motionValsCh, err := i.dev.WatchMotion(s.Context())
if err != nil {
return err
}
for motionVals := range motionValsCh {
err = s.Send(&rpc.MotionResponse{
X: int32(motionVals.X),
Y: int32(motionVals.Y),
Z: int32(motionVals.Z),
})
if err != nil {
return err
}
}
return nil
}
func (i *ITD) StepCount(_ context.Context, _ *rpc.Empty) (*rpc.IntResponse, error) {
sc, err := i.dev.StepCount()
return &rpc.IntResponse{Value: sc}, err
}
func (i *ITD) WatchStepCount(_ *rpc.Empty, s rpc.DRPCITD_WatchStepCountStream) error {
stepCountCh, err := i.dev.WatchStepCount(s.Context())
if err != nil {
return err
}
for stepCount := range stepCountCh {
err = s.Send(&rpc.IntResponse{Value: stepCount})
if err != nil {
return err
}
}
return nil
}
func (i *ITD) Version(_ context.Context, _ *rpc.Empty) (*rpc.StringResponse, error) {
v, err := i.dev.Version()
return &rpc.StringResponse{Value: v}, err
}
func (i *ITD) Address(_ context.Context, _ *rpc.Empty) (*rpc.StringResponse, error) {
return &rpc.StringResponse{Value: i.dev.Address()}, nil
}
func (i *ITD) Notify(_ context.Context, data *rpc.NotifyRequest) (*rpc.Empty, error) {
return &rpc.Empty{}, i.dev.Notify(data.Title, data.Body)
}
func (i *ITD) SetTime(_ context.Context, data *rpc.SetTimeRequest) (*rpc.Empty, error) {
return &rpc.Empty{}, i.dev.SetTime(time.Unix(0, data.UnixNano))
}
func (i *ITD) WeatherUpdate(context.Context, *rpc.Empty) (*rpc.Empty, error) {
sendWeatherCh <- struct{}{}
return &rpc.Empty{}, nil
}
func (i *ITD) FirmwareUpgrade(data *rpc.FirmwareUpgradeRequest, s rpc.DRPCITD_FirmwareUpgradeStream) error {
i.dev.DFU.Reset()
switch data.Type {
case rpc.FirmwareUpgradeRequest_Archive:
// If less than one file, return error
if len(data.Files) < 1 {
return ErrDFUNotEnoughFiles
}
// If file is not zip archive, return error
if filepath.Ext(data.Files[0]) != ".zip" {
return ErrDFUInvalidFile
}
// Load DFU archive
err := i.dev.DFU.LoadArchive(data.Files[0])
if err != nil {
return err
}
case rpc.FirmwareUpgradeRequest_Files:
// If less than two files, return error
if len(data.Files) < 2 {
return ErrDFUNotEnoughFiles
}
// If first file is not init packet, return error
if filepath.Ext(data.Files[0]) != ".dat" {
return ErrDFUInvalidFile
}
// If second file is not firmware image, return error
if filepath.Ext(data.Files[1]) != ".bin" {
return ErrDFUInvalidFile
}
// Load individual DFU files
err := i.dev.DFU.LoadFiles(data.Files[0], data.Files[1])
if err != nil {
return err
}
default:
return ErrDFUInvalidUpgType
}
go func() {
for event := range i.dev.DFU.Progress() {
_ = s.Send(&rpc.DFUProgress{
Sent: int64(event.Sent),
Recieved: int64(event.Received),
Total: event.Total,
})
}
firmwareUpdating = false
}()
// Set firmwareUpdating
firmwareUpdating = true
// Start DFU
err := i.dev.DFU.Start()
if err != nil {
firmwareUpdating = false
return err
}
return nil
}
type FS struct {
dev *infinitime.Device
fs *blefs.FS
}
func (fs *FS) RemoveAll(_ context.Context, req *rpc.PathsRequest) (*rpc.Empty, error) {
fs.updateFS()
for _, path := range req.Paths {
err := fs.fs.RemoveAll(path)
if err != nil {
return &rpc.Empty{}, err
}
}
return &rpc.Empty{}, nil
}
func (fs *FS) Remove(_ context.Context, req *rpc.PathsRequest) (*rpc.Empty, error) {
fs.updateFS()
for _, path := range req.Paths {
err := fs.fs.Remove(path)
if err != nil {
return &rpc.Empty{}, err
}
}
return &rpc.Empty{}, nil
}
func (fs *FS) Rename(_ context.Context, req *rpc.RenameRequest) (*rpc.Empty, error) {
fs.updateFS()
return &rpc.Empty{}, fs.fs.Rename(req.From, req.To)
}
func (fs *FS) MkdirAll(_ context.Context, req *rpc.PathsRequest) (*rpc.Empty, error) {
fs.updateFS()
for _, path := range req.Paths {
err := fs.fs.MkdirAll(path)
if err != nil {
return &rpc.Empty{}, err
}
}
return &rpc.Empty{}, nil
}
func (fs *FS) Mkdir(_ context.Context, req *rpc.PathsRequest) (*rpc.Empty, error) {
fs.updateFS()
for _, path := range req.Paths {
err := fs.fs.Mkdir(path)
if err != nil {
return &rpc.Empty{}, err
}
}
return &rpc.Empty{}, nil
}
func (fs *FS) ReadDir(_ context.Context, req *rpc.PathRequest) (*rpc.DirResponse, error) {
fs.updateFS()
entries, err := fs.fs.ReadDir(req.Path)
if err != nil {
return nil, err
}
var fileInfo []*rpc.FileInfo
for _, entry := range entries {
info, err := entry.Info()
if err != nil {
return nil, err
}
fileInfo = append(fileInfo, &rpc.FileInfo{
Name: info.Name(),
Size: info.Size(),
IsDir: info.IsDir(),
})
}
return &rpc.DirResponse{Entries: fileInfo}, nil
}
func (fs *FS) Upload(req *rpc.TransferRequest, s rpc.DRPCFS_UploadStream) error {
fs.updateFS()
localFile, err := os.Open(req.Source)
if err != nil {
return err
}
localInfo, err := localFile.Stat()
if err != nil {
return err
}
remoteFile, err := fs.fs.Create(req.Destination, uint32(localInfo.Size()))
if err != nil {
return err
}
go func() {
// For every progress event
for sent := range remoteFile.Progress() {
_ = s.Send(&rpc.TransferProgress{
Total: remoteFile.Size(),
Sent: sent,
})
}
}()
io.Copy(remoteFile, localFile)
localFile.Close()
remoteFile.Close()
return nil
}
func (fs *FS) Download(req *rpc.TransferRequest, s rpc.DRPCFS_DownloadStream) error {
fs.updateFS()
localFile, err := os.Create(req.Destination)
if err != nil {
return err
}
remoteFile, err := fs.fs.Open(req.Source)
if err != nil {
return err
}
defer localFile.Close()
defer remoteFile.Close()
go func() {
// For every progress event
for sent := range remoteFile.Progress() {
_ = s.Send(&rpc.TransferProgress{
Total: remoteFile.Size(),
Sent: sent,
})
}
}()
_, err = io.Copy(localFile, remoteFile)
if err != nil {
return err
}
return nil
}
func (fs *FS) LoadResources(req *rpc.PathRequest, s rpc.DRPCFS_LoadResourcesStream) error {
resFl, err := os.Open(req.Path)
if err != nil {
return err
}
progCh, err := infinitime.LoadResources(resFl, fs.fs)
if err != nil {
return err
}
for evt := range progCh {
err = s.Send(&rpc.ResourceLoadProgress{
Name: evt.Name,
Total: evt.Total,
Sent: evt.Sent,
Operation: rpc.ResourceLoadProgress_Operation(evt.Operation),
})
if err != nil {
return err
}
}
return nil
}
func (fs *FS) updateFS() {
if fs.fs == nil || updateFS {
// Get new FS
newFS, err := fs.dev.FS()
if err != nil {
log.Warn("Error updating BLE filesystem").Err(err).Send()
} else {
// Set FS pointer to new FS
fs.fs = newFS
// Reset updateFS
updateFS = false
}
}
}