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
|
// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
// Use of this source code is governed by the GPL 3.0
package main
import (
"fmt"
"net/http"
"strings"
"time"
"go.wit.com/lib/protobuf/zoopb"
"go.wit.com/log"
"google.golang.org/protobuf/types/known/timestamppb"
)
func rawGetHostname(data []byte) *zoopb.Machine {
newm := new(zoopb.Machine)
newm.Unmarshal(data)
return newm
}
func handleMachine(r *http.Request, w http.ResponseWriter, hostname string, data []byte) {
hostname = strings.TrimSpace(hostname)
newm := rawGetHostname(data)
if newm == nil {
log.Info("unmarshal failed on data len =", len(data))
}
if hostname != newm.Hostname {
// log.Info("hostname mismatch", hostname, "vs", newm.Hostname)
hostname = newm.Hostname
}
if hostname == "" {
ua := dumpUserAgent(r)
ra := dumpRemoteAddr(r)
log.Info("hostname is blank even after unmarshal. data len =", len(data), ra, ua, newm.Cpus, newm.Hostname)
return
}
// log.Info("lookoing for", hostname)
m := me.machines.FindByHostname(hostname)
if m == nil {
am := new(zoopb.Machine)
am.Hostname = newm.Hostname
am.Memory = newm.Memory
me.machines.Append(newm)
log.Info("new machine", am.Hostname, am.Memory)
return
}
ua := dumpUserAgent(r)
ra := dumpRemoteAddr(r)
if m.UserAgent != ua {
log.Info("hostname ua changed len =", len(data), ra, hostname, ua)
m.UserAgent = ua
}
if m.Upgrade {
log.Info(m.Hostname, "was told to upgrade zood")
fmt.Fprintln(w, "apt update")
m.Upgrade = false
} else {
fmt.Fprintln(w, "good")
}
// log.Info("update machine protobuf", hostname)
updateMachine(newm)
}
// someone sent machine 'u' is it new?
// if not, update the record of it
func updateMachine(u *zoopb.Machine) string {
if u == nil {
return "nil"
}
m := me.machines.FindByHostname(u.Hostname)
if m == nil {
log.Info("adding new machine", u.Hostname)
me.machines.Append(u)
if me.zood == nil {
// do nothing. window has not been opened
} else {
me.zood.doMachinesUpgradeTable(me.machines)
}
saveMachineState()
return "new"
}
// log.Info("updating machine", m.Hostname)
// did the # of cpus change?
if m.Cpus != u.Cpus {
m.Cpus = u.Cpus
log.Info("cpus changed to", m.Cpus)
}
// did the memory change?
if m.Memory != u.Memory {
m.Memory = u.Memory
log.Info("memory changed to", m.Memory)
}
// init these if nil
if m.Packages == nil {
m.Packages = new(zoopb.Packages)
}
if u.Packages == nil {
u.Packages = new(zoopb.Packages)
}
if zood := m.Packages.FindByName("zood"); zood != nil {
log.Log(INFO, m.Hostname, "has zood version", zood.Version)
}
m.Laststamp = timestamppb.New(time.Now())
updatePackages(m, u.Packages)
return "upgrade"
}
// looks to see if any packages:
// changed versions
// were newly installed
// were uninstalled
func updatePackages(m *zoopb.Machine, newp *zoopb.Packages) bool {
var changed bool = false
loop := newp.SortByName()
for loop.Scan() {
p := loop.Next()
if p.Name == "zood" {
if pold := m.Packages.FindByName("zood"); pold == nil {
changed = true
log.Log(ZOOD, "updatePackages() new package", p.Name, "version", p.Version, "machine", m.Hostname)
m.Packages.Append(p)
} else {
if p.Version == pold.Version {
log.Log(ZOOD, "updatePackages() unchanged", p.Version, "machine", m.Hostname)
} else {
changed = true
log.Log(NOW, "updatePackages() package", p.Name, "version changed", pold.Version, "to", p.Version, "machine", m.Hostname)
pold.Version = p.Version
}
}
}
}
return changed
}
|
