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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
package main
import (
"flag"
"fmt"
"log"
"os/exec"
"strings"
"rescribe.xyz/go.git/bookpipeline"
)
const usage = `Usage: lspipeline [-i key] [-n num]
Lists useful things related to the pipeline.
- Instances running
- Messages in each queue
- Books not completed
- Books done
- Last n lines of bookpipeline logs from each running instance
`
type LsPipeliner interface {
Init() error
PreQueueId() string
OCRQueueId() string
AnalyseQueueId() string
GetQueueDetails(url string) (string, string, error)
GetInstanceDetails() ([]bookpipeline.InstanceDetails, error)
ListObjects(bucket string, prefix string) ([]string, error)
WIPStorageId() string
}
// NullWriter is used so non-verbose logging may be discarded
type NullWriter bool
func (w NullWriter) Write(p []byte) (n int, err error) {
return len(p), nil
}
type queueDetails struct {
name, numAvailable, numInProgress string
}
func getInstances(conn LsPipeliner, detailsc chan bookpipeline.InstanceDetails) {
details, err := conn.GetInstanceDetails()
if err != nil {
log.Println("Error getting instance details:", err)
}
for _, d := range details {
detailsc <- d
}
close(detailsc)
}
func getQueueDetails(conn LsPipeliner, qdetails chan queueDetails) {
queues := []struct{ name, id string }{
{"preprocess", conn.PreQueueId()},
{"ocr", conn.OCRQueueId()},
{"analyse", conn.AnalyseQueueId()},
}
for _, q := range queues {
avail, inprog, err := conn.GetQueueDetails(q.id)
if err != nil {
log.Println("Error getting queue details:", err)
}
var qd queueDetails
qd.name = q.name
qd.numAvailable = avail
qd.numInProgress = inprog
qdetails <- qd
}
close(qdetails)
}
// getBookStatus returns a list of in progress and done books.
// It determines this by listing all objects, and splitting the
// prefixes into two lists, those which have a 'graph.png' file,
// which are classed as done, and those which are not.
func getBookStatus(conn LsPipeliner) (inprogress []string, done []string, err error) {
allfiles, err := conn.ListObjects(conn.WIPStorageId(), "")
if err != nil {
log.Println("Error getting list of objects:", err)
return inprogress, done, err
}
for _, f := range allfiles {
parts := strings.Split(f, "/")
if parts[1] != "graph.png" {
continue
}
prefix := parts[0]
found := false
for _, i := range done {
if i == prefix {
found = true
continue
}
}
if !found {
done = append(done, prefix)
}
}
for _, f := range allfiles {
parts := strings.Split(f, "/")
prefix := parts[0]
found := false
for _, i := range done {
if i == prefix {
found = true
continue
}
}
for _, i := range inprogress {
if i == prefix {
found = true
continue
}
}
if !found {
inprogress = append(inprogress, prefix)
}
}
return inprogress, done, err
}
func getBookStatusChan(conn LsPipeliner, inprogressc chan string, donec chan string) {
inprogress, done, err := getBookStatus(conn)
if err != nil {
log.Println("Error getting book status:", err)
close(inprogressc)
close(donec)
return
}
for _, i := range inprogress {
inprogressc <- i
}
close(inprogressc)
for _, i := range done {
donec <- i
}
close(donec)
}
func getRecentSSHLogs(ip string, id string, n int) (string, error) {
addr := fmt.Sprintf("%s@%s", "admin", ip)
logcmd := fmt.Sprintf("journalctl -n %d -u bookpipeline", n)
var cmd *exec.Cmd
if id == "" {
cmd = exec.Command("ssh", addr, logcmd)
} else {
cmd = exec.Command("ssh", "-i", id, addr, logcmd)
}
out, err := cmd.Output()
if err != nil {
return "", err
}
return string(out), nil
}
func main() {
keyfile := flag.String("i", "", "private key file for SSH")
lognum := flag.Int("n", 5, "number of lines to include in SSH logs")
flag.Usage = func() {
fmt.Fprintf(flag.CommandLine.Output(), usage)
flag.PrintDefaults()
}
flag.Parse()
var verboselog *log.Logger
var n NullWriter
verboselog = log.New(n, "", 0)
var conn LsPipeliner
conn = &bookpipeline.AwsConn{Region: "eu-west-2", Logger: verboselog}
err := conn.Init()
if err != nil {
log.Fatalln("Failed to set up cloud connection:", err)
}
instances := make(chan bookpipeline.InstanceDetails, 100)
queues := make(chan queueDetails)
inprogress := make(chan string, 100)
done := make(chan string, 100)
go getInstances(conn, instances)
go getQueueDetails(conn, queues)
go getBookStatusChan(conn, inprogress, done)
var ips []string
fmt.Println("# Instances")
for i := range instances {
fmt.Printf("ID: %s, Type: %s, LaunchTime: %s, State: %s", i.Id, i.Type, i.LaunchTime, i.State)
if i.Name != "" {
fmt.Printf(", Name: %s", i.Name)
}
if i.Ip != "" {
fmt.Printf(", IP: %s", i.Ip)
ips = append(ips, i.Ip)
}
if i.Spot != "" {
fmt.Printf(", SpotRequest: %s", i.Spot)
}
fmt.Printf("\n")
}
fmt.Println("\n# Queues")
for i := range queues {
fmt.Printf("%s: %s available, %s in progress\n", i.name, i.numAvailable, i.numInProgress)
}
fmt.Println("\n# Books not completed")
for i := range inprogress {
fmt.Println(i)
}
fmt.Println("\n# Books done")
for i := range done {
fmt.Println(i)
}
if len(ips) > 0 {
fmt.Println("\n# Recent logs")
for _, ip := range ips {
logs, err := getRecentSSHLogs(ip, *keyfile, *lognum)
if err != nil {
log.Printf("Error running ssh for %s: %v\n", ip, err)
continue
}
fmt.Printf("\n%s\n%s\n", ip, logs)
}
}
}
|
