automated stream start

May return the user ability of stopping and starting but its really
what we want
This commit is contained in:
2026-09-25 11:06:33 +01:00
parent d14649d80c
commit d677c66a22
6 changed files with 32 additions and 32 deletions
+6 -1
View File
@@ -83,14 +83,17 @@ func (ds *DeviceService) PeripheralExists(pname string) bool {
// Getters [END] ---------------------------------------------------------------
// Actions [START] -------------------------------------------------------------
func (ds *DeviceService) StartStream() {
func (ds *DeviceService) StartStream(ch <-chan telemetry.TelemetryData) {
// NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this
ds.SetTelemetryChannel(ch)
var ctx context.Context
ctx, ds.streamCancel = context.WithCancel(context.Background())
ds.PSS.OnStartStream()
go ds.transmit(ctx)
ds.Messages <- "Device service started stream\n"
}
func (ds *DeviceService) StopStream() {
@@ -154,6 +157,8 @@ func (ds *DeviceService) peripheralConfigured(pname string, fields []telemetry.F
// We need to retrigger field subscription here
subscribedTo := ds.triggerFieldSubscription(fields)
ds.Messages <- fmt.Sprintf("subscribed to fields: %q\n", subscribedTo)
ds.PSS.OnStartStreamPeripheral(pname)
}
// Callbacks [END] -------------------------------------------------------------
+12
View File
@@ -211,6 +211,17 @@ func (pss *PeripheralStateStore) OnStartStream() {
}
}
func (pss *PeripheralStateStore) OnStartStreamPeripheral(pname string) {
state, err := pss.GetState(pname)
if err != nil {
return
}
if state.State == DeviceIsConfigured {
pss.setDeviceIsStreaming(pname)
}
}
func (pss *PeripheralStateStore) OnStopStream() {
pss.mu.Lock()
pss.isStreaming = false
@@ -349,6 +360,7 @@ func (pss *PeripheralStateStore) configurePeripheral(
onFailure(pname)
return
}
pss.Messages <- fmt.Sprintf("Configuring peripheral for provider: %s\n", provider)
err = state.Peripheral.Setup(provider)
if err != nil {
+1 -1
View File
@@ -29,7 +29,7 @@ func NewOrchestrator(logger *slog.Logger) (*Orchestrator, error) {
devService.triggerFieldSubscription = telemService.SubscribeToFields
// Setup telemetry service callbacks
// telemService.getRequiredFields = devService.GetRequiredFields
telemService.startedStreaming = devService.StartStream
return &Orchestrator{
DeviceService: devService,
+7 -6
View File
@@ -35,6 +35,7 @@ type TelemetryService struct {
CtxHealthcheck context.Context
healthCheckCancel context.CancelFunc
// Callbacks
startedStreaming func(ch <-chan telemetry.TelemetryData)
// Devices data request
// peripheralProvider func() []peripheral.Peripheral
// getRequiredFields func() []telemetry.FieldID
@@ -204,21 +205,17 @@ func (t *TelemetryService) StopStream() {
t.isStreaming = false
}
func (t *TelemetryService) StartStream() {
slog.Debug("Stream started")
func (t *TelemetryService) StartStream() <-chan telemetry.TelemetryData {
// Start the new stream
if t.activeProvider == nil {
slog.Debug("there's no active provider. not starting the stream")
return
return nil
}
// Stop the provider healthcheck
t.healthCheckCancel()
simInCh, _ := t.activeProvider.Stream()
// TODO: the provider needs to be able to tell the data has stopped
// so we can restart the provider lookup routine
// Create the context so we can control the lifecycle
ctx, cancel := context.WithCancel(context.Background())
@@ -227,6 +224,10 @@ func (t *TelemetryService) StartStream() {
// Multiplex this data
go t.multiplexData(ctx, simInCh)
t.isStreaming = true
t.Messages <- "Provider has started streaming data\n"
return simInCh
}
func (t *TelemetryService) multiplexData(ctx context.Context, dataCh <-chan telem.TelemetryData) {
+4
View File
@@ -16,6 +16,7 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) {
// Attach to the provider
t.logger.Info("found provider for " + prov.Name())
t.Messages <- fmt.Sprintf("Found provider \"%s\"\n", prov.Name())
err := t.SwitchProvider(prov)
if err != nil {
t.Messages <- fmt.Sprintf("Failed to switch to provider: %+v\n", err.Error())
@@ -26,6 +27,9 @@ func (t *TelemetryService) onFindProvider(prov telem.TelemetryProvider) {
// Start the healthcheck on our provider so we can drop it if it stops
t.CtxHealthcheck, t.healthCheckCancel = context.WithCancel(context.Background())
go t.ProviderMonitor(t.CtxHealthcheck)
ch := t.StartStream()
t.startedStreaming(ch)
}
func (t *TelemetryService) onProviderStopsMidStream() {