feat: per-task hooks

abstraction/executable.go

@@ -6,5 +6,7 @@ import "context"
 // Executable is an object that can be executed using a execute method and stopped using cancel method
 type Executable interface {
 	Execute(context.Context) error
+	SetDoneHooks([]Executable)
+	SetFailHooks([]Executable)
 	Cancel()
 }

config/compiler/compiler.go

@@ -35,13 +35,28 @@ func CompileScheduler(sh *config.JobScheduler, cr *cron.Cron, logger *logrus.Ent
 }
 
 func CompileTask(sh *config.Task, logger *logrus.Entry) abstraction.Executable {
+	var t abstraction.Executable
 	switch {
 	case sh.Command != "":
-		return task.NewCommand(sh, logger)
+		t = task.NewCommand(sh, logger)
 	case sh.Get != "":
-		return task.NewGet(sh, logger)
+		t = task.NewGet(sh, logger)
 	case sh.Post != "":
-		return task.NewPost(sh, logger)
+		t = task.NewPost(sh, logger)
+	default:
+		logger.Fatalln("cannot handle given task config", sh)
 	}
-	return nil
+
+	onDone := []abstraction.Executable{}
+	for _, d := range sh.OnDone {
+		onDone = append(onDone, CompileTask(&d, logger))
+	}
+	t.SetDoneHooks(onDone)
+	onFail := []abstraction.Executable{}
+	for _, d := range sh.OnFail {
+		onFail = append(onFail, CompileTask(&d, logger))
+	}
+	t.SetFailHooks(onFail)
+
+	return t
 }

config/config.go

@@ -57,5 +57,8 @@ type (
 		RetryDelay time.Duration `mapstructure:"retry-delay" json:"retry_delay,omitempty"`
 		Timeout    time.Duration `mapstructure:"timeout" json:"timeout,omitempty"`
 		Env        EnvVariables  `mapstructure:"env" json:"env,omitempty"`
+
+		OnDone []Task `mapstructure:"on-done" json:"on_done,omitempty"`
+		OnFail []Task `mapstructure:"on-fail" json:"on_fail,omitempty"`
 	}
 )

config/validators.go

@@ -103,6 +103,16 @@ func (t *Task) Validate(log *logrus.Entry) error {
 			t,
 		)
 	}
