wire up ignore-on-battery and locks

from schedule configuration to context

commands.go

@@ -608,18 +608,40 @@ func preRunSchedule(ctx *Context) error {
 		schedules := profile.Schedules()
 		for _, schedule := range schedules {
 			if schedule.CommandName == ctx.command {
-				clog.Debugf("preparing scheduled profile %q", ctx.request.schedule)
 				ctx.schedule = schedule
-				if len(schedule.Log) > 0 {
-					ctx.logTarget = schedule.Log
-				}
+				prepareScheduledProfile(ctx)
 				break
 			}
 		}
 	}
 	return nil
 }
 
+func prepareScheduledProfile(ctx *Context) {
+	clog.Debugf("preparing scheduled profile %q", ctx.request.schedule)
+	// log file
+	if len(ctx.schedule.Log) > 0 {
+		ctx.logTarget = ctx.schedule.Log
+	}
+	// battery
+	if ctx.schedule.IgnoreOnBatteryLessThan > 0 {
+		ctx.stopOnBattery = ctx.schedule.IgnoreOnBatteryLessThan
+	} else if ctx.schedule.IgnoreOnBattery {
+		ctx.stopOnBattery = 100
+	}
+	// lock
+	if ctx.schedule.GetLockWait() > 0 {
+		ctx.lockWait = ctx.schedule.LockWait
+	}
+	if ctx.schedule.GetLockMode() == config.ScheduleLockModeDefault {
+		if ctx.schedule.GetLockWait() > 0 {
+			ctx.lockWait = ctx.schedule.GetLockWait()
+		}
+	} else if ctx.schedule.GetLockMode() == config.ScheduleLockModeIgnore {
+		ctx.noLock = true
+	}
+}
+
 func runSchedule(_ io.Writer, cmdCtx commandContext) error {
 	err := startProfileOrGroup(&cmdCtx.Context)
 	if err != nil {

config/profile.go

@@ -480,9 +480,9 @@ func (o *OtherFlagsSection) SetOtherFlag(name string, value any) {
 // NewProfile instantiates a new blank profile
 func NewProfile(c *Config, name string) (p *Profile) {
 	p = &Profile{
-		Name:          name,
-		config:        c,
-		OtherSections: make(map[string]*GenericSection),
+		Name:                 name,
+		config:               c,
+		OtherSections:        make(map[string]*GenericSection),
 		PrometheusPushFormat: constants.DefaultPrometheusPushFormat,
 	}
 
@@ -849,16 +849,17 @@ func (p *Profile) Schedules() []*Schedule {
 				Profiles:                []string{},
 				Schedules:               s.Schedule,
 				Permission:              s.SchedulePermission,
-				Environment:             env.Values(),
 				Log:                     s.ScheduleLog,
+				Priority:                s.SchedulePriority,
 				LockMode:                s.ScheduleLockMode,
 				LockWait:                s.ScheduleLockWait,
-				Priority:                s.SchedulePriority,
+				Environment:             env.Values(),
 				IgnoreOnBattery:         s.ScheduleIgnoreOnBattery,
 				IgnoreOnBatteryLessThan: s.ScheduleIgnoreOnBatteryLessThan,
 				AfterNetworkOnline:      s.ScheduleAfterNetworkOnline,
 				SystemdDropInFiles:      p.SystemdDropInFiles,
 				ConfigFile:              p.config.configFile,
+				Flags:                   map[string]string{},
 			}
 
 			if len(config.Log) > 0 {

config/schedule.go

@@ -1,6 +1,22 @@
 package config
 
-import "time"
+import (
+	"time"
+
+	"github.com/creativeprojects/resticprofile/constants"
+)
+
+type ScheduleLockMode int8
+
+const (
+	// ScheduleLockModeDefault waits on acquiring a lock (local and repository) for up to ScheduleConfig lockWait (duration), before failing a schedule.
+	// With lockWait set to 0, ScheduleLockModeDefault and ScheduleLockModeFail behave the same.
+	ScheduleLockModeDefault = ScheduleLockMode(0)
+	// ScheduleLockModeFail fails immediately on a lock failure without waiting.
+	ScheduleLockModeFail = ScheduleLockMode(1)
+	// ScheduleLockModeIgnore does not create or fail on resticprofile locks. Repository locks cause an immediate failure.
+	ScheduleLockModeIgnore = ScheduleLockMode(2)
+)
 
 // Schedule is an intermediary object between the configuration (v1, v2+) and the ScheduleConfig object used by the scheduler.
 // The object is also used to display the scheduling configuration
@@ -31,6 +47,33 @@ func NewEmptySchedule(profileName, command string) *Schedule {
 	}
 }
 
+func (s *Schedule) GetLockMode() ScheduleLockMode {
+	switch s.LockMode {
+	case constants.ScheduleLockModeOptionFail:
+		return ScheduleLockModeFail
+	case constants.ScheduleLockModeOptionIgnore:
+		return ScheduleLockModeIgnore
+	default:
+		return ScheduleLockModeDefault
+	}
+}
+
+func (s *Schedule) GetLockWait() time.Duration {
+	if s.LockWait <= 2*time.Second {
+		return 0
+	}
+	return s.LockWait
+}
+
+func (s *Schedule) GetFlag(name string) (string, bool) {
+	if len(s.Flags) == 0 {
+		return "", false
+	}
+	// we can't do a direct return, technically the map returns only one value
+	value, found := s.Flags[name]
+	return value, found
+}
+
 func (s *Schedule) SetFlag(name, value string) {
 	if s.Flags == nil {
 		s.Flags = make(map[string]string)

config/schedule_test.go

@@ -0,0 +1,70 @@
+package config
+
+import (
+	"testing"
+	"time"
+
+	"github.com/creativeprojects/resticprofile/constants"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestScheduleProperties(t *testing.T) {
+	schedule := Schedule{
+		ProfileName:             "profile",
+		CommandName:             "command name",
+		Schedules:               []string{"1", "2", "3"},
+		Permission:              "admin",
+		Environment:             []string{"test=dev"},
+		Priority:                "",
+		LockMode:                "undefined",
+		LockWait:                1 * time.Minute,
+		ConfigFile:              "config",
+		Flags:                   map[string]string{},
+		IgnoreOnBattery:         false,
+		IgnoreOnBatteryLessThan: 0,
+	}
+
+	assert.Equal(t, "config", schedule.ConfigFile)
+	assert.Equal(t, "profile", schedule.ProfileName)
+	assert.Equal(t, "command name", schedule.CommandName)
+	assert.ElementsMatch(t, []string{"1", "2", "3"}, schedule.Schedules)
+	assert.Equal(t, "admin", schedule.Permission)
+	assert.Equal(t, []string{"test=dev"}, schedule.Environment)
+	assert.Equal(t, ScheduleLockModeDefault, schedule.GetLockMode())
+	assert.Equal(t, 60*time.Second, schedule.GetLockWait())
+}
+
+func TestLockModes(t *testing.T) {
+	tests := map[ScheduleLockMode]Schedule{
+		ScheduleLockModeDefault: {LockMode: ""},
+		ScheduleLockModeFail:    {LockMode: constants.ScheduleLockModeOptionFail},
+		ScheduleLockModeIgnore:  {LockMode: constants.ScheduleLockModeOptionIgnore},
+	}
+	for mode, config := range tests {
+		assert.Equal(t, mode, config.GetLockMode())
+	}
+}
+
+func TestLockWait(t *testing.T) {
+	tests := map[time.Duration]Schedule{
+		0:               {LockWait: 2 * time.Second}, // min lock wait is is >2 seconds
+		3 * time.Second: {LockWait: 3 * time.Second},
+		120 * time.Hour: {LockWait: 120 * time.Hour},
+	}
+	for mode, config := range tests {
+		assert.Equal(t, mode, config.GetLockWait())
+	}
+}
+
+func TestScheduleFlags(t *testing.T) {
+	schedule := &Schedule{}
+
+	flag, found := schedule.GetFlag("unit")
+	assert.Empty(t, flag)
+	assert.False(t, found)
+
+	schedule.SetFlag("unit", "test")
+	flag, found = schedule.GetFlag("unit")
+	assert.Equal(t, "test", flag)
+	assert.True(t, found)
+}

context.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"os"
+	"time"
 
 	"github.com/creativeprojects/resticprofile/config"
 )
@@ -18,16 +19,19 @@ type Request struct {
 // Not everything is always available,
 // but any information should be added to the context as soon as known.
 type Context struct {
-	request   Request
-	flags     commandLineFlags
-	global    *config.Global
-	config    *config.Config
-	binary    string // where to find the restic binary
-	command   string // which restic command to use
-	profile   *config.Profile
-	schedule  *config.Schedule // when profile is running with run-schedule command
-	sigChan   chan os.Signal   // termination request
-	logTarget string           // where to send the log output
+	request       Request
+	flags         commandLineFlags
+	global        *config.Global
+	config        *config.Config
+	binary        string // where to find the restic binary
+	command       string // which restic command to use
+	profile       *config.Profile
+	schedule      *config.Schedule // when profile is running with run-schedule command
+	sigChan       chan os.Signal   // termination request
+	logTarget     string           // where to send the log output
+	stopOnBattery int              // stop if running on battery
+	noLock        bool             // skip profile lock file
+	lockWait      time.Duration    // wait up to duration to acquire a lock
 }
 
 // WithConfig sets the configuration and global values. A new copy of the context is returned.

main.go

@@ -177,7 +177,7 @@ func main() {
 	}
 
 	// check if we're running on battery
-	if shouldStopOnBattery(flags.ignoreOnBattery) {
+	if shouldStopOnBattery(ctx.stopOnBattery) {
 		exitCode = 3
 		return
 	}
@@ -332,6 +332,17 @@ func loadContext(flags commandLineFlags, silent bool) (*Context, error) {
 	if flags.log != "" {
 		ctx.logTarget = flags.log
 	}
+	// same for battery configuration
+	if flags.ignoreOnBattery > 0 {
+		ctx.stopOnBattery = flags.ignoreOnBattery
+	}
+	// also lock configuration
+	if flags.noLock {
+		ctx.noLock = true
+	}
+	if flags.lockWait > 0 {
+		ctx.lockWait = flags.lockWait
+	}
 	return ctx, nil
 }
 
@@ -546,7 +557,7 @@ func runProfile(ctx *Context) error {
 
 	if ctx.request.schedule != "" {
 		// this is a scheduled profile
-		prepareScheduledProfile(ctx, profile)
+		loadScheduledProfile(ctx)
 	}
 
 	// Catch CTR-C keypress, or other signal sent by a service manager (systemd)
@@ -558,10 +569,10 @@ func runProfile(ctx *Context) error {
 	ctx.sigChan = sigChan
 	wrapper := newResticWrapper(ctx)
 
-	if ctx.flags.noLock {
+	if ctx.noLock {
 		wrapper.ignoreLock()
-	} else if ctx.flags.lockWait > 0 {
-		wrapper.maxWaitOnLock(ctx.flags.lockWait)
+	} else if ctx.lockWait > 0 {
+		wrapper.maxWaitOnLock(ctx.lockWait)
 	}
 
 	// add progress receivers if necessary
@@ -579,13 +590,11 @@ func runProfile(ctx *Context) error {
 	return nil
 }
 
-func prepareScheduledProfile(ctx *Context, profile *config.Profile) error {
+func loadScheduledProfile(ctx *Context) error {
 	// get the list of all scheduled commands to find the current command
-	schedules := profile.Schedules()
+	schedules := ctx.profile.Schedules()
 	for _, schedule := range schedules {
 		if schedule.CommandName == ctx.command {
-			// TODO: do we still need to do anything here?
-			// clog.Debugf("preparing scheduled profile %q", ctx.request.schedule)
 			ctx.schedule = schedule
 			break
 		}

schedule/config.go

@@ -2,23 +2,10 @@ package schedule
 
 import (
 	"strings"
-	"time"
 
 	"github.com/creativeprojects/resticprofile/constants"
 )
 
-type ScheduleLockMode int8
-
-const (
-	// ScheduleLockModeDefault waits on acquiring a lock (local and repository) for up to ScheduleConfig lockWait (duration), before failing a schedule.
-	// With lockWait set to 0, ScheduleLockModeDefault and ScheduleLockModeFail behave the same.
-	ScheduleLockModeDefault = ScheduleLockMode(0)
-	// ScheduleLockModeFail fails immediately on a lock failure without waiting.
-	ScheduleLockModeFail = ScheduleLockMode(1)
-	// ScheduleLockModeIgnore does not create or fail on resticprofile locks. Repository locks cause an immediate failure.
-	ScheduleLockModeIgnore = ScheduleLockMode(2)
-)
-
 // Config contains all information to schedule a profile command
 type Config struct {
 	ProfileName             string
@@ -32,8 +19,6 @@ type Config struct {
 	JobDescription          string
 	TimerDescription        string
 	Priority                string // Priority is either "background" or "standard"
-	LockMode                string
-	LockWait                time.Duration
 	ConfigFile              string
 	Flags                   map[string]string // flags added to the command line
 	IgnoreOnBattery         bool
@@ -68,24 +53,6 @@ func (s *Config) GetPriority() string {
 	return s.Priority
 }
 
-func (s *Config) GetLockMode() ScheduleLockMode {
-	switch s.LockMode {
-	case constants.ScheduleLockModeOptionFail:
-		return ScheduleLockModeFail
-	case constants.ScheduleLockModeOptionIgnore:
-		return ScheduleLockModeIgnore
-	default:
-		return ScheduleLockModeDefault
-	}
-}
-
-func (s *Config) GetLockWait() time.Duration {
-	if s.LockWait <= 2*time.Second {
-		return 0
-	}
-	return s.LockWait
-}
-
 func (s *Config) GetFlag(name string) (string, bool) {
 	if len(s.Flags) == 0 {
 		return "", false