Merge pull request #189 from calvinmclean/feature/restart-light

calvinmclean · web-flow · commit 44b0e3b8aff5 · 2025-11-09T13:55:42.000-07:00
Enable server to set Controller's LightState when it detects reconnect
diff --git a/garden-app/pkg/light_schedule.go b/garden-app/pkg/light_schedule.go
@@ -88,3 +88,44 @@ func (ls *LightSchedule) Patch(newLightSchedule *LightSchedule) {
 		ls.AdhocOnTime = nil
 	}
 }
+
+// ExpectedStateAtTime returns the expected state for a LightSchedule at a specific time
+func (ls LightSchedule) ExpectedStateAtTime(now time.Time) LightState {
+	_, state := ls.NextChange(now)
+	return state ^ 1
+}
+
+// NextChange determines what the next LightState change will be and at what time. For example, consider a LightSchedule
+// that turns on at 8PM for 12 hours. At 7PM, this will return (8PM, ON). At 9PM, it returns (8AM, OFF).
+func (ls LightSchedule) NextChange(now time.Time) (time.Time, LightState) {
+	// LightSchedules operate on a 24-hour interval, so we have a time for today's schedule
+	todayOnTime := ls.StartTime.OnDate(now)
+	todayOffTime := todayOnTime.Add(ls.Duration.Duration)
+
+	// and one for yesterday's which could still be active
+	yesterdayOnTime := todayOnTime.AddDate(0, 0, -1)
+	yesterdayOffTime := todayOffTime.AddDate(0, 0, -1)
+
+	withinTodaysDuration := todayOnTime.Before(now) && todayOffTime.After(now)
+	if withinTodaysDuration {
+		return todayOffTime, LightStateOff
+	}
+
+	withinYesterdayDuration := yesterdayOnTime.Before(now) && yesterdayOffTime.After(now)
+	if withinYesterdayDuration {
+		return yesterdayOffTime, LightStateOff
+	}
+
+	alreadyOnAndOffToday := todayOffTime.Before(now)
+	if alreadyOnAndOffToday {
+		// turns on again tomorrow
+		return todayOnTime.AddDate(0, 0, 1), LightStateOn
+	}
+
+	notOnYetToday := todayOnTime.After(now)
+	if notOnYetToday {
+		return todayOnTime, LightStateOn
+	}
+
+	return time.Time{}, LightStateToggle
+}
diff --git a/garden-app/pkg/light_schedule_test.go b/garden-app/pkg/light_schedule_test.go
@@ -3,6 +3,9 @@ package pkg
 import (
 	"encoding/json"
 	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLightStateString(t *testing.T) {
@@ -138,3 +141,117 @@ func TestLightStateMarshal(t *testing.T) {
 		}
 	})
 }
