实战 Go：怎样快速实现一个极简任务调度系统

引子

使命调度（Task Scheduling）是许多软件体系中的重要组成部分，字面上的意思是依照必定要求分配运转一些一般时间较长的脚本或程序。在爬虫办理平台 Crawlab 中，使命调度是其间的中心模块，相信不少朋友会猎奇怎么编写一个使命调度体系。本篇文章会教读者用 Go 言语编写一个非常简略的使命调度体系。

思路

咱们首要理清一下思路，开发最小化使命调度器需求什么。

• 交互界面（API）
• 守时使命（Cron）
• 使命履行（Execute Tasks）

整个流程如下：

咱们经过 API 创立守时使命，履行器依据守时使命规范守时履行脚本。

实战

交互界面

首要咱们来搭个架子。在项目目录下创立一个 main.go 文件，并输入以下内容。其间 gin 是非常盛行的 Go 言语 API 引擎。

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)
  }
}
​

然后增加 api.go 文件，输入以下内容，留意，这儿没有任何代码完成，只是加入了占位区域。

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

守时使命

然后是使命调度的中心，守时使命。这儿咱们使用 robfig/cron，Go 言语比较盛行的守时使命库。

现在创立 cron.go 文件，输入以下内容。其间 Cron 便是 robfig/cron 库中的 Cron 类生成的实例。

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()
​

现在创立好了主要守时使命实例，就可以将中心逻辑增加在刚才的 API 占位区域了。

同样是 api.go ，将中心代码增加进来。

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)
}
​

在这段代码中，咱们完成了大部分逻辑，只在 AddJob 的 Cron.AddFunc 中第二个参数里，剩余最后一部分履行使命的代码。下面将来完成一下。

使命履行

现在需求增加使命履行的代码逻辑，咱们创立 exec.go 文件，输入以下内容。这儿咱们用到了 Go 言语内置的 shell 运转办理库 os/exec，可以履行任何 shell 指令。

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())
  }
}
​

好了，现在咱们将这部分履行代码逻辑放到之前的占位区域中。

...
  // add cron job
  eid, _ := Cron.AddFunc(payload.Cron, func() {
    ExecuteTask(payload.Exec)
  })
...

代码效果

OK，大功告成！现在咱们可以试试运转这个极简的使命调度器了。

在指令行中敲入 go run .，API 引擎就发动起来了。

[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
​

现在翻开另一个指令行窗口，输入 curl -X POST -d '{"cron":"* * * * *","exec":"touch /tmp/hello.txt"}' http://localhost:9092/jobs，会得到如下返回成果。表明已经生成了相应的守时使命，使命 ID 为 1，每分钟跑一次，会更新一次 /tmp/hello.txt。

{"id":1}

在这个指令行窗口中输入 curl http://localhost:9092/jobs。

[{"id":1,"next":"2022-10-03T12:46:00+08:00"}]

这表明下一次履行是 1 分钟之后。

等候一分钟，履行 ls -l /tmp/hello.txt，得到如下成果。

-rw-r--r--  1 marvzhang  wheel   0B Oct  3 12:46 /tmp/hello.txt

也便是说，履行成功了，大功告成！

总结

本篇文章经过将 Go 言语几个库简略组合，就开发出了一个极简的使命调度体系。所用到的中心库:

• gin
• robfig/cron
• os/exec

整个代码示例库房在 GitHub 上: github.com/tikazyq/cod…

社区

如果您对笔者的文章感兴趣，可以加笔者微信 tikazyq1 并注明 “码之道”，笔者会将你拉入 “码之道” 交流群。

本篇文章英文版同步发布在 dev.to，技能共享无国界，欢迎大佬们点拨。