70 lines
995 B
Go
70 lines
995 B
Go
package executer
|
|
|
|
import (
|
|
"errors"
|
|
"os/exec"
|
|
"time"
|
|
)
|
|
|
|
var ErrTimeout = errors.New("operation timed out")
|
|
|
|
type Job struct {
|
|
Cmd *exec.Cmd
|
|
Err chan error
|
|
}
|
|
|
|
type Worker struct {
|
|
Jobs chan Job
|
|
Timeout time.Duration
|
|
}
|
|
|
|
func NewJob(e *exec.Cmd) Job {
|
|
return Job{
|
|
Cmd: e,
|
|
Err: make(chan error),
|
|
}
|
|
}
|
|
|
|
func NewWorker(timeout time.Duration) *Worker {
|
|
w := &Worker{
|
|
Jobs: make(chan Job, 1),
|
|
Timeout: timeout,
|
|
}
|
|
// start worker routine
|
|
go w.run()
|
|
return w
|
|
}
|
|
|
|
// runs in own goroutine
|
|
func (e *Worker) run() {
|
|
var done chan error
|
|
|
|
if e.Timeout != 0 {
|
|
done = make(chan error)
|
|
defer close(done)
|
|
}
|
|
|
|
for j := range e.Jobs {
|
|
if e.Timeout == 0 {
|
|
// run synchronously
|
|
j.Err <- j.Cmd.Run()
|
|
} else {
|
|
// run asyncly and timeout
|
|
go func() {
|
|
done <- j.Cmd.Run()
|
|
}()
|
|
|
|
select {
|
|
case err := <-done:
|
|
j.Err <- err
|
|
case <-time.After(e.Timeout):
|
|
j.Err <- j.Cmd.Process.Kill()
|
|
j.Err <- ErrTimeout
|
|
}
|
|
}
|
|
|
|
// signal done
|
|
close(j.Err)
|
|
}
|
|
}
|