Start routine at wakeup end

api/alarm.go

@@ -20,7 +20,7 @@ func declareAlarmRoutes(cfg *config.Config, router *gin.RouterGroup) {
 
 	router.POST("/alarm/run", func(c *gin.Context) {
 		if player.CommonPlayer == nil {
-			err := player.WakeUp(cfg)
+			err := player.WakeUp(cfg, nil)
 			if err != nil {
 				c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()})
 				return

api/alarms.go

@@ -13,7 +13,7 @@ import (
 
 func declareAlarmsRoutes(cfg *config.Config, db *reveil.LevelDBStorage, resetTimer func(), router *gin.RouterGroup) {
 	router.GET("/alarms/next", func(c *gin.Context) {
-		alarm, err := reveil.GetNextAlarm(cfg, db)
+		alarm, _, err := reveil.GetNextAlarm(cfg, db)
 		if err != nil {
 			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": err.Error()})
 			return

app.go

@@ -80,11 +80,11 @@ func (app *App) ResetTimer() {
 		app.nextAlarm = nil
 	}
 
-	if na, err := reveil.GetNextAlarm(app.cfg, app.db); err == nil && na != nil {
+	if na, routines, err := reveil.GetNextAlarm(app.cfg, app.db); err == nil && na != nil {
 		app.nextAlarm = time.AfterFunc(time.Until(*na), func() {
 			app.nextAlarm = nil
 			reveil.RemoveOldAlarmsSingle(app.db)
-			err := player.WakeUp(app.cfg)
+			err := player.WakeUp(app.cfg, routines)
 			if err != nil {
 				log.Println(err.Error())
 				return

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
+}

player/player.go

@@ -31,6 +31,8 @@ type Player struct {
 	claironTime time.Duration
 	claironFile string
 
+	endRoutines []*reveil.Routine
+
 	ntick            int64
 	hasClaironed     bool
 	hasSpokeWeather  bool
@@ -41,7 +43,7 @@ type Player struct {
 	playedItem       int
 }
 
-func WakeUp(cfg *config.Config) (err error) {
+func WakeUp(cfg *config.Config, routine []reveil.Identifier) (err error) {
 	if CommonPlayer != nil {
 		return fmt.Errorf("Unable to start the player: a player is already running")
 	}
@@ -50,16 +52,16 @@ func WakeUp(cfg *config.Config) (err error) {
 	seed -= seed % 172800
 	rand.Seed(seed)
 
-	CommonPlayer, err = NewPlayer(cfg)
+	CommonPlayer, err = NewPlayer(cfg, routine)
 	if err != nil {
 		return err
 	}
 
-	go CommonPlayer.WakeUp()
+	go CommonPlayer.WakeUp(cfg)
 	return nil
 }
 
-func NewPlayer(cfg *config.Config) (*Player, error) {
+func NewPlayer(cfg *config.Config, routines []reveil.Identifier) (*Player, error) {
 	// Load our settings
 	settings, err := reveil.ReadSettings(cfg.SettingsFile)
 	if err != nil {
@@ -83,6 +85,17 @@ func NewPlayer(cfg *config.Config) (*Player, error) {
 		reverseOrder:  int(time.Now().Unix()/86400)%2 == 0,
 	}
 
+	// Load routines
+	for _, routine := range routines {
+		r, err := reveil.LoadRoutineFromId(routine, cfg)
+		if err != nil {
+			log.Printf("Unable to load routine %x: %s", routine, err.Error())
+			continue
+		}
+
+		p.endRoutines = append(p.endRoutines, r)
+	}
+
 	// Load our track list
 	tracks, err := reveil.LoadTracks(cfg)
 	if err != nil {
@@ -136,7 +149,7 @@ func (p *Player) playFile(filepath string) (err error) {
 	return
 }
 
-func (p *Player) WakeUp() {
+func (p *Player) WakeUp(cfg *config.Config) {
 	log.Println("Playlist in use:", strings.Join(p.Playlist, " ; "))
 
 	// Prepare sound player
@@ -241,6 +254,11 @@ loopcalm:
 
 		CommonPlayer = nil
 	}
+
+	// TODO: Start Routine if any
+	for _, r := range p.endRoutines {
+		go r.Launch(cfg)
+	}
 }
 
 func (p *Player) NextTrack() {

ui/nojs.go

@@ -24,7 +24,7 @@ func DeclareNoJSRoutes(router *gin.Engine, cfg *config.Config, db *reveil.LevelD
 	router.SetHTMLTemplate(templ)
 
 	router.GET("/nojs.html", func(c *gin.Context) {
-		alarm, err := reveil.GetNextAlarm(cfg, db)
+		alarm, _, err := reveil.GetNextAlarm(cfg, db)
 		if err != nil {
 			c.HTML(http.StatusInternalServerError, "error.tmpl", gin.H{"errmsg": err.Error()})
 			return
@@ -109,7 +109,7 @@ func DeclareNoJSRoutes(router *gin.Engine, cfg *config.Config, db *reveil.LevelD
 
 		case "start":
 			if player.CommonPlayer == nil {
-				err := player.WakeUp(cfg)
+				err := player.WakeUp(cfg, nil)
 				if err != nil {
 					c.HTML(http.StatusInternalServerError, "error.tmpl", gin.H{"errmsg": err.Error()})
 					return