Task

Tasks work very similarly to cron jobs. Tasks are used to run a job outside the normal request/response cycle. These can be adhoc or scheduled to run regularly. Examples include: Reporting memory and goroutine status, periodically triggering GC or cleaning up log files at fixed intervals.

Creating a new Task

To initialize a task implement :

tk1 := task.NewTask("tk1", "0 12 * * * *", func(ctx context.Context) error {
    fmt.Println("tk1")
    return nil
})

The NewTask signature:

NewTask(tname string, spec string, f TaskFunc) *Task    

• tname: Task name
• spec: Task format. See below for details.
• f: The function which will be run as the task.

To implement this task, add it to the global task list and start it.

task.AddTask("tk1", tk1)
task.StartTask()
defer task.StopTask()

Testing the TaskFunc

Use the code below to test if the TaskFunc is working correctly.

err := tk.Run()
if err != nil {
    t.Fatal(err)
}

spec in detail

spec specifies when the new Task will be run. Its format is the same as that of traditional crontab:

// The first 6 parts are:
//       second: 0-59
//       minute: 0-59
//       hour: 1-23
//       day: 1-31
//       month: 1-12
//       weekdays: 0-6（0 is Sunday）
// Some special sign:
//       *: any time
//       ,: separator. E.g.: 2,4 in the third part means run at 2 and 4 o'clock
//　　    －: range. E.g.: 1-5 in the third part means run between 1 and 5 o'clock
//       /n : run once every n time. E.g.: */1 in the third part means run once every an hour. Same as 1-23/1
/////////////////////////////////////////////////////////
//    0/30 * * * * *                        run every 30 seconds
//    0 43 21 * * *                         run at 21:43
//    0 15 05 * * *                         run at 05:15
//    0 0 17 * * *                          run at 17:00
//    0 0 17 * * 1                          run at 17:00 of every Monday
//    0 0,10 17 * * 0,2,3                   run at 17:00 and 17:10 of every Sunday, Tuesday and Wednesday
//    0 0-10 17 1 * *                       run once every minute from 17:00 to 7:10 on 1st day of every month
//    0 0 0 1,15 * 1                        run at 0:00 on 1st and 15th of each month and every Monday
//    0 42 4 1 * *                          run at 4:42 on 1st of every month
//    0 0 21 * * 1-6                        run at 21:00 from Monday to Saturday
//    0 0,10,20,30,40,50 * * * *            run every 10 minutes
//    0 */10 * * * *                        run every 10 minutes
//    0 * 1 * * *                           run every one minute from 1:00 to 1:59
//    0 0 1 * * *                           run at 1:00
//    0 0 */1 * * *                         run at :00 of every hour
//    0 0 * * * *                           run at :00 of every hour
//    0 2 8-20/3 * * *                      run at 8:02, 11:02, 14:02, 17:02 and 20:02
//    0 30 5 1,15 * *                       run at 5:30 of 1st and 15th of every month

Debug module (Already moved to utils module)

We always use print for debugging. But the default output is not good enough for debugging. Beego provides this debug module

• Display() print result to console
• GetDisplayString() return the string

It print key/value pairs. The following code:

Display("v1", 1, "v2", 2, "v3", 3)

will output:

2013/12/16 23:48:41 [Debug] at TestPrint() [/Users/astaxie/github/beego/task/debug_test.go:13]
[Variables]
v1 = 1
v2 = 2
v3 = 3    

For pointer type:

type mytype struct {
    next *mytype
    prev *mytype
}    
var v1 = new(mytype)
var v2 = new(mytype)
v1.prev = nil
v1.next = v2
v2.prev = v1
v2.next = nil
Display("v1", v1, "v2", v2)

The output result

2013/12/16 23:48:41 [Debug] at TestPrintPoint() [/Users/astaxie/github/beego/task/debug_test.go:26]
[Variables]
v1 = &task.mytype{
    next: &task.mytype{
        next: nil,
        prev: 0x210335420,
    },
    prev: nil,
}
v2 = &task.mytype{
    next: nil,
    prev: &task.mytype{
        next: 0x210335430,
        prev: nil,
    },
}