-
-
Notifications
You must be signed in to change notification settings - Fork 53
/
process.go
133 lines (116 loc) · 2.26 KB
/
process.go
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
package immortal
import (
"fmt"
"io"
"os"
"os/exec"
"strconv"
"syscall"
"time"
)
// Process interface
type Process interface {
Kill() error
Pid() int
Signal(sig os.Signal) error
Start() (*process, error)
}
type process struct {
*Config
Logger
cmd *exec.Cmd
eTime time.Time
errch chan error
sTime time.Time
}
// Start runs the command
func (p *process) Start() (*process, error) {
p.cmd = exec.Command(p.command[0], p.command[1:]...)
// change working directory
if p.Cwd != "" {
p.cmd.Dir = p.Cwd
}
// set environment vars
if p.Env != nil {
env := os.Environ()
for k, v := range p.Env {
env = append(env, fmt.Sprintf("%s=%s", k, v))
}
p.cmd.Env = env
}
sysProcAttr := new(syscall.SysProcAttr)
// set owner
if p.user != nil {
uid, err := strconv.Atoi(p.user.Uid)
if err != nil {
return nil, err
}
gid, err := strconv.Atoi(p.user.Gid)
if err != nil {
return nil, err
}
sysProcAttr.Credential = &syscall.Credential{
Uid: uint32(uid),
Gid: uint32(gid),
}
}
// Set Process group ID to Pgid, or, if Pgid == 0, to new pid
sysProcAttr.Setpgid = true
sysProcAttr.Pgid = 0
// set the attributes
p.cmd.SysProcAttr = sysProcAttr
// log only if are available loggers
var (
r *io.PipeReader
w *io.PipeWriter
)
if p.Logger.IsLogging() {
r, w = io.Pipe()
p.cmd.Stdout = w
p.cmd.Stderr = w
go p.Logger.StdHandler(r)
} else {
p.cmd.Stdin = nil
p.cmd.Stdout = nil
p.cmd.Stderr = nil
}
// Start the process
if err := p.cmd.Start(); err != nil {
return nil, err
}
p.sTime = time.Now()
p.errch = make(chan error)
go func(w *io.PipeWriter) {
err := p.cmd.Wait()
p.eTime = time.Now()
if w != nil {
w.Close()
}
p.errch <- err
}(w)
return p, nil
}
// Kill the entire Process group.
func (p *process) Kill() error {
processGroup := 0 - p.cmd.Process.Pid
return syscall.Kill(processGroup, syscall.SIGKILL)
}
// Pid return Process PID
func (p *process) Pid() int {
if p.cmd == nil || p.cmd.Process == nil {
return 0
}
return p.cmd.Process.Pid
}
// Signal sends a signal to the Process
func (p *process) Signal(sig os.Signal) error {
return p.cmd.Process.Signal(sig)
}
func NewProcess(cfg *Config) *process {
return &process{
Config: cfg,
Logger: &LogWriter{
logger: NewLogger(cfg),
},
}
}