+	for _, task := range t.OnDone {
+		if err := task.Validate(log); err != nil {
+			return err
+		}
+	}
+	for _, task := range t.OnFail {
+		if err := task.Validate(log); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 

core/os_credential/unix_credential.go

@@ -52,6 +52,9 @@ func SetUser(log *logrus.Entry, proc *exec.Cmd, usr string, grp string) {
 }
 
 func lookupGID(grp string, log *logrus.Entry) (gid uint32, err error) {
+	if grp == "" {
+		return 0, nil
+	}
 	g, err := osUser.LookupGroup(grp)
 	if err != nil {
 		log.Panicf("cannot find group with name %s in the os: %s, you've changed os users during application runtime", grp, err)
@@ -64,6 +67,9 @@ func lookupGID(grp string, log *logrus.Entry) (gid uint32, err error) {
 }
 
 func lookupUIDAndGID(usr string, log *logrus.Entry) (uid uint32, gid uint32, err error) {
+	if usr == "" {
+		return 0, 0, nil
+	}
 	u, err := osUser.Lookup(usr)
 	if err != nil {
 		log.Panicf("cannot find user with name %s in the os: %s, you've changed os users during application runtime", usr, err)

core/task/command.go

@@ -33,6 +33,19 @@ type Command struct {
 	retries    uint
 	retryDelay time.Duration
 	timeout    time.Duration
+
+	doneHooks []abstraction.Executable
+	failHooks []abstraction.Executable
+}
+
+// SetDoneHooks implements abstraction.Executable.
+func (c *Command) SetDoneHooks(done []abstraction.Executable) {
+	c.doneHooks = done
+}
+
+// SetFailHooks implements abstraction.Executable.
+func (c *Command) SetFailHooks(fail []abstraction.Executable) {
+	c.failHooks = fail
 }
 
 // Cancel implements abstraction.Executable.
@@ -49,6 +62,7 @@ func (c *Command) Execute(ctx context.Context) (e error) {
 	log := c.log.WithField("retry", r)
 	if getRetry(ctx) > c.retries {
 		log.Warn("maximum retry reached")
+		runTasks(c.failHooks)
 		return fmt.Errorf("maximum retries reached")
 	}
 	if r != 0 {
@@ -83,6 +97,8 @@ func (c *Command) Execute(ctx context.Context) (e error) {
 		log.Warn("failed to execute the command ", e)
 		return c.Execute(ctx)
 	}
+
+	runTasks(c.doneHooks)
 	return
 }
 

core/task/get.go

@@ -21,6 +21,19 @@ type Get struct {
 	retries    uint
 	retryDelay time.Duration
 	timeout    time.Duration
+
+	doneHooks []abstraction.Executable
+	failHooks []abstraction.Executable
+}
+
+// SetDoneHooks implements abstraction.Executable.
+func (g *Get) SetDoneHooks(done []abstraction.Executable) {
+	g.doneHooks = done
+}
+
+// SetFailHooks implements abstraction.Executable.
+func (g *Get) SetFailHooks(fail []abstraction.Executable) {
+	g.failHooks = fail
 }
 
 // Cancel implements abstraction.Executable.
@@ -37,6 +50,7 @@ func (g *Get) Execute(ctx context.Context) (e error) {
 	log := g.log.WithField("retry", r)
 	if getRetry(ctx) > g.retries {
 		log.Warn("maximum retry reached")
+		runTasks(g.failHooks)
 		return fmt.Errorf("maximum retries reached")
 	}
 	if r != 0 {
@@ -80,6 +94,7 @@ func (g *Get) Execute(ctx context.Context) (e error) {
 		log.Warnln("request failed")
 		return g.Execute(ctx)
 	}
+	runTasks(g.doneHooks)
 	return
 }
 

core/task/helper.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 
+	"github.com/FMotalleb/crontab-go/abstraction"
 	"github.com/FMotalleb/crontab-go/ctxutils"
 )
 
@@ -49,3 +50,9 @@ func (r *ResponseWriter) Write(p []byte) (n int, err error) {
 func (r *ResponseWriter) String() string {
 	return string(r.buffer)
 }
+
+func runTasks(exec []abstraction.Executable) {
+	for _, t := range exec {
+		_ = t.Execute(context.Background())
+	}
+}

core/task/post.go

@@ -24,45 +24,59 @@ type Post struct {
 	retries    uint
 	retryDelay time.Duration
 	timeout    time.Duration
+
+	doneHooks []abstraction.Executable
+	failHooks []abstraction.Executable
+}
+
+// SetDoneHooks implements abstraction.Executable.
+func (p *Post) SetDoneHooks(done []abstraction.Executable) {
+	p.doneHooks = done
+}
+
+// SetFailHooks implements abstraction.Executable.
+func (p *Post) SetFailHooks(fail []abstraction.Executable) {
+	p.failHooks = fail
 }
 
 // Cancel implements abstraction.Executable.
-func (g *Post) Cancel() {
-	if g.cancel != nil {
-		g.log.Debugln("canceling get request")
-		g.cancel()
+func (p *Post) Cancel() {
+	if p.cancel != nil {
+		p.log.Debugln("canceling get request")
+		p.cancel()
 	}
 }
 
 // Execute implements abstraction.Executable.
-func (g *Post) Execute(ctx context.Context) (e error) {
+func (p *Post) Execute(ctx context.Context) (e error) {
 	r := getRetry(ctx)
-	log := g.log.WithField("retry", r)
-	if getRetry(ctx) > g.retries {
+	log := p.log.WithField("retry", r)
+	if getRetry(ctx) > p.retries {
 		log.Warn("maximum retry reached")
+		runTasks(p.failHooks)
 		return fmt.Errorf("maximum retries reached")
 	}
 	if r != 0 {
-		log.Debugln("waiting", g.retryDelay, "before executing the next iteration after last fail")
-		time.Sleep(g.retryDelay)
+		log.Debugln("waiting", p.retryDelay, "before executing the next iteration after last fail")
+		time.Sleep(p.retryDelay)
 	}
 	ctx = increaseRetry(ctx)
 	// ctx := context.Background()
 	var localCtx context.Context
-	if g.timeout != 0 {
-		localCtx, g.cancel = context.WithTimeout(ctx, g.timeout)
+	if p.timeout != 0 {
+		localCtx, p.cancel = context.WithTimeout(ctx, p.timeout)
 	} else {
-		localCtx, g.cancel = context.WithCancel(ctx)
+		localCtx, p.cancel = context.WithCancel(ctx)
 	}
 	client := &http.Client{}
-	data, _ := json.Marshal(g.data)
+	data, _ := json.Marshal(p.data)
 
-	req, e := http.NewRequestWithContext(localCtx, "POST", g.address, bytes.NewReader(data))
+	req, e := http.NewRequestWithContext(localCtx, "POST", p.address, bytes.NewReader(data))
 	log.Debugln("sending get http request")
 	if e != nil {
 		return
 	}
-	for key, val := range *g.headers {
+	for key, val := range *p.headers {
 		req.Header.Add(key, val)
 	}
 
@@ -82,8 +96,10 @@ func (g *Post) Execute(ctx context.Context) (e error) {
 
 	if e != nil || res.StatusCode >= 400 {
 		log.Warnln("request failed")
-		return g.Execute(ctx)
+		return p.Execute(ctx)
 	}
+
+	runTasks(p.doneHooks)
 	return
 }
 

schema.json

@@ -187,6 +187,20 @@
           ],
           "description": "A string that represents the URL to be sent using the POST method."
         },
+        "on-done": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Task"
+          },
+          "description": "List of optional hooks"
+        },
+        "on-fail": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Task"
+          },
+          "description": "Username that this command must run as. (root privilege needed)"
+        },
         "data": {
           "$ref": "#/definitions/Data",
           "description": "A Data object that defines the data to be sent with the request."