feat: add safeguards to not get stuck in reboot loop

internal/app.go

@@ -4,15 +4,19 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"os"
+	"os/signal"
+	"time"
+
 	"github.com/rs/zerolog/log"
 	"github.com/soerenschneider/conditional-reboot/internal/group"
 	"github.com/soerenschneider/conditional-reboot/internal/journal"
+	"github.com/soerenschneider/conditional-reboot/internal/uptime"
 	"github.com/soerenschneider/conditional-reboot/pkg/reboot"
-	"os"
-	"os/signal"
-	"time"
 )
 
+const DefaultSystemUptimeHours = 4
+
 type ConditionalReboot struct {
 	groups        []*group.Group
 	rebootImpl    reboot.Reboot
@@ -45,6 +49,16 @@ func NewConditionalReboot(groups []*group.Group, rebootImpl reboot.Reboot, audit
 	}, nil
 }
 
+func IsSafeToReboot() bool {
+	systemUptime, err := uptime.Uptime()
+	if err != nil {
+		log.Error().Err(err).Msgf("could not determine system uptime, rebooting anyway: %w", err)
+		return true
+	}
+
+	return systemUptime.Hours() >= DefaultSystemUptimeHours
+}
+
 func (app *ConditionalReboot) Start() {
 	ctx, cancel := context.WithCancel(context.Background())
 	for _, group := range app.groups {
@@ -62,7 +76,11 @@ func (app *ConditionalReboot) Start() {
 			return
 
 		case group := <-app.rebootRequest:
-			log.Info().Msgf("Group '%s' requests reboot", group.GetName())
+			log.Info().Msgf("Reboot request from group '%s'", group.GetName())
+
+			if !IsSafeToReboot() {
+				log.Warn().Msg("Not safe to reboot (yet), ignoring reboot request")
+			}
 
 			if err := app.audit.Journal(actionToText(group)); err != nil {
 				log.Err(err).Msg("could not write journal")

internal/uptime/uptime.go

@@ -0,0 +1,24 @@
+package uptime
+
+import (
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Clock interface makes it easier to test
+type Clock interface {
+	Now() time.Time
+}
+
+type realClock struct{}
+
+func (r *realClock) Now() time.Time {
+	return time.Now()
+}
+
+func parseLinuxUptime(uptime string) (float64, error) {
+	parts := strings.Split(string(uptime), " ")
+	secondsStr := strings.TrimSpace(parts[0])
+	return strconv.ParseFloat(secondsStr, 64)
+}

internal/uptime/uptime_darwin.go

@@ -0,0 +1,11 @@
+package uptime
+
+import (
+	"time"
+)
+
+var start = time.Now()
+
+func Uptime() (time.Duration, error) {
+	return time.Since(start), nil
+}

internal/uptime/uptime_linux.go

@@ -0,0 +1,32 @@
+package uptime
+
+import "os"
+
+var (
+	rawUptimeImpl UptimeSource = &LinuxUptime{}
+	clock         Clock        = &realClock{}
+)
+
+type UptimeSource interface {
+	RawUptime() (float64, error)
+}
+
+func Uptime() (time.Duration, error) {
+	seconds, err := rawUptimeImpl.RawUptime()
+	if err != nil {
+		return time.Time{}, fmt.Errorf("could not read raw uptime: %w", err)
+	}
+
+	return time.Second * time.Duration(seconds), nil
+}
+
+type LinuxUptime struct {
+}
+
+func (p *LinuxUptime) RawUptime() (float64, error) {
+	uptime, err := os.ReadFile("/proc/uptime")
+	if err != nil {
+		return math.MaxFloat64, err
+	}
+	return parseLinuxUptime(uptime)
+}