Cronspec and other parameters can be specified as comments in the file

Added support for Timezone & Timeout

Author: timjwright

Readme.md

@@ -11,6 +11,16 @@ include environment variables.
 The `.godoit` filename contains the cronspec description of when to run
 the job and the scheduled job name.
 
+The `.godoit` file can also include job parameters as comment in the script (including specifying the cronspec
+as comments of the form `#:godoit <param> <value>`
+e.g.
+
+Comment            | Detail
+-------------------|-----------
+`#:godoit cronspec ...`| The cron spec (see https://godoc.org/github.com/robfig/cron) 
+`#:godoit timeout ...` | Time as a duration after which SIGTERM is sent e.g. `1h30m`, `15s`
+`#:godoit timezone ...`| The timezone for the job e.g. `Europe/London`
+
 Godoit jobs are executed by a wrapper script which allows the deployment
 to handle specific concerns such as job logging and alerting of failures.
 

execution.go

@@ -5,23 +5,47 @@ import (
 	"os/exec"
 	"log"
 	"io"
+	"time"
+	"syscall"
 )
 
-type JobExecutor func(jobName, jobPath string)
+type JobExecutor func(jobName, jobPath string, timeout time.Duration)
 
 func JobExecutorFromScript(jobExecutorScript string, output io.Writer) JobExecutor {
 	if len(jobExecutorScript) == 0 {
-		log.Fatalf("Job executor is not defined")
+		log.Fatal("Job executor is not defined")
 	}
 	jobExecutorScript = os.ExpandEnv(jobExecutorScript)
-	return func(jobName, jobPath string) {
+	return func(jobName, jobPath string, timeout time.Duration) {
 		cmd := exec.Command(jobExecutorScript, jobName, jobPath)
-		log.Printf("Running comand line: %s '%s' '%s'", jobExecutorScript, jobName, jobPath)
+		log.Printf("Running comand line: %s '%s' '%s' Timeout: %s", jobExecutorScript, jobName, jobPath, timeout)
 		cmd.Stdout = output
 		cmd.Stderr = output
-		err := cmd.Run()
+		err := runWithTimout(cmd, timeout)
 		if err != nil {
 			log.Printf("ERROR: Failed to execute executor script %s %s %s", jobExecutorScript, jobName, jobPath)
 		}
 	}
 }
+
+func runWithTimout(cmd *exec.Cmd, timeout time.Duration) error {
+	if timeout.Seconds() <= 0 {
+		return cmd.Run()
+	} else {
+		done := make(chan error, 1)
+		go func() {
+			cmd.Start()
+			done <- cmd.Wait()
+		}()
+		select {
+		case <-time.After(timeout):
+			if err := cmd.Process.Signal(syscall.SIGTERM); err != nil {
+				log.Printf("ERROR: Failed to terminate job %s error: %s", cmd.Path, err)
+			}
+			log.Printf("Job %s timed out", cmd.Path)
+			return nil
+		case err := <-done:
+			return err
+		}
+	}
+}

execution_test.go

@@ -4,11 +4,20 @@ import (
 	"testing"
 	"github.com/stretchr/testify/assert"
 	"os"
+	"time"
 )
 
 func TestExecutor(t *testing.T) {
 	// TODO...
 	jobExec := JobExecutorFromScript("./test_wrapper.sh", os.Stdout)
-	jobExec("my job","/path/to/@ 1 @ @ @ @ my job.godoit")
+	jobExec("my job","/path/to/@ 1 @ @ @ @ my job.godoit", noTimeout)
 	assert.True(t, true, "Failed to parse job")
 }
+
+func TestExecutorWithTimeout(t *testing.T) {
+	jobExec := JobExecutorFromScript("./test_wrapper_sleep.sh", os.Stdout)
+	start := time.Now()
+	jobExec("my job","/path/to/@ 1 @ @ @ @ my job.godoit", time.Second * 3)
+	duration := time.Since(start)
+	assert.True(t, duration.Seconds() < 4.0, "Job took to long")
+}

job.go

@@ -1,29 +1,135 @@
 package main
 
 import (
+	"path"
 	"path/filepath"
 	"strings"
 	"regexp"
+	"time"
+	"os"
+	"bufio"
+	"log"
+	"github.com/robfig/cron"
+	"fmt"
 )
 
 type Job struct {
 	Filepath string
 	Spec string
+	Timezone *time.Location
 	Name string
+	Timeout time.Duration
+	Enabled bool
+	Errors []string
+	UpdateTime time.Time
 }
 
 var cronSpecRegex,_ = regexp.Compile(`\s*($|#|\w+\s*=|(x|\*|(?:[0-5]?\d)(?:(?:-|%|\,)(?:[0-5]?\d))?(?:,(?:[0-5]?\d)(?:(?:-|%|\,)(?:[0-5]?\d))?)*)\s+(x|\*|(?:[0-5]?\d)(?:(?:-|%|\,)(?:[0-5]?\d))?(?:,(?:[0-5]?\d)(?:(?:-|%|\,)(?:[0-5]?\d))?)*)\s+(x|\*|(?:[01]?\d|2[0-3])(?:(?:-|%|\,)(?:[01]?\d|2[0-3]))?(?:,(?:[01]?\d|2[0-3])(?:(?:-|%|\,)(?:[01]?\d|2[0-3]))?)*)\s+(x|\*|(?:0?[1-9]|[12]\d|3[01])(?:(?:-|%|\,)(?:0?[1-9]|[12]\d|3[01]))?(?:,(?:0?[1-9]|[12]\d|3[01])(?:(?:-|%|\,)(?:0?[1-9]|[12]\d|3[01]))?)*)\s+(x|\*|(?:[1-9]|1[012])(?:(?:-|%|\,)(?:[1-9]|1[012]))?(?:L|W)?(?:,(?:[1-9]|1[012])(?:(?:-|%|\,)(?:[1-9]|1[012]))?(?:L|W)?)*|x|\*|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)(?:(?:-)(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC))?(?:,(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)(?:(?:-)(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC))?)*)\s+(x|\*|(?:[0-6])(?:(?:-|%|\,|#)(?:[0-6]))?(?:L)?(?:,(?:[0-6])(?:(?:-|%|\,|#)(?:[0-6]))?(?:L)?)*|x|\*|(?:MON|TUE|WED|THU|FRI|SAT|SUN)(?:(?:-)(?:MON|TUE|WED|THU|FRI|SAT|SUN))?(?:,(?:MON|TUE|WED|THU|FRI|SAT|SUN)(?:(?:-)(?:MON|TUE|WED|THU|FRI|SAT|SUN))?)*)(|\s)+(x|\*|(?:|\d{4})(?:(?:-|%|\,)(?:|\d{4}))?(?:,(?:|\d{4})(?:(?:-|%|\,)(?:|\d{4}))?)*)) (.*)\.godoit`)
+var noTimeout = time.Second * 0
+var GodoitFileSuffix = ".godoit"
+var godoitCommentPrefix = "#:godoit "
+
+
+func ParseJobFile(directory, filename string) *Job {
+	jobPath := path.Join(directory, filename)
+	var cronspec string
+	var name string
+	enabled :=
+		!strings.HasPrefix(filename, "--") &&
+		!strings.HasPrefix(filename, "#")
 
-func ParseJobFile(path, filename string) *Job {
-	// Return commented out files
-	if strings.HasPrefix(filename, "--") {
-		return nil
-	}
 	if result := cronSpecRegex.FindStringSubmatch(filename); result != nil {
-		cronspec := strings.Replace(result[1], "x", "*", -1)
+		cronspec = strings.Replace(result[1], "x", "*", -1)
 		cronspec = strings.Replace(cronspec, "%", "/", -1)
-		return &Job{filepath.Join(path, filename), cronspec, strings.TrimSpace(result[10])}
+		name = strings.TrimSpace(result[10])
+	} else if strings.HasSuffix(filename, GodoitFileSuffix) {
+		name = strings.TrimSuffix(filename, GodoitFileSuffix)
 	} else {
 		return nil
 	}
+
+	cronspec, timeout, timezone, errors, updateTime := parseJobParameters(jobPath, cronspec)
+
+	if cronspec == "" {
+		errors = append(errors, "Missing cronspec")
+	}
+
+	if len(errors) > 0 {
+		enabled = false
+		log.Printf("Errors parsing job %s: %v", jobPath, errors)
+	}
+
+	return &Job{
+		filepath.Join(directory, filename),
+		cronspec,
+		timezone,
+		name,
+		timeout,
+		enabled,
+		errors,
+		updateTime}
+}
+
+func parseJobParameters(jobPath, cronspec string) (string, time.Duration, *time.Location, []string, time.Time) {
+	timeout := 0 * time.Second
+	timezone := time.UTC
+	var updateTime time.Time
+	errors := make ([]string,0,10)
+
+	if file, err := os.Open(jobPath); err == nil {
+		defer file.Close()
+		if info, err := file.Stat() ; err == nil {
+			updateTime = info.ModTime()
+		}
+
+		// create a new scanner and read the file line by line
+		scanner := bufio.NewScanner(file)
+		i := 0
+		for scanner.Scan() {
+			// Only scan start of file for params...
+			i++
+			if i > 10 {
+				break
+			}
+
+			line := scanner.Text()
+			if strings.HasPrefix(line, godoitCommentPrefix) {
+				line = strings.TrimPrefix(line, godoitCommentPrefix)
+				line = strings.TrimSpace(line)
+				parts := strings.SplitN(line," ",2)
+				if len(parts) == 2 {
+					param := parts[0]
+					value := parts[1]
+					if param == "cronspec" {
+						if cronspec != "" {
+							errors = append(errors, "Cronspec in filename and as comment")
+						}
+						if _, err := cron.Parse(value); err == nil {
+							cronspec = value
+						} else {
+							errors = append(errors, fmt.Sprintf("Invalid cronspec: '%s'", value))
+						}
+					} else if param == "timeout" {
+						if d, err := time.ParseDuration(value); err == nil {
+							timeout = d
+						} else {
+							errors = append(errors, fmt.Sprintf("Invalid timeout: '%s'", value))
+						}
+					} else if param == "timezone" {
+						if l, err := time.LoadLocation(value); err == nil {
+							timezone = l
+						} else {
+							errors = append(errors, fmt.Sprintf("Invalid timezone: '%s'", value))
+						}
+					}
+
+				} else {
+					errors = append(errors, fmt.Sprintf("Invalid parameter '%s'", line))
+				}
+			}
+		}
+	} else {
+		errors = append(errors, "Unable to open file to parse parameters")
+	}
+	return cronspec, timeout, timezone, errors, updateTime
 }