1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

package main

?

import (

  "fmt"

  "github.com/gin-gonic/gin"

  "os"

)

?

func main() {

  // api engine

  app := gin.New()

?

  // api routes

  app.GET("/jobs", GetJobs)

  app.POST("/jobs", AddJob)

  app.DELETE("/jobs", DeleteJob)

?

  // run api on port 9092

  if err := app.Run(":9092"); err != nil {

    _, err = fmt.Fprintln(os.Stderr, err)

    os.Exit(1)

  }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

package main

?

import "github.com/gin-gonic/gin"

?

func GetJobs(c *gin.Context) {

  // TODO: implementation here

}

?

func AddJob(c *gin.Context) {

  // TODO: implementation here

}

?

func DeleteJob(c *gin.Context) {

  // TODO: implementation here

}

1

2

3

4

5

6

7

8

9

10

11

package main

?

import "github.com/robfig/cron"

?

func init() {

  // start to run

  Cron.Run()

}

?

// Cron create a new cron.Cron instance

var Cron = cron.New()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

package main

?

import (

  "github.com/gin-gonic/gin"

  "github.com/robfig/cron/v3"

  "net/http"

  "strconv"

)

?

func GetJobs(c *gin.Context) {

  // return a list of cron job entries

  var results []map[string]interface{}

  for _, e := range Cron.Entries() {

    results = append(results, map[string]interface{}{

      "id":   e.ID,

      "next": e.Next,

    })

  }

  c.JSON(http.StatusOK, Cron.Entries())

}

?

func AddJob(c *gin.Context) {

  // post JSON payload

  var payload struct {

    Cron string `json:"cron"`

    Exec string `json:"exec"`

  }

  if err := c.ShouldBindJSON(&payload); err != nil {

    c.AbortWithStatus(http.StatusBadRequest)

    return

  }

?

  // add cron job

  eid, err := Cron.AddFunc(payload.Cron, func() {

    // TODO: implementation here

  })

  if err != nil {

    c.AbortWithStatusJSON(http.StatusInternalServerError, map[string]interface{}{

      "error": err.Error(),

    })

    return

  }

?

  c.AbortWithStatusJSON(http.StatusOK, map[string]interface{}{

    "id": eid,

  })

}

?

func DeleteJob(c *gin.Context) {

  // cron job entry id

  id := c.Param("id")

  eid, err := strconv.Atoi(id)

  if err != nil {

    c.AbortWithStatus(http.StatusBadRequest)

    return

  }

?

  // remove cron job

  Cron.Remove(cron.EntryID(eid))

?

  c.AbortWithStatus(http.StatusOK)

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

package main

?

import (

  "fmt"

  "os"

  "os/exec"

  "strings"

)

?

func ExecuteTask(execCmd string) {

  // execute command string parts, delimited by space

  execParts := strings.Split(execCmd, " ")

?

  // executable name

  execName := execParts[0]

?

  // execute command parameters

  execParams := strings.Join(execParts[1:], " ")

?

  // execute command instance

  cmd := exec.Command(execName, execParams)

?

  // run execute command instance

  if err := cmd.Run(); err != nil {

    _, err = fmt.Fprintln(os.Stderr, err)

    fmt.Println(err.Error())

  }

}

1

2

3

4

5

6

...

  // add cron job

  eid, _ := Cron.AddFunc(payload.Cron, func() {

    ExecuteTask(payload.Exec)

  })

...

1

2

3

4

5

6

7

8

9

10

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.

 - using env:   export GIN_MODE=release

 - using code:  gin.SetMode(gin.ReleaseMode)

?

[GIN-debug] GET    /jobs                     --> main.GetJobs (1 handlers)

[GIN-debug] POST   /jobs                     --> main.AddJob (1 handlers)

[GIN-debug] DELETE /jobs/:id                 --> main.DeleteJob (1 handlers)

[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.

Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.

[GIN-debug] Listening and serving HTTP on :9092