Scheduling improvements

Makefile

@@ -87,6 +87,10 @@ $(GOBIN)/mockery: verify $(GOBIN)/eget
 	@echo "[*] $@"
 	"$(GOBIN)/eget" vektra/mockery --upgrade-only --to '$(GOBIN)'
 
+$(GOBIN)/golangci-lint: verify $(GOBIN)/eget
+	@echo "[*] $@"
+	"$(GOBIN)/eget" golangci/golangci-lint --tag v1.63.4 --asset=tar.gz --upgrade-only --to '$(GOBIN)'
+
 prepare_build: verify download
 	@echo "[*] $@"
 
@@ -296,14 +300,14 @@ checklinks:
 	muffet -b 8192 --exclude="(linux.die.net|stackoverflow.com)" http://localhost:1313/resticprofile/
 
 .PHONY: lint
-lint:
+lint: $(GOBIN)/golangci-lint
 	@echo "[*] $@"
 	GOOS=darwin golangci-lint run
 	GOOS=linux golangci-lint run
 	GOOS=windows golangci-lint run
 
 .PHONY: fix
-fix:
+fix: $(GOBIN)/golangci-lint
 	@echo "[*] $@"
 	$(GOCMD) mod tidy
 	$(GOCMD) fix ./...

calendar/event.go