+
+func TestNextChange(t *testing.T) {
+	tests := []struct {
+		name          string
+		ls            LightSchedule
+		currentTime   time.Time
+		expectedTime  time.Time
+		expectedState LightState
+	}{
+		{
+			name: "OnInOneHour",
+			ls: LightSchedule{
+				StartTime: &StartTime{Time: time.Date(0, 0, 0, 13, 0, 0, 0, time.UTC)},
+				Duration:  &Duration{Duration: 12 * time.Hour},
+			},
+			currentTime:   time.Date(2025, time.November, 8, 12, 0, 0, 0, time.UTC),
+			expectedTime:  time.Date(2025, time.November, 8, 13, 0, 0, 0, time.UTC),
+			expectedState: LightStateOn,
+		},
+		{
+			name: "OffInElevenHours",
+			ls: LightSchedule{
+				StartTime: &StartTime{Time: time.Date(0, 0, 0, 13, 0, 0, 0, time.UTC)},
+				Duration:  &Duration{Duration: 12 * time.Hour},
+			},
+			currentTime:   time.Date(2025, time.November, 8, 14, 0, 0, 0, time.UTC),
+			expectedTime:  time.Date(2025, time.November, 9, 1, 0, 0, 0, time.UTC),
+			expectedState: LightStateOff,
+		},
+		{
+			name: "TurnedOnYesterdayAndTurnsOffLater",
+			ls: LightSchedule{
+				StartTime: &StartTime{Time: time.Date(0, 0, 0, 20, 0, 0, 0, time.UTC)},
+				Duration:  &Duration{Duration: 12 * time.Hour},
+			},
+			currentTime:   time.Date(2025, time.November, 8, 6, 0, 0, 0, time.UTC),
+			expectedTime:  time.Date(2025, time.November, 8, 8, 0, 0, 0, time.UTC),
+			expectedState: LightStateOff,
+		},
+		{
+			// Light turns on at 7AM and off at 7PM. It is currently 10PM, so it will turn on tomorrow morning
+			name: "TurnsOnAgainTomorrow",
+			ls: LightSchedule{
+				StartTime: &StartTime{Time: time.Date(0, 0, 0, 0o7, 0, 0, 0, time.UTC)},
+				Duration:  &Duration{Duration: 12 * time.Hour},
+			},
+			currentTime:   time.Date(2023, time.November, 8, 22, 0, 0, 0, time.UTC),
+			expectedTime:  time.Date(2023, time.November, 9, 0o7, 0, 0, 0, time.UTC),
+			expectedState: LightStateOn,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			nextTime, nextState := tt.ls.NextChange(tt.currentTime)
+			assert.Equal(t, tt.expectedTime, nextTime)
+			assert.Equal(t, tt.expectedState, nextState)
+		})
+	}
+}
+
+func TestExpectedStateAtTime(t *testing.T) {
+	tests := []struct {
+		name          string
+		ls            LightSchedule
+		currentTime   time.Time
+		expectedState LightState
+	}{
+		{
+			name: "OnInOneHour_CurrentlyOff",
+			ls: LightSchedule{
+				StartTime: &StartTime{Time: time.Date(0, 0, 0, 13, 0, 0, 0, time.UTC)},
+				Duration:  &Duration{Duration: 12 * time.Hour},
+			},
+			currentTime:   time.Date(2025, time.November, 8, 12, 0, 0, 0, time.UTC),
+			expectedState: LightStateOff,
+		},
+		{
+			name: "OffInElevenHours_CurrentlyOn",
+			ls: LightSchedule{
+				StartTime: &StartTime{Time: time.Date(0, 0, 0, 13, 0, 0, 0, time.UTC)},
+				Duration:  &Duration{Duration: 12 * time.Hour},
+			},
+			currentTime:   time.Date(2025, time.November, 8, 14, 0, 0, 0, time.UTC),
+			expectedState: LightStateOn,
+		},
+		{
+			name: "TurnedOnYesterdayAndTurnsOffLater_CurrentlyOn",
+			ls: LightSchedule{
+				StartTime: &StartTime{Time: time.Date(0, 0, 0, 20, 0, 0, 0, time.UTC)},
+				Duration:  &Duration{Duration: 12 * time.Hour},
+			},
+			currentTime:   time.Date(2025, time.November, 8, 6, 0, 0, 0, time.UTC),
+			expectedState: LightStateOn,
+		},
+		{
+			// Light runs from 5PM to 5AM and it is currently 8AM
+			name: "CurrentlyOff",
+			ls: LightSchedule{
+				StartTime: &StartTime{Time: time.Date(0, 0, 0, 17, 0, 0, 0, time.UTC)},
+				Duration:  &Duration{Duration: 12 * time.Hour},
+			},
+			currentTime:   time.Date(2025, time.November, 9, 8, 0, 0, 0, time.UTC),
+			expectedState: LightStateOff,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			currentState := tt.ls.ExpectedStateAtTime(tt.currentTime)
+			assert.Equal(t, tt.expectedState, currentState)
+		})
+	}
+}
diff --git a/garden-app/pkg/start_time.go b/garden-app/pkg/start_time.go
@@ -39,6 +39,21 @@ func (st *StartTime) String() string {
 	return st.Time.Format(startTimeFormat)
 }
 
