forked from waffle-iron/core0
/
local.go
100 lines (84 loc) · 1.85 KB
/
local.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
package core
import (
"encoding/json"
"fmt"
"github.com/g8os/core0/base/pm"
"github.com/g8os/core0/base/pm/core"
"github.com/g8os/core0/base/utils"
"net"
"os"
)
type Local struct {
listener *net.UnixListener
}
type LocalCmd struct {
Sync bool `json:"sync"`
Content json.RawMessage `json:"content"`
}
type LocalResult struct {
State string `json:"state"`
Error string `json:"error,omitempty"`
Result *core.JobResult `json:"result,omitempty"`
}
func NewLocal(s string) (*Local, error) {
if utils.Exists(s) {
os.Remove(s)
}
addr, err := net.ResolveUnixAddr("unix", s)
if err != nil {
return nil, err
}
listener, err := net.ListenUnix("unix", addr)
if err != nil {
return nil, err
}
return &Local{
listener,
}, nil
}
func (l *Local) server(con net.Conn) {
//read command
lresult := LocalResult{
State: core.StateError,
}
defer func() {
//send result
m, _ := json.Marshal(&lresult)
if _, err := con.Write(m); err != nil {
log.Errorf("Failed to write response to local transport: %s", err)
}
con.Close()
}()
decoder := json.NewDecoder(con)
var lcmd LocalCmd
if err := decoder.Decode(&lcmd); err != nil {
lresult.Error = fmt.Sprintf("Failed to decode message: %s", err)
return
}
cmd, err := core.LoadCmd(lcmd.Content)
if err != nil {
lresult.Error = fmt.Sprintf("Failed to extract command: %s", err)
return
}
runner, err := pm.GetManager().RunCmd(cmd)
if err != nil {
lresult.Error = fmt.Sprintf("Failed to get job runner for command(%s): %s", cmd.Command, err)
return
}
go runner.Run()
lresult.State = core.StateSuccess
if lcmd.Sync {
result := runner.Wait()
lresult.Result = result
}
}
func (l *Local) Serve() {
defer l.listener.Close()
for {
con, err := l.listener.Accept()
if err != nil {
log.Errorf("local transport error: %s", err)
}
go l.server(con)
}
}