Created a devices service and moved the CDashDisplay service to the sahdow realm

services/devices.go

@@ -0,0 +1,123 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"sync/atomic"
+
+	"esdi/devices"
+	"esdi/devices/cdashdisplay"
+	"esdi/telemetry"
+)
+
+// DeviceService will handle sending the data from the telemetry service to the
+// actual devices
+// NOTE: create a virtual device and make it be the output window or something so
+// we can just add it as a device or whatever instead of being a custom made thing
+// that would be pretty cool I think
+type DeviceService struct {
+	Logger  *slog.Logger
+	Devices map[string]devices.Device
+	// Strem handling
+	streamCancel context.CancelFunc
+	TelemCh      <-chan telemetry.TelemetryData
+	// Output
+	Messages chan string
+}
+
+func NewDeviceService(logger *slog.Logger) *DeviceService {
+	sharedChannel := make(chan string, 10)
+	return &DeviceService{
+		Devices:  make(map[string]devices.Device),
+		Logger:   logger,
+		Messages: sharedChannel,
+	}
+}
+
+func (ds *DeviceService) FindDevices() {
+	// Need to define a list of devices to search for
+	// For now lets just try to find our cdashdisplay - will think about the rest later
+
+	// Find CDashDisplay
+	{
+		ds.Messages <- "looking for " + cdashdisplay.Name + "...\n"
+		ds.Logger.Info("Looking for " + cdashdisplay.Name)
+
+		cdashdisplay.SetLogger(ds.Logger.With("[device]", cdashdisplay.Name))
+
+		// Create a cdashdisplay
+		display, err := cdashdisplay.Discover()
+		if err == nil {
+			ds.Devices[cdashdisplay.Name] = display
+			ds.Logger.Info("found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name)
+			ds.Messages <- "found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name + "\n"
+			return
+		}
+
+		ds.Logger.Info("didn't find " + cdashdisplay.Name)
+		ds.Messages <- "didn't find " + cdashdisplay.Name + "\n"
+		// No CDashDisplay available for one reason or another, so we don't set the
+		// key
+	}
+}
+
+func (ds *DeviceService) GetDevice(name string) (devices.Device, error) {
+	val, ok := ds.Devices[name]
+	if !ok {
+		return nil, fmt.Errorf("device `%s` couldn't be found", name)
+	}
+
+	return val, nil
+}
+
+func (ds *DeviceService) StartStream() {
+	// NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this
+	var ctx context.Context
+	ctx, ds.streamCancel = context.WithCancel(context.Background())
+
+	go ds.transmit(ctx)
+}
+
+func (ds *DeviceService) StopStream() {
+	if ds.streamCancel == nil {
+		return
+	}
+
+	ds.streamCancel()
+	ds.streamCancel = nil
+}
+
+// SetTelemetryChannel sets the TelemCh to the passed channel
+func (ds *DeviceService) SetTelemetryChannel(ch <-chan telemetry.TelemetryData) {
+	ds.TelemCh = ch
+}
+
+// transmit will send the data to the devices themselves
+func (ds *DeviceService) transmit(ctx context.Context) {
+	var isSending atomic.Bool
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case data, ok := <-ds.TelemCh:
+			if !ok {
+				return
+			}
+
+			if isSending.Load() {
+				continue
+			}
+
+			isSending.Store(true)
+
+			// TODO: make a copy of the data and send that copy instead of keeping
+			// the data locked
+			for _, dev := range ds.Devices {
+				dev.SendData(&data)
+			}
+			isSending.Store(false)
+		}
+	}
+}