package main

import (
    "errors"
    "log"
    "os"
    "os/signal"
    "time"
)

var (
    // ErrTimeout 任務(wù)執(zhí)行超時(shí)時(shí)返回
    ErrTimeout = errors.New("received timeout")
    // ErrInterrupt 接收到操作系統(tǒng)的事件時(shí)返回
    ErrInterrupt = errors.New("received interrupt")
)

// Runner 在給定的超時(shí)時(shí)間內(nèi)執(zhí)行一組任務(wù)
// 并且在操作系統(tǒng)發(fā)送中斷信號(hào)時(shí)結(jié)束這些任務(wù)
type Runner struct {
    // interrupt 通道報(bào)告從操作系統(tǒng)
    // 發(fā)送的信號(hào)
    interrupt chan os.Signal

    // complete 通道報(bào)告處理任務(wù)已完成
    complete chan error

    // timeout 報(bào)告處理任務(wù)已經(jīng)超時(shí)
    timeout <-chan time.Time

    // tasks 持有一組以索引順序依次執(zhí)行的函數(shù)
    tasks []func(int)
}

// NewRunner 創(chuàng)建Runner
func NewRunner(duration time.Duration) *Runner {
    return &Runner{
        interrupt: make(chan os.Signal, 1),
        complete:  make(chan error),
        timeout:   time.After(duration),
    }
}

// Add 將一個(gè)任務(wù)附加到runner上
// 任務(wù)接收一個(gè)int類型的??作為函數(shù)參數(shù)
func (r *Runner) Add(tasks ...func(int)) {
    r.tasks = append(r.tasks, tasks...)
}

func (r *Runner) Start() error {
    // 接收中斷信號(hào)
    signal.Notify(r.interrupt, os.Interrupt)

    go func() {
        r.complete <- r.Run()
    }()

    select {
    // 任務(wù)完成
    case err := <-r.complete:
        return err
    // 任務(wù)超時(shí)
    case <-r.timeout:
        return ErrTimeout
    }
}

// Run 執(zhí)行注冊(cè)的任務(wù)
func (r *Runner) Run() error {
    for id, task := range r.tasks {
        if r.gotInterrupt() {
            return ErrInterrupt
        }

        task(id)
    }
    return nil
}

// gotInterrupt 是否收到中斷信號(hào)
func (r *Runner) gotInterrupt() bool {
    select {
    case <-r.interrupt:
        signal.Stop(r.interrupt)
        return true
    default:
        return false
    }
}

// Demo 模擬耗時(shí)任務(wù)
func Demo() func(int) {
    return func(i int) {
        log.Printf("Processor - Task #%d.\n", i)
        time.Sleep(time.Second * time.Duration(i))
    }
}

func main() {
    log.Println("Process start.")

    timeout := time.Second * 3 // 3s過(guò)期
    r := NewRunner(timeout)

    r.Add(Demo(), Demo(), Demo())
    if err := r.Start(); err != nil {
        switch err {
        case ErrTimeout:
            log.Println("Terminating due to timeout.")
            os.Exit(1)
        case ErrInterrupt:
            log.Println("Terminating due to interrupt.")
            os.Exit(2)
        }
    }

    log.Println("Process ended.")
}