Start routine at wakeup end

model/alarm.go

@@ -40,37 +40,57 @@ func (h *Hour) UnmarshalJSON(src []byte) error {
 	return nil
 }
 
-func GetNextAlarm(cfg *config.Config, db *LevelDBStorage) (*time.Time, error) {
+func GetNextAlarm(cfg *config.Config, db *LevelDBStorage) (*time.Time, []Identifier, error) {
 	alarmsRepeated, err := GetAlarmsRepeated(db)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var closestAlarm *time.Time
+	var closestAlarmRoutines []Identifier
 	for _, alarm := range alarmsRepeated {
 		next := alarm.GetNextOccurence(cfg, db)
 		if next != nil && (closestAlarm == nil || closestAlarm.After(*next)) {
 			closestAlarm = next
+			closestAlarmRoutines = alarm.FollowingRoutines
 		}
 	}
 
 	alarmsSingle, err := GetAlarmsSingle(db)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	now := time.Now()
 	for _, alarm := range alarmsSingle {
 		if closestAlarm == nil || (closestAlarm.After(alarm.Time) && alarm.Time.After(now)) {
 			closestAlarm = &alarm.Time
+			closestAlarmRoutines = alarm.FollowingRoutines
 		}
 	}
 
-	return closestAlarm, nil
+	return closestAlarm, closestAlarmRoutines, nil
+}
+
+func GetNextException(cfg *config.Config, db *LevelDBStorage) (*time.Time, error) {
+	alarmsExceptions, err := GetAlarmExceptions(db)
+	if err != nil {
+		return nil, err
+	}
+
+	var closestException *time.Time
+	for _, except := range alarmsExceptions {
+		if except != nil && time.Time(*except.End).After(time.Now()) && (closestException == nil || closestException.After(time.Time(*except.Start))) {
+			tmp := time.Time(*except.Start)
+			closestException = &tmp
+		}
+	}
+
+	return closestException, nil
 }
 
 func DropNextAlarm(cfg *config.Config, db *LevelDBStorage) error {
-	timenext, err := GetNextAlarm(cfg, db)
+	timenext, _, err := GetNextAlarm(cfg, db)
 	if err != nil {
 		return err
 	}

model/routine.go

@@ -1,7 +1,9 @@
 package reveil
 
 import (
+	"bytes"
 	"crypto/sha512"
+	"fmt"
 	"io/fs"
 	"io/ioutil"
 	"log"
@@ -9,6 +11,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"time"
 
 	"git.nemunai.re/nemunaire/reveil/config"
 )
@@ -19,6 +22,10 @@ type RoutineStep struct {
 	Args   []string `json:"args,omitempty"`
 }
 
+func (s *RoutineStep) GetAction(cfg *config.Config) (*Action, error) {
+	return LoadAction(cfg, s.Action)
+}
+
 type Routine struct {
 	Id    Identifier    `json:"id"`
 	Name  string        `json:"name"`
@@ -72,6 +79,21 @@ func LoadRoutine(path string, cfg *config.Config) ([]RoutineStep, error) {
 	return steps, nil
 }
 
+func LoadRoutineFromId(id Identifier, cfg *config.Config) (*Routine, error) {
+	routines, err := LoadRoutines(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, routine := range routines {
+		if bytes.Equal(routine.Id, id) {
+			return routine, nil
+		}
+	}
+
+	return nil, fmt.Errorf("Unable to find routine %x", id)
+}
+
 func LoadRoutines(cfg *config.Config) (routines []*Routine, err error) {
 	err = filepath.Walk(cfg.RoutinesDir, func(path string, d fs.FileInfo, err error) error {
 		if d.IsDir() && path != cfg.RoutinesDir {
@@ -117,3 +139,28 @@ func (r *Routine) Rename(newName string) error {
 func (a *Routine) Remove() error {
 	return os.Remove(a.Path)
 }
+
+func (a *Routine) Launch(cfg *config.Config) error {
+	for _, s := range a.Steps {
+		act, err := s.GetAction(cfg)
+		if err != nil {
+			log.Printf("Unable to get action: %s: %s", s.Action, err.Error())
+			continue
+		}
+
+		time.Sleep(time.Duration(s.Delay) * time.Second)
+
+		cmd, err := act.Launch()
+		if err != nil {
+			log.Printf("Unable to launch the action %q: %s", s.Action, err.Error())
+			continue
+		}
+
+		err = cmd.Wait()
+		if err != nil {
+			log.Printf("Something goes wrong when waiting for the action %q's end: %s", s.Action, err.Error())
+		}
+	}
+
+	return nil
+}