@@ -97,6 +97,11 @@ func (e *Event) Parse(input string) error {
 func (e *Event) Next(from time.Time) time.Time {
 	// start from time and increment of 1 minute each time
 	next := from.Truncate(time.Minute) // truncate all the seconds
+	// if we're already partway through a minute, skip to the next minute
+	// to avoid scheduling events in the past
+	if from.Second() > 0 {
+		next = next.Add(time.Minute) // it's too late for the current minute
+	}
 	// should stop in 2 years time to avoid an infinite loop
 	endYear := from.Year() + 2
 	for next.Year() <= endYear {

calendar/event_test.go

@@ -161,24 +161,31 @@ func TestNextTrigger(t *testing.T) {
 	// the base time is the example in the Go documentation https://golang.org/pkg/time/
 	ref, err := time.Parse(time.ANSIC, "Mon Jan 2 15:04:05 2006")
 	require.NoError(t, err)
+	refNoSecond, err := time.Parse(time.ANSIC, "Mon Jan 2 15:04:00 2006")
+	require.NoError(t, err)
 
-	testData := []struct{ event, trigger string }{
-		{"*:*:*", "2006-01-02 15:04:00"}, // seconds are zeroed out
-		{"03-*", "2006-03-01 00:00:00"},
-		{"*-01", "2006-02-01 00:00:00"},
-		{"*:*:11", "2006-01-02 15:04:00"}, // again, seconds are zeroed out
-		{"*:11:*", "2006-01-02 15:11:00"},
-		{"11:*:*", "2006-01-03 11:00:00"},
-		{"tue", "2006-01-03 00:00:00"},
-		{"2003-*-*", "0001-01-01 00:00:00"},
+	testData := []struct {
+		event, trigger string
+		ref            time.Time
+	}{
+		{"*:*:*", "2006-01-02 15:04:00", refNoSecond}, // at the exact same second
+		{"*:*:*", "2006-01-02 15:05:00", ref},         // seconds are zeroed out => take next minute
+		{"03-*", "2006-03-01 00:00:00", ref},
+		{"*-01", "2006-02-01 00:00:00", ref},
+		{"*:*:11", "2006-01-02 15:04:00", refNoSecond}, // at the exact same second
+		{"*:*:11", "2006-01-02 15:05:00", ref},         // seconds are zeroed out => take next minute
+		{"*:11:*", "2006-01-02 15:11:00", ref},
+		{"11:*:*", "2006-01-03 11:00:00", ref},
+		{"tue", "2006-01-03 00:00:00", ref},
+		{"2003-*-*", "0001-01-01 00:00:00", ref},
 	}
 
 	for _, testItem := range testData {
 		t.Run(testItem.event, func(t *testing.T) {
 			event := NewEvent()
 			err = event.Parse(testItem.event)
 			assert.NoError(t, err)
-			assert.Equal(t, testItem.trigger, event.Next(ref).String()[0:len(testItem.trigger)])
+			assert.Equal(t, testItem.trigger, event.Next(testItem.ref).String()[0:len(testItem.trigger)])
 		})
 	}
 }

codecov.yml

@@ -11,6 +11,7 @@ ignore:
   - run_profile.go
   - syslog.go
   - syslog_windows.go
+  - "**/mocks/*.go"
 
 codecov:
   notify:

commands.go

@@ -11,6 +11,7 @@
 	"slices"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/creativeprojects/clog"
@@ -25,6 +26,7 @@
 
 var (
 	ownCommands = NewOwnCommands()
+	elevation   sync.Once
 )
 
 func init() {
@@ -99,7 +101,8 @@
 			needConfiguration: true,
 			hide:              false,
 			flags: map[string]string{
-				"--no-start": "don't start the timer/service (systemd/launch only)",
+				"--no-start": "don't start the job after installing (systemd/launch only)",
+				"--start":    "start the job after installing (systemd/launch only)",
 				"--all":      "add all scheduled jobs of all profiles and groups",
 			},
 		},
@@ -323,8 +326,11 @@
 	}
 	// maybe can find a better way than searching for the word "denied"?
 	if platform.IsWindows() && !flags.isChild && strings.Contains(err.Error(), "denied") {
-		clog.Info("restarting resticprofile in elevated mode...")
-		err := elevated()
+		// we try only once, otherwise we return the original error
+		elevation.Do(func() {
+			clog.Info("restarting resticprofile in elevated mode...")
+			err = elevated()
+		})
 		if err != nil {
 			return err
 		}

commands_schedule.go

@@ -15,6 +15,10 @@
 	"golang.org/x/text/language"
 )
 
+const (
+	legacyFlagWarning = "the --legacy flag is only temporary and will be removed in version 1.0."
+)
+
 // createSchedule accepts one argument from the commandline: --no-start
 func createSchedule(_ io.Writer, ctx commandContext) error {
 	c := ctx.config
@@ -24,9 +28,9 @@
 	defer c.DisplayConfigurationIssues()
 
 	type profileJobs struct {
-		scheduler schedule.SchedulerConfig
-		name      string
-		jobs      []*config.Schedule
+		schedulerConfig schedule.SchedulerConfig
+		name            string
+		jobs            []*config.Schedule
 	}
 
 	allJobs := make([]profileJobs, 0, 1)
@@ -55,12 +59,12 @@
 			}
 		}
 
-		allJobs = append(allJobs, profileJobs{scheduler: scheduler, name: profileName, jobs: jobs})
+		allJobs = append(allJobs, profileJobs{schedulerConfig: scheduler, name: profileName, jobs: jobs})
 	}
 
 	// Step 2: Schedule all collected jobs
 	for _, j := range allJobs {
-		err := scheduleJobs(schedule.NewHandler(j.scheduler), j.name, j.jobs)
+		err := scheduleJobs(schedule.NewHandler(j.schedulerConfig), j.jobs)
 		if err != nil {
 			return retryElevated(err, flags)
 		}
@@ -70,26 +74,45 @@
 }
 
 func removeSchedule(_ io.Writer, ctx commandContext) error {
+	var err error
 	c := ctx.config
 	flags := ctx.flags
 	args := ctx.request.arguments
 
-	// Unschedule all jobs of all selected profiles
-	for _, profileName := range selectProfilesAndGroups(c, flags, args) {
-		profileFlags := flagsForProfile(flags, profileName)
+	if slices.Contains(args, "--legacy") {
+		clog.Warning(legacyFlagWarning)
+		// Unschedule all jobs of all selected profiles
+		for _, profileName := range selectProfilesAndGroups(c, flags, args) {
+			profileFlags := flagsForProfile(flags, profileName)
 
-		scheduler, jobs, err := getRemovableScheduleJobs(c, profileFlags)
-		if err != nil {
-			return err
-		}
+			schedulerConfig, jobs, err := getRemovableScheduleJobs(c, profileFlags)
+			if err != nil {
+				return err
+			}
 
-		err = removeJobs(schedule.NewHandler(scheduler), profileName, jobs)
-		if err != nil {
-			return retryElevated(err, flags)
+			err = removeJobs(schedule.NewHandler(schedulerConfig), jobs)
+			if err != nil {
+				err = retryElevated(err, flags)
+			}
+			if err != nil {
+				// we keep trying to remove the other jobs
+				clog.Error(err)
+			}
 		}
+		return nil
 	}
 
-	return nil
+	profileName := ctx.request.profile
+	if slices.Contains(args, "--all") {
+		// Unschedule all jobs of all profiles
+		profileName = ""
+	}
+	schedulerConfig := schedule.NewSchedulerConfig(ctx.global)
+	err = removeScheduledJobs(schedule.NewHandler(schedulerConfig), ctx.config.GetConfigFile(), profileName)
+	if err != nil {
+		err = retryElevated(err, flags)
+	}
+	return err
 }
 
 func statusSchedule(w io.Writer, ctx commandContext) error {
@@ -99,38 +122,54 @@
 
 	defer c.DisplayConfigurationIssues()
 
-	if !slices.Contains(args, "--all") {
-		scheduler, schedules, _, err := getScheduleJobs(c, flags)
-		if err != nil {
-			return err
-		}
-		if len(schedules) == 0 {
-			clog.Warningf("profile or group %s has no schedule", flags.name)
+	if slices.Contains(flags.resticArgs, "--legacy") {
+		clog.Warning(legacyFlagWarning)
+		// single profile or group
+		if !slices.Contains(args, "--all") {
+			schedulerConfig, schedules, _, err := getScheduleJobs(c, flags)
+			if err != nil {
+				return err
+			}
+			if len(schedules) == 0 {
+				clog.Warningf("profile or group %s has no schedule", flags.name)
+				return nil
+			}
+			err = statusScheduleProfileOrGroup(schedulerConfig, schedules, flags)
+			if err != nil {
+				return err
+			}
 			return nil
 		}
-		err = statusScheduleProfileOrGroup(scheduler, schedules, flags)
-		if err != nil {
-			return err
-		}
-	}
 
-	for _, profileName := range selectProfilesAndGroups(c, flags, args) {
-		profileFlags := flagsForProfile(flags, profileName)
-		scheduler, schedules, schedulable, err := getScheduleJobs(c, profileFlags)
-		if err != nil {
-			return err
-		}
-		// it's all fine if this profile has no schedule
-		if len(schedules) == 0 {
-			continue
-		}
-		clog.Infof("%s %q:", cases.Title(language.English).String(schedulable.Kind()), profileName)
-		err = statusScheduleProfileOrGroup(scheduler, schedules, profileFlags)
-		if err != nil {
-			// display the error but keep going with the other profiles
-			clog.Error(err)
+		// all profiles and groups
+		for _, profileName := range selectProfilesAndGroups(c, flags, args) {
+			profileFlags := flagsForProfile(flags, profileName)
+			scheduler, schedules, schedulable, err := getScheduleJobs(c, profileFlags)
+			if err != nil {
+				return err
+			}
+			// it's all fine if this profile has no schedule
+			if len(schedules) == 0 {
+				continue
+			}
+			clog.Infof("%s %q:", cases.Title(language.English).String(schedulable.Kind()), profileName)
+			err = statusScheduleProfileOrGroup(scheduler, schedules, profileFlags)
+			if err != nil {
+				// display the error but keep going with the other profiles
+				clog.Error(err)
+			}
 		}
 	}
+	profileName := ctx.request.profile
+	if slices.Contains(args, "--all") {
+		// display all jobs of all profiles
+		profileName = ""
+	}
+	schedulerConfig := schedule.NewSchedulerConfig(ctx.global)
+	err := statusScheduledJobs(schedule.NewHandler(schedulerConfig), ctx.config.GetConfigFile(), profileName)
+	if err != nil {
+		return retryElevated(err, flags)
+	}
 	return nil
 }
 
@@ -159,8 +198,8 @@
 	return flags
 }
 
-func statusScheduleProfileOrGroup(scheduler schedule.SchedulerConfig, schedules []*config.Schedule, flags commandLineFlags) error {
-	err := statusJobs(schedule.NewHandler(scheduler), flags.name, schedules)
+func statusScheduleProfileOrGroup(schedulerConfig schedule.SchedulerConfig, schedules []*config.Schedule, flags commandLineFlags) error {
+	err := statusJobs(schedule.NewHandler(schedulerConfig), flags.name, schedules)
 	if err != nil {
 		return retryElevated(err, flags)
 	}

commands_schedule_test.go

@@ -37,40 +37,55 @@ profiles:
 
   profile-schedule-inline:
     backup:
-      schedule: daily
+      schedule: "*:00,30"
 
   profile-schedule-struct:
     backup:
       schedule:
-        at: daily
+        at: "*:00,30"
 
 `
 
-func TestCommandsIntegrationUsingCrontab(t *testing.T) {
+const scheduleIntegrationTestsCrontab = `
+### this content was generated by resticprofile, please leave this line intact ###
+00,30 * * * *	user	cd /workdir && /home/resticprofile --no-ansi --config config.yaml run-schedule backup@profile
+### end of resticprofile content, please leave this line intact ###
+`
+
+// TODO: finish implementation of this test
+func TestStatusCommandIntegrationUsingCrontab(t *testing.T) {
 	crontab := filepath.Join(t.TempDir(), "crontab")
+	err := os.WriteFile(crontab, []byte(scheduleIntegrationTestsCrontab), 0o600)
+	require.NoError(t, err)
+
 	cfg, err := config.Load(
 		bytes.NewBufferString(fmt.Sprintf(scheduleIntegrationTestsConfiguration, crontab)),
 		config.FormatYAML,
+		config.WithConfigFile("config.yaml"),
 	)
 	require.NoError(t, err)
 	require.NotNil(t, cfg)
 
+	global, err := cfg.GetGlobalSection()
+	require.NoError(t, err)
+	require.NotNil(t, global)
+
 	testCases := []struct {
 		name     string
 		contains string
 		err      error
 	}{
 		{
 			name: "",
-			err:  config.ErrNotFound,
+			err:  nil,
 		},
 		{
 			name:     "profile-schedule-inline",
-			contains: "Original form: daily",
+			contains: "Original form: *-*-* *:00,30:00",
 		},
 		{
 			name:     "profile-schedule-struct",
-			contains: "Original form: daily",
+			contains: "Original form: *-*-* *:00,30:00",
 		},
 	}
 
@@ -82,6 +97,7 @@ func TestCommandsIntegrationUsingCrontab(t *testing.T) {
 					flags: commandLineFlags{
 						name: tc.name,
 					},
+					global: global,
 				},
 			}
 			output := &bytes.Buffer{}