+// OnDate takes the StartTime hour/minute/second and applies to the date on the input
+func (st StartTime) OnDate(date time.Time) time.Time {
+	date = date.In(st.Time.Location())
+	return time.Date(
+		date.Year(),
+		date.Month(),
+		date.Day(),
+		st.Time.Hour(),
+		st.Time.Minute(),
+		st.Time.Second(),
+		0,
+		st.Time.Location(),
+	)
+}
+
 // Validate is used after parsing from HTML form so the time can be parsed
 func (st *StartTime) Validate() error {
 	if !st.Time.IsZero() {
diff --git a/garden-app/worker/scheduler.go b/garden-app/worker/scheduler.go
@@ -42,12 +42,15 @@ func (w *Worker) ScheduleWaterAction(waterSchedule *pkg.WaterSchedule) error {
 	logger := w.contextLogger(nil, nil, waterSchedule)
 	logger.Info("creating scheduled Job for WaterSchedule")
 
-	startTime := waterSchedule.StartTime.Time.UTC()
+	startDate := clock.Now()
+	if waterSchedule.StartDate != nil {
+		startDate = *waterSchedule.StartDate
+	}
 
 	// Schedule the WaterAction execution
 	scheduleJobsGauge.WithLabelValues(waterScheduleLabels(waterSchedule)...).Inc()
 	_, err := waterSchedule.Interval.SchedulerFunc(w.scheduler).
-		StartAt(timeAtDate(waterSchedule.StartDate, startTime)).
+		StartAt(waterSchedule.StartTime.OnDate(startDate).UTC()).
 		Tag("water_schedule").
 		Tag(waterSchedule.ID.String()).
 		Do(func(jobLogger *slog.Logger) {
@@ -187,10 +190,8 @@ func (w *Worker) ScheduleLightActions(g *pkg.Garden) error {
 	logger := w.contextLogger(g, nil, nil)
 	logger.Info("creating scheduled Jobs for lighting Garden", "light_schedule", *g.LightSchedule)
 
-	lightTime := g.LightSchedule.StartTime.Time.UTC()
-
 	now := clock.Now()
-	onStartDate := timeAtDate(&now, lightTime)
+	onStartDate := g.LightSchedule.StartTime.OnDate(now).UTC()
 	offStartDate := onStartDate.Add(g.LightSchedule.Duration.Duration)
 
 	// Schedule the LightAction execution for ON and OFF
@@ -504,21 +505,3 @@ func (w *Worker) executeLightActionInScheduledJob(g *pkg.Garden, input *action.L
 
 	w.sendLightActionNotification(g, input.State, actionLogger)
 }
-
-func timeAtDate(date *time.Time, startTime time.Time) time.Time {
-	actualDate := clock.Now()
-	if date != nil {
-		actualDate = *date
-	}
-	actualDate = actualDate.In(startTime.Location())
-	return time.Date(
-		actualDate.Year(),
-		actualDate.Month(),
-		actualDate.Day(),
-		startTime.Hour(),
-		startTime.Minute(),
-		startTime.Second(),
-		0,
-		startTime.Location(),
-	)
-}
diff --git a/garden-app/worker/startup_notification_handler.go b/garden-app/worker/startup_notification_handler.go
@@ -1,10 +1,13 @@
 package worker
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 
+	"github.com/calvinmclean/automated-garden/garden-app/clock"
 	"github.com/calvinmclean/automated-garden/garden-app/pkg"
+	"github.com/calvinmclean/automated-garden/garden-app/pkg/action"
 	mqtt "github.com/eclipse/paho.mqtt.golang"
 )
 
@@ -31,14 +34,45 @@ func (w *Worker) getGardenAndSendStartupMessage(topic string, payload string) er
 	logger = logger.With("garden_id", garden.GetID())
 	logger.Info("found garden with topic-prefix")
 
+	err = w.setExpectedLightState(garden)
+	if err != nil {
+		logger.Warn("unable to set expected LightState", "error", err.Error())
+		msg += fmt.Sprintf(" Error setting LightState: %v", err)
+	}
+
 	return w.sendGardenStartupMessage(garden, topic, msg)
 }
 
+// setExpectedLightState is used when a GardenController connects/starts up. It sets the current
+// expected light state in case the last toggle was missed during downtime or turned off after crashing
+func (w *Worker) setExpectedLightState(garden *pkg.Garden) error {
+	if garden == nil {
+		return errors.New("nil Garden")
+	}
+
+	if garden.LightSchedule == nil {
+		return nil
+	}
+
+	state := garden.LightSchedule.ExpectedStateAtTime(clock.Now())
+	err := w.ExecuteLightAction(garden, &action.LightAction{
+		State: state,
+	})
+	if err != nil {
+		return fmt.Errorf("error executing LigthAction: %w", err)
+	}
+
+	return nil
+}
+
 func (w *Worker) sendGardenStartupMessage(garden *pkg.Garden, topic string, msg string) error {
-	logger := w.logger.With("topic", topic)
+	if garden == nil {
+		return errors.New("nil Garden")
+	}
+	logger := w.logger.With("garden_id", garden.GetID(), "topic", topic)
 
 	if !garden.GetNotificationSettings().ControllerStartup {
-		logger.Warn("garden does not have controller_startup notification enabled", "garden_id", garden.GetID())
+		logger.Warn("garden does not have controller_startup notification enabled")
 		return nil
 	}
 
diff --git a/garden-app/worker/startup_notification_handler_test.go b/garden-app/worker/startup_notification_handler_test.go
@@ -2,14 +2,76 @@ package worker
 
 import (
 	"bytes"
+	"context"
+	"fmt"
 	"log/slog"
 	"strings"
 	"testing"
+	"time"
 
+	"github.com/calvinmclean/automated-garden/garden-app/clock"
 	"github.com/calvinmclean/automated-garden/garden-app/pkg"
+	"github.com/calvinmclean/automated-garden/garden-app/pkg/mqtt"
+	"github.com/calvinmclean/automated-garden/garden-app/pkg/storage"
+	"github.com/calvinmclean/babyapi"
 	"github.com/stretchr/testify/require"
 )
 
+func TestGetGardenAndSendStartupMessage(t *testing.T) {
+	// When a GardenController reboots, the light probably turned off. If the LightSchedule shows it should be on,
+	// turn it on
+	c := clock.MockTime()
+	defer clock.Reset()
+	now := c.Now()
+
+	storageClient, err := storage.NewClient(storage.Config{
+		Driver: "hashmap",
+	})
+	require.NoError(t, err)
+
+	garden := &pkg.Garden{
+		ID:          babyapi.NewID(),
+		TopicPrefix: "garden",
+		Name:        "garden",
+		// This light scheduled turned on 3 hours ago and should still be on due to the 12 hour duration
+		LightSchedule: &pkg.LightSchedule{
+			Duration: &pkg.Duration{Duration: 12 * time.Hour},
+			StartTime: &pkg.StartTime{
+				Time: now.Add(-3 * time.Hour),
+			},
+		},
+	}
+	err = storageClient.Gardens.Set(context.Background(), garden)
+	require.NoError(t, err)
+
+	mqttClient := new(mqtt.MockClient)
+	w := NewWorker(storageClient, nil, mqttClient, slog.Default())
+
+	t.Run("LightTurnsOn", func(t *testing.T) {
+		mqttClient.On("Publish", "garden/command/light", []byte(`{"state":"ON","for_duration":null}`)).Return(nil)
+		err = w.getGardenAndSendStartupMessage("garden/data/logs", "logs message=\"garden-controller setup complete\"")
+		require.NoError(t, err)
+		mqttClient.AssertExpectations(t)
+	})
+
+	t.Run("LightTurnsOff", func(t *testing.T) {
+		c.Add(12 * time.Hour)
+		fmt.Println("LightTime", garden.LightSchedule.StartTime.Time)
+		fmt.Println("Now", clock.Now())
+		fmt.Println(garden.LightSchedule.NextChange(c.Now()))
+		mqttClient.On("Publish", "garden/command/light", []byte(`{"state":"OFF","for_duration":null}`)).Return(nil)
+		err = w.getGardenAndSendStartupMessage("garden/data/logs", "logs message=\"garden-controller setup complete\"")
+		require.NoError(t, err)
+		mqttClient.AssertExpectations(t)
+	})
+
+	t.Run("Shutdown", func(t *testing.T) {
+		mqttClient.On("Disconnect", uint(100)).Return()
+		w.Stop()
+		mqttClient.AssertExpectations(t)
+	})
+}
+
 func TestParseStartupMessage(t *testing.T) {
 	input := "logs message=\"garden-controller setup complete\""
 	msg := parseStartupMessage(input)
@@ -28,7 +90,7 @@ func TestSendGardenStartupMessage_WarnLogs(t *testing.T) {
 			"NotificationsDisabled",
 			&pkg.Garden{},
 			"", "",
-			`level=WARN msg="garden does not have controller_startup notification enabled" topic="" garden_id=00000000000000000000
+			`level=WARN msg="garden does not have controller_startup notification enabled" garden_id=00000000000000000000 topic=""
 `,
 		},
 	}
