Merge pull request #171 from richbl/dev

refactor(app): 🧑‍💻 Added goroutine wrappers (r/w mutexes) …

Author: richbl

go.mod

@@ -7,13 +7,13 @@ require (
 	github.com/diamondburned/gotk4-adwaita/pkg v0.0.0-20250703085337-e94555b846b6
 	github.com/diamondburned/gotk4/pkg v0.3.2-0.20250703063411-16654385f59a
 	github.com/gen2brain/go-mpv v0.2.3
+	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20250301202403-da16c1255728
 	github.com/stretchr/testify v1.11.1
 	tinygo.org/x/bluetooth v0.13.0
 )
 
 require (
 	github.com/KarpelesLab/weak v0.1.1 // indirect
-	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20250301202403-da16c1255728 // indirect
 	go4.org/unsafe/assume-no-moving-gc v0.0.0-20231121144256-b99613f794b6 // indirect
 	golang.org/x/sync v0.17.0 // indirect
 )

internal/ble/sensor_controller.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"tinygo.org/x/bluetooth"
@@ -34,6 +35,7 @@ type blePeripheralDetails struct {
 type Controller struct {
 	blePeripheralDetails blePeripheralDetails
 	speedConfig          config.SpeedConfig
+	InstanceID           int64
 }
 
 // actionParams encapsulates parameters for BLE actions
@@ -46,6 +48,9 @@ type actionParams[T any] struct {
 // Mutex for synchronizing adapter access
 var AdapterMu sync.Mutex
 
+// Instance counter to distinguish between controller object instances
+var bleInstanceCounter atomic.Int64
+
 // Error definitions
 var (
 	// General BLE errors
@@ -80,20 +85,26 @@ func NewBLEController(bleConfig config.BLEConfig, speedConfig config.SpeedConfig
 	AdapterMu.Lock()
 	defer AdapterMu.Unlock()
 
+	// Increment instance counter
+	instanceID := bleInstanceCounter.Add(1)
+
+	logger.Debug(logger.BackgroundCtx, logger.BLE, fmt.Sprintf("creating BLE controller object (id:%04d)...", instanceID))
+
 	bleAdapter := bluetooth.DefaultAdapter
 
 	if err := bleAdapter.Enable(); err != nil {
-		return nil, fmt.Errorf(errFormat, "failed to enable BLE central controller", err)
+		return nil, fmt.Errorf(errFormat, "failed to enable BLE controller", err)
 	}
 
-	logger.Info(logger.BackgroundCtx, logger.BLE, "created new BLE central controller")
+	logger.Info(logger.BackgroundCtx, logger.BLE, fmt.Sprintf("created BLE controller object (id:%04d)", instanceID))
 
 	return &Controller{
 		blePeripheralDetails: blePeripheralDetails{
 			bleConfig:  bleConfig,
 			bleAdapter: *bleAdapter,
 		},
 		speedConfig: speedConfig,
+		InstanceID:  instanceID,
 	}, nil
 }
 

internal/services/shutdown_manager.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"os/signal"
 	"sync"
+	"sync/atomic"
 	"syscall"
 	"time"
 
@@ -21,28 +22,39 @@ type smContext struct {
 	cancel context.CancelFunc
 }
 
-// ShutdownManager represents a shutdown manager that manages a component lifecycle
+// ShutdownManager manages an application lifecycle
 type ShutdownManager struct {
-	context smContext
-	errChan chan error
-	cleanup []func()
-	wg      sync.WaitGroup
-	timeout time.Duration
+	context    smContext
+	errChan    chan error
+	cleanup    []func()
+	wg         sync.WaitGroup
+	timeout    time.Duration
+	InstanceID int64
 }
 
+// Instance counter to distinguish between shutdown manager objects
+var shutdownInstanceCounter atomic.Int64
+
 // NewShutdownManager creates a new shutdown manager
 func NewShutdownManager(timeout time.Duration) *ShutdownManager {
 
+	instanceID := shutdownInstanceCounter.Add(1)
+
+	logger.Debug(logger.BackgroundCtx, logger.APP, fmt.Sprintf("creating shutdown manager object (id:%04d)...", instanceID))
+
 	// Create a context with a timeout
 	ctx, cancel := context.WithCancel(logger.BackgroundCtx)
 
+	logger.Debug(logger.BackgroundCtx, logger.APP, fmt.Sprintf("created shutdown manager object (id:%04d)", instanceID))
+
 	return &ShutdownManager{
 		context: smContext{
 			ctx:    ctx,
 			cancel: cancel,
 		},
-		timeout: timeout,
-		errChan: make(chan error, 1),
+		timeout:    timeout,
+		InstanceID: instanceID,
+		errChan:    make(chan error, 1),
 	}
 }
 
@@ -88,6 +100,8 @@ func (sm *ShutdownManager) Start() {
 // Shutdown shuts down the shutdown manager
 func (sm *ShutdownManager) Shutdown() {
 
+	logger.Debug(logger.BackgroundCtx, logger.APP, fmt.Sprintf("shutting down shutdown manager object (id:%04d)...", sm.InstanceID))
+
 	sm.context.cancel()
 	done := make(chan struct{})
 
@@ -98,15 +112,20 @@ func (sm *ShutdownManager) Shutdown() {
 
 	select {
 	case <-done:
+		logger.Debug(logger.BackgroundCtx, logger.APP, fmt.Sprintf("shutdown manager (id:%04d) services stopped", sm.InstanceID))
+
 	case <-time.After(sm.timeout):
-		logger.Warn(sm.context.ctx, logger.APP, "shutdown timed out")
+		logger.Debug(logger.BackgroundCtx, logger.APP, fmt.Sprintf("shutdown manager (id:%04d) shutdown timed out", sm.InstanceID))
+
 	}
 
 	// Execute cleanup functions in reverse order
 	for i := len(sm.cleanup) - 1; i >= 0; i-- {
 		sm.cleanup[i]()
 	}
 
+	logger.Debug(logger.BackgroundCtx, logger.APP, fmt.Sprintf("shutdown manager object (id:%04d) shutdown complete", sm.InstanceID))
+
 }
 
 // Context returns the shutdown manager's context

internal/services/shutdown_manager_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/richbl/go-ble-sync-cycle/internal/logger"
 	sm "github.com/richbl/go-ble-sync-cycle/internal/services"
 )
 
@@ -17,6 +18,8 @@ var (
 // TestNewShutdownManager tests the creation of a new shutdown manager
 func TestNewShutdownManager(t *testing.T) {
 
+	logger.Initialize("debug")
+
 	timeout := 5 * time.Second
 	manager := sm.NewShutdownManager(timeout)
 

internal/session/controllers.go

@@ -94,8 +94,13 @@ func (m *StateManager) StartSession() error {
 func (m *StateManager) StopSession() error {
 
 	m.mu.Lock()
+
 	shutdownMgr := m.shutdownMgr
 	wasPending := m.PendingStart
+
+	// Log what we're destroying
+	m.logControllersRelease(shutdownMgr)
+
 	m.state = StateLoaded
 	m.PendingStart = false
 	m.mu.Unlock()
@@ -104,50 +109,90 @@ func (m *StateManager) StopSession() error {
 		return errNoActiveSession
 	}
 
+	ctx := logger.BackgroundCtx
+	if shutdownMgr != nil {
+		ctx = *shutdownMgr.Context()
+	}
+
 	if wasPending {
-		logger.Info(*shutdownMgr.Context(), logger.BLE, "stop requested, canceling pending session setup...")
+		logger.Info(ctx, logger.APP, "stop requested, canceling pending session setup...")
 	} else {
-		logger.Info(*shutdownMgr.Context(), logger.BLE, "stop requested, canceling active session...")
+		logger.Info(ctx, logger.APP, "stop requested, canceling active session...")
 	}
 
-	// Trigger shutdown (cancels ctx, waits wg—like Ctrl+C)
 	fmt.Fprint(os.Stdout, "\r") // Clear the ^C character from the terminal line
 
+	// Stop the shutdown manager
 	if shutdownMgr != nil {
 		shutdownMgr.Shutdown()
 	}
 
-	// Clear resources under lock
+	m.clearResources()
+	m.stopBLEScan(ctx)
+
+	if wasPending {
+		logger.Info(ctx, logger.APP, "stopped pending session startup")
+	} else {
+		logger.Info(ctx, logger.APP, "session stopped")
+	}
+
+	return nil
+}
+
+// logControllersRelease logs the release of controller objects
+func (m *StateManager) logControllersRelease(shutdownMgr *services.ShutdownManager) {
+
+	if m.controllers == nil || shutdownMgr == nil {
+		return
+	}
+
+	ctx := *shutdownMgr.Context()
+
+	if m.controllers.bleController != nil {
+		logger.Info(ctx, logger.BLE, fmt.Sprintf("releasing BLE controller object (id:%04d)", m.controllers.bleController.InstanceID))
+	}
+	if m.controllers.speedController != nil {
+		logger.Info(ctx, logger.SPEED, fmt.Sprintf("releasing speed controller object (id:%04d)", m.controllers.speedController.InstanceID))
+	}
+	if m.controllers.videoPlayer != nil {
+		logger.Info(ctx, logger.VIDEO, fmt.Sprintf("releasing video controller object (id:%04d)", m.controllers.videoPlayer.InstanceID))
+	}
+
+}
+
+// clearResources clears the session resources
+func (m *StateManager) clearResources() {
+
 	m.mu.Lock()
+	defer m.mu.Unlock()
+
 	m.controllers = nil
 	m.shutdownMgr = nil
 	m.activeConfig = nil
-	m.mu.Unlock()
+
+	logger.Debug(logger.BackgroundCtx, logger.APP, "controllers and shutdown manager objects released")
+
+}
+
+// stopBLEScan stops the BLE scan
+func (m *StateManager) stopBLEScan(ctx context.Context) {
 
 	// Stop any ongoing scan under mutex
 	ble.AdapterMu.Lock()
 	defer ble.AdapterMu.Unlock()
 
 	if err := bluetooth.DefaultAdapter.StopScan(); err != nil {
-		logger.Warn(*shutdownMgr.Context(), logger.BLE, fmt.Sprintf("failed to stop current BLE scan: %v", err))
-	} else {
-		logger.Info(*shutdownMgr.Context(), logger.BLE, "BLE scan stopped")
-	}
-
-	if wasPending {
-		logger.Info(*shutdownMgr.Context(), logger.APP, "stopped pending session startup")
+		logger.Warn(ctx, logger.BLE, fmt.Sprintf("failed to stop current BLE scan: %v", err))
 	} else {
-		logger.Info(*shutdownMgr.Context(), logger.APP, "session stopped")
+		logger.Info(ctx, logger.BLE, "BLE scan stopped")
 	}
 
-	return nil
 }
 
 // BatteryLevel returns the current battery level from the BLE controller
 func (m *StateManager) BatteryLevel() byte {
 
-	m.mu.RLock()
-	defer m.mu.RUnlock()
+	defer m.readLock()()
 
 	if m.controllers != nil && m.controllers.bleController != nil {
 		return m.controllers.bleController.BatteryLevelLast()
@@ -159,8 +204,7 @@ func (m *StateManager) BatteryLevel() byte {
 // CurrentSpeed returns the current smoothed speed from the speed controller
 func (m *StateManager) CurrentSpeed() (float64, string) {
 
-	m.mu.RLock()
-	defer m.mu.RUnlock()
+	defer m.readLock()()
 
 	// Use ActiveConfig here to ensure we return the units of the active running session
 	cfg := m.activeConfig
@@ -179,8 +223,7 @@ func (m *StateManager) CurrentSpeed() (float64, string) {
 // VideoTimeRemaining returns the formatted time remaining string (HH:MM:SS)
 func (m *StateManager) VideoTimeRemaining() string {
 
-	m.mu.RLock()
-	defer m.mu.RUnlock()
+	defer m.readLock()()
 
 	noTime := "--:--:--"
 
@@ -199,8 +242,7 @@ func (m *StateManager) VideoTimeRemaining() string {
 // VideoPlaybackRate returns the current video playback multiplier (e.g. 1.0x)
 func (m *StateManager) VideoPlaybackRate() float64 {
 
-	m.mu.RLock()
-	defer m.mu.RUnlock()
+	defer m.readLock()()
 
 	if m.controllers == nil || m.controllers.videoPlayer == nil {
 		return 0.0
@@ -216,28 +258,32 @@ func (m *StateManager) initializeControllers() (*controllers, error) {
 	cfg := m.activeConfig
 	m.mu.RUnlock()
 
+	logger.Debug(logger.BackgroundCtx, logger.APP, "creating and initializing controllers...")
+
 	if cfg == nil {
 		return nil, errNoActiveConfig
 	}
 
-	logger.Debug(logger.BackgroundCtx, logger.APP, "creating speed controller...")
+	logger.Debug(logger.BackgroundCtx, logger.APP, "creating new speed controller...")
 
 	speedController := speed.NewSpeedController(cfg.Speed.SmoothingWindow)
 
-	logger.Debug(logger.BackgroundCtx, logger.APP, "creating video controller...")
+	logger.Debug(logger.BackgroundCtx, logger.APP, "creating new video controller...")
 
 	videoPlayer, err := video.NewPlaybackController(cfg.Video, cfg.Speed)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create video controller: %w", err)
 	}
 
-	logger.Debug(logger.BackgroundCtx, logger.APP, "creating BLE controller...")
+	logger.Debug(logger.BackgroundCtx, logger.APP, "creating new BLE controller...")
 
 	bleController, err := ble.NewBLEController(cfg.BLE, cfg.Speed)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create BLE controller: %w", err)
 	}
 
+	logger.Debug(logger.BackgroundCtx, logger.APP, "all controllers created and initialized")
+
 	return &controllers{
 		speedController: speedController,
 		videoPlayer:     videoPlayer,
@@ -310,6 +356,29 @@ func (m *StateManager) startServices(ctrl *controllers, shutdownMgr *services.Sh
 
 }
 
+// cleanupStartFailure handles cleaning manager state when session startup fails
+func (m *StateManager) cleanupStartFailure(shutdownMgr *services.ShutdownManager) {
+
+	logger.Debug(logger.BackgroundCtx, logger.APP, "resetting controllers and session state...")
+
+	m.mu.Lock()
+	m.PendingStart = false
+	m.state = StateLoaded
+	m.controllers = nil
+	m.shutdownMgr = nil
+	m.activeConfig = nil
+
+	m.mu.Unlock()
+
+	// ensure the shutdown manager... uh... shuts down
+	if shutdownMgr != nil {
+		shutdownMgr.Shutdown()
+	}
+
+	logger.Debug(logger.BackgroundCtx, logger.APP, "controllers and session state reset complete")
+
+}
+
 // runService helper to launch a service with standard error handling and logging
 func (m *StateManager) runService(shutdownMgr *services.ShutdownManager, service string, action func(context.Context) error) {