convert to httppb

Makefile

@@ -7,13 +7,27 @@ BUILDTIME = $(shell date +%Y.%m.%d_%H%M)
 # REDOMOD = $(shell if [ -e go.mod ]; then  echo go.mod; else echo no go mod; fi)
 REDOMOD = $(shell if [ -e go.sum ]; then  echo go.sum exists; else GO111MODULE= go mod init; GO111MODULE= go mod tidy; fi)
 
-all: goimports build
-	./zookeeper
+all: build
+	./zookeeper list
+
+vet:
+	@GO111MODULE=off go vet
+	@echo this go binary package builds okay
 
 nogui:
 	./zookeeper --gui nocui
 
-build:
+gocui: build
+	./zookeeper --gui gocui
+
+gocui-5000: build
+	./zookeeper --gui gocui --port 5000
+
+gocui-debugging: build
+	./zookeeper --gui gocui --gui-file ~/go/src/go.wit.com/toolkits/gocui/gocui.so
+	# ./zookeeper --gui gocui --gui-file ~/go/src/go.wit.com/toolkits/gocui/gocui.so  >/tmp/forge.log 2>&1
+
+build: goimports vet
 	GO111MODULE=off go build -v -x \
 		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
 
@@ -41,7 +55,7 @@ redomod:
 clean:
 	rm -f go.*
 	rm -f zookeeper
-	go-mod-clean --purge
+	go-mod-clean purge
 
 # git clone the sources and all the golang dependancies into ~/go/src
 # if you don't have go-clone, you can get it from http://go.wit.com/
@@ -54,14 +68,5 @@ http-toogle-ZOOD:
 http-list-machines:
 	curl --silent http://localhost:8080/list
 
-http-ConfigSave:
-	curl --silent http://localhost:8080/save
-
-http-set-zood-target:
-	curl --silent "http://localhost:8080/target?package=zood&version=v0.0.8"
-
-http-upgrade-hpdev2.grid.wit.com:
-	curl --silent "http://localhost:8080/upgrade?hostname=hpdev2.grid.wit.com"
-
-http-upgrade-mirrors.wit.com:
-	curl --silent "http://localhost:8080/upgrade?hostname=mirrors.wit.com"
+http-uptime:
+	curl --silent http://localhost:8080/uptime

argv.go

@@ -9,24 +9,38 @@ package main
 */
 
 import (
-	"go.wit.com/dev/alexflint/arg"
+	"fmt"
+	"os"
+
 	"go.wit.com/log"
 )
 
 var argv args
 
 type args struct {
-	Daemon bool `arg:"--daemon"           default:"false"  help:"run in daemon mode"`
-	Port   int  `arg:"--port"             default:"8080"   help:"port to run on"`
+	Gui      *EmptyCmd `arg:"subcommand:gui"                       help:"open the gui"`
+	List     *EmptyCmd `arg:"subcommand:list"                      help:"list the machines in your zoo"`
+	Upgrade  *EmptyCmd `arg:"subcommand:upgrade"                   help:"upgrade the machines"`
+	Verbose  bool      `arg:"--verbose"          default:"false"  help:"talk more"`
+	Daemon   bool      `arg:"--daemon"           default:"false"  help:"run in daemon mode"`
+	Port     int       `arg:"--port"             default:"8080"   help:"port to run on"`
+	NoPort   bool      `arg:"--no-port"                              help:"don't open socket"`
+	Bash     bool      `arg:"--bash"                               help:"generate bash completion"`
+	BashAuto []string  `arg:"--auto-complete"                      help:"todo: move this to go-arg"`
+}
+
+type EmptyCmd struct {
 }
 
 func (args) Version() string {
-	return "zood " + VERSION + "   Built on: " + BUILDTIME
+	return "zookeeper " + VERSION + "   Built on: " + BUILDTIME
 }
 
+/*
 func init() {
 	arg.MustParse(&argv)
 }
+*/
 
 func (a args) Description() string {
 	return `
@@ -48,3 +62,36 @@ func init() {
 	ZOOD = log.NewFlag("ZOOD", false, full, short, "show reporting from zood")
 	WARN = log.NewFlag("WARN", true, full, short, "bad things")
 }
+
+// prints help to STDERR // TODO: move everything below this to go-args
+func (args) doBashHelp() {
+	if argv.BashAuto[1] != "''" {
+		// if this is not blank, then the user has typed something
+		return
+	}
+	if argv.BashAuto[0] != ARGNAME {
+		// if this is not the name of the command, the user already started doing something
+		return
+	}
+	if argv.BashAuto[0] == ARGNAME {
+		me.pp.WriteHelp(os.Stderr)
+		return
+	}
+}
+
+func (args) DoAutoComplete(argv []string) {
+	switch argv[0] {
+	case "list":
+		fmt.Println("")
+	case "verify":
+		fmt.Println("on")
+	case "upgrade":
+		fmt.Println("")
+	default:
+		if argv[0] == ARGNAME {
+			// list the subcommands here
+			fmt.Println("help list")
+		}
+	}
+	os.Exit(0)
+}

control

@@ -8,7 +8,7 @@ Maintainer: Jeff Carr <jcarr@wit.com>
 Architecture: amd64
 Depends:
 URL: https://go.wit.com/apps/zookeeper
-Description: zookeeper for homelab grids
+Description: manage your homelab cluster
     keeps track of things in a grid. Maybe
     this is similar to the apache project by
     the same name, but in any case, this is

doGui.go

@@ -6,44 +6,43 @@ package main
 // An app to submit patches for the 30 GO GUI repos
 
 import (
-	"fmt"
 	"os"
-	"time"
 
-	"go.wit.com/gui"
 	"go.wit.com/lib/gadgets"
 	"go.wit.com/lib/protobuf/zoopb"
 	"go.wit.com/log"
 )
 
-func debug() {
-	for {
-		time.Sleep(90 * time.Second)
-		log.Info("TODO: zookeeper scan here. repo count =")
+// refresh the windows & tables the user has open
+func refresh() {
+	if argv.Verbose {
+		log.Info("zookeeper scan here")
+	}
+	if me.zood != nil {
+		// me.zood.doMachinesUpgradeTable(me.machines)
+		all := me.machines.All()
+		for all.Scan() {
+			m := all.Next()
+			if me.hostname == m.Hostname {
+				// this is me! This is the version of zood that should be installed everywhere
+				v := m.FindVersion("zood")
+				me.zood.version = v
+				me.zood.versionL.SetText(v)
+			}
+		}
+		me.zood.refresh()
 	}
 }
 
 func doGui() {
-	me.myGui = gui.New()
-	me.myGui.InitEmbed(resources)
-	me.myGui.Default()
-
-	mainWindow := gadgets.RawBasicWindow("Zookeeper: (inventory your cluster)")
-	mainWindow.Make()
-	mainWindow.Show()
-	mainWindow.Custom = func() {
+	win := gadgets.RawBasicWindow("Zookeeper: (inventory your cluster)")
+	win.Make()
+	win.Show()
+	win.Custom = func() {
 		log.Warn("Main window close")
 		os.Exit(0)
 	}
 
-	drawWindow(mainWindow)
-
-	// sits here forever
-	debug()
-
-}
-
-func drawWindow(win *gadgets.BasicWindow) {
 	box := win.Box()
 
 	vbox := box.NewVerticalBox("BOX2")
@@ -51,77 +50,32 @@ func drawWindow(win *gadgets.BasicWindow) {
 	group1 := vbox.NewGroup("Zookeeper Settings")
 	grid := group1.NewGrid("buildOptions", 0, 0)
 
-	var tbwin *tableWindow
-	grid.NewButton("show zoo", func() {
-		win.Disable()
-		defer win.Enable()
-
-		if tbwin == nil {
-			log.Info("show zoo here")
-			tbwin = makeTableWindow()
-			tbwin.showTable(me.machines)
+	grid.NewButton("zood versions", func() {
+		// if the window exists, just toggle it open or closed
+		if me.zood != nil {
+			me.zood.Toggle()
+			return
 		}
-
-		if tbwin.Hidden() {
-			tbwin.Show()
-		} else {
-			tbwin.Hide()
-		}
-		return
-
+		me.zood = makeZoodWin()
 	})
 
-	grid.NewButton("update table", func() {
-		newwin := makeTableWindow()
-		newwin.showTable(me.machines)
-		newwin.Show()
+	grid.NewButton("Cluster Events", func() {
+		log.Info("todo: start a list here!")
 	})
 
-	grid.NewButton("me.machines.ShowTable()", func() {
-		t := me.machines.NewTable("test 2")
-		t.AddHostname()
-		t.AddStringFunc("sMB", func(m *zoopb.Machine) string {
-			return fmt.Sprintf("%d mb", m.Memory/(1024*1024))
-		})
-		t.ShowTable()
-	})
-
-	grid.NewButton("ConfigSave(me.machines)", func() {
-		log.Info("saving config...")
-		me.machines.ConfigSave()
-	})
-
-	grid.NewButton("ConfigSave(me.machines2)", func() {
-		log.Info("saving config...")
-		me.machines2.ConfigSave()
+	grid.NewButton("ConfigSave()", func() {
+		saveMachineState()
 	})
 }
 
-func (tw *tableWindow) showTable(allm *zoopb.Machines) {
-	all := allm.All()
+func saveMachineState() {
+	cur := zoopb.NewMachines()
+
+	all := me.machines.SortByHostname()
 	for all.Scan() {
 		m := all.Next()
-		tw.grid.NewLabel(m.Hostname)
-		tw.grid.NewLabel(fmt.Sprintf("%d", m.Cpus))
-		gb := m.Memory / (1024 * 1024)
-		ms := fmt.Sprintf("%d MB", gb)
-		tw.grid.NewLabel(ms)
-		tw.grid.NewLabel(m.Distro)
-		tw.grid.NewLabel(findVersion(m, "zood"))
-		tw.grid.NewLabel(findVersion(m, "bash"))
-		dur := m.Laststamp.AsTime()
-		tw.grid.NewLabel(fmt.Sprintf("%v", time.Since(dur)))
-		tw.grid.NewButton("upgrade", func() {
-			log.Info("figure out upgrade", m.Hostname)
-		})
-		tw.grid.NextRow()
+		log.Info("have machine:", m.Hostname)
+		cur.Append(m)
 	}
-}
-
-func findVersion(m *zoopb.Machine, pkgname string) string {
-	zood := m.Packages.FindByName(pkgname)
-	if zood == nil {
-		return "n/a"
-	}
-	return zood.Version
+	cur.ConfigSave()
 }

exit.go

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+import (
+	"os"
+
+	"go.wit.com/log"
+)
+
+func okExit(thing string) {
+	if thing != "" {
+		log.Info("zookeeper exit:", thing, "ok")
+	}
+	os.Exit(0)
+}
+
+func badExit(err error) {
+	log.Info("zookeeper failed: ", err)
+	os.Exit(-1)
+}

http.go

@@ -5,162 +5,90 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
-	"strings"
+	"time"
 
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/lib/protobuf/zoopb"
+	"go.wit.com/lib/protobuf/httppb"
 	"go.wit.com/log"
 )
 
-// remove '?' part and trailing '/'
-func cleanURL(url string) string {
-	url = "/" + strings.Trim(url, "/")
-	return url
-}
-
-func okHandler(w http.ResponseWriter, r *http.Request) {
-	// log.Info("Got URL Path: ", r.URL.Path)
-	route := cleanURL(r.URL.Path)
-
-	hostname := r.URL.Query().Get("hostname")
-	flag := r.URL.Query().Get("flag")
-	packname := r.URL.Query().Get("package")
-	version := r.URL.Query().Get("version")
-
-	msg, err := ioutil.ReadAll(r.Body) // Read the body as []byte
-	if err != nil {
-		log.Info("ReadAll() error =", err)
+/*
+	if strings.HasPrefix(route, "/repos/") {
+		pb := gitpb.NewRepos()
+		if err := pb.Unmarshal(reqPB.ClientData); err == nil {
+			reqPB.Log("Repos Unmarshal() len=%d", pb.Len())
+		} else {
+			reqPB.Logf("Repos Unmarshal() err=%v", err)
+		}
+		result := gitpb.NewRepos()
+		switch route {
+		case "/repos/check":
+			result = addRequest(pb, reqPB)
+			reqPB.Logf("repos check result.Len()=%d pb.Len()=%d\n", result.Len(), pb.Len())
+		case "/repos/pull":
+			result = pullRequest(pb, reqPB)
+		case "/repos/add":
+			result = addRequest(pb, reqPB)
+		default:
+			reqPB.Logf("repos check result.Len()=%d pb.Len()=%d\n", result.Len(), pb.Len())
+			log.Info("repos", route, "unknown")
+		}
+		if err := result.SendReply(w, reqPB); err != nil {
+			reqPB.Logf("Oh well, Send to client failed. err=%v", err)
+		}
+		// todo: logReq(reqPB)
+		logReqPB(reqPB)
 		return
 	}
+*/
+func okHandler(w http.ResponseWriter, r *http.Request) {
+	reqPB, err := httppb.ReqToPB(r)
+	reqPB.Logf("START: Got %d bytes from the client", len(reqPB.ClientData))
+	if err != nil {
+		reqPB.Logf("httppb err %v", err)
+	}
+
+	route := reqPB.Route
 
 	if route == "/" {
 		return
 	}
 
 	if route == "/machine" {
-		handleMachine(r, w, hostname, msg)
-		return
-
-		var m *zoopb.Machine
-		m = new(zoopb.Machine)
-		if err := m.Unmarshal(msg); err != nil {
-			log.Info("zoo host sent unknown machine protobuf len", len(msg))
-			forgepb.IdentifyProtobuf(msg)
-			log.Info("error =", err)
-			return
-		}
-		log.Log(INFO, "proto.Unmarshal() worked on wire message len", len(msg), "from", m.Hostname)
-		b := me.upgrade[m.Hostname]
-		switch updateMachine(m) {
-		case "upgrade":
-			if b {
-				fmt.Fprintln(w, "apt update")
-				me.upgrade[m.Hostname] = false
-			} else {
-				fmt.Fprintln(w, "upgrade")
-			}
-		default:
-			fmt.Fprintln(w, "notsure")
-		}
+		handleMachine(w, reqPB)
 		return
 	}
 
-	if route == "/status" {
-		var packs *zoopb.Packages
-		packs = new(zoopb.Packages)
-		if err := packs.Unmarshal(msg); err != nil {
-			log.Info("/status proto.Unmarshal() failed on wire message len", len(msg), "from", hostname)
-			return
-		}
-
-		log.Info("/status Unmarshal worked with msg len", len(msg), "from", hostname)
-		log.Info("/status hostname", hostname, "has", packs.Len(), "packages installed")
-		fmt.Fprintln(w, "upgrade")
-		return
-	}
-
-	// list out the machines and thier version of zood
-	if route == "/list" {
-		log.HttpMode(w)
-		defer log.HttpMode(nil)
-		loop := me.machines.SortByHostname()
-		for loop.Scan() {
-			m := loop.Next()
-			zood := m.Packages.FindByName("zood")
-			v := me.targets["zood"] // this is the target version
-			if zood == nil {
-				log.Info("machine", m.Hostname, "does not have zood installed")
-			} else {
-				log.Info(fmt.Sprintf("zood version %s vs target version %s on machine %s", zood.Version, v, m.Hostname))
-			}
-		}
-		return
-	}
-
-	// save the config file
-	if route == "/save" {
-		log.HttpMode(w)
-		defer log.HttpMode(nil)
-		if err := me.machines2.ConfigSave(); err == nil {
-			log.Log(NOW, "ConfigSave() ok")
-		} else {
-			log.Log(NOW, "ConfigSave() failed", err)
-		}
-		return
-	}
-
-	// flag a package to attempt to upgrade
-	if route == "/upgrade" {
-		log.HttpMode(w)
-		defer log.HttpMode(nil)
-		me.upgrade[hostname] = true
-		log.Log(NOW, "setting package ", packname, " to upgrade")
-		return
-	}
-
-	// set the target version for a package
-	if route == "/target" {
-		log.HttpMode(w)
-		defer log.HttpMode(nil)
-		// me.targets[packname] = version
-		log.Log(NOW, "setting package/version to ", packname, " ", version)
-		return
-	}
-
-	// toggle logging flags
-	if route == "/flag" {
-		log.HttpMode(w)
-		defer log.HttpMode(nil)
-		log.Info("going to toggle flag:", flag)
-		switch flag {
-		case "ZOOD":
-			if ZOOD.Enabled() {
-				log.Log(NOW, "toogle ZOOD false")
-				ZOOD.SetBool(false)
-			} else {
-				log.Log(NOW, "toogle ZOOD true")
-				ZOOD.SetBool(true)
-			}
-		default:
-			log.Info("unknown looging flag:", flag)
-		}
+	if route == "/uptime" {
+		doUptime(w)
 		return
 	}
 
 	log.Warn("BAD URL =", route)
 }
 
-// starts and sits waiting for HTTP requests
-func startHTTP() {
-	http.HandleFunc("/", okHandler)
-
-	p := fmt.Sprintf(":%d", argv.Port)
-	log.Println("Running on port", p)
-
-	err := http.ListenAndServe(p, nil)
-	if err != nil {
-		log.Println("Error starting server:", err)
+func doUptime(w io.Writer) {
+	if me.zood == nil {
+		fmt.Fprintf(w, "BAD zood == nil\n")
+		return
+	}
+	var count int
+	var bad int
+	for m := range me.machines.IterAll() {
+		count += 1
+		if m.FindVersion("zood") != me.zood.version {
+			if m.SinceLastUpdate() > 10*time.Minute {
+				// skip machines that have not been updated in the last 10 minutes
+				log.Info("ignoring old machine", m.Hostname)
+				continue
+			}
+			bad += 1
+		}
+	}
+	if bad == 0 {
+		fmt.Fprintf(w, "GOOD machine count=(%d) all machines are version %s\n", count, me.zood.version)
+	} else {
+		fmt.Fprintf(w, "BAD machine count=(%d) upgrade=(%d) to %s\n", count, bad, me.zood.version)
 	}
 }

httpDump.go

@@ -1,83 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"net/http"
-)
-
-func dumpRemoteAddr(r *http.Request) string {
-	return r.RemoteAddr
-}
-
-func dumpUserAgent(r *http.Request) string {
-	var all string
-	for param, values := range r.URL.Query() {
-		for _, value := range values {
-			all += fmt.Sprint(" Query:", param, value)
-		}
-	}
-	// hostname := r.URL.Query().Get("hostname")
-	return r.UserAgent() + all
-}
-
-func dumpClient(r *http.Request) {
-	/*
-		var host, url, proto, addr, agent string
-
-		host = r.Host
-		url = r.URL.String()
-		proto = r.Proto
-		addr = r.RemoteAddr
-		agent = r.UserAgent()
-
-		log.Warn(host, proto, addr, url, agent)
-
-		fmt.Fprintln(accessf, time.Now(), host, proto, addr, url, agent)
-		// return
-
-		fmt.Fprintln(clientf)
-		fmt.Fprintln(clientf, time.Now())
-		// Basic request information
-		fmt.Fprintln(clientf, "Method:", r.Method)
-		fmt.Fprintln(clientf, "URL:", r.URL)
-		fmt.Fprintln(clientf, "Protocol:", r.Proto)
-		fmt.Fprintln(clientf, "Host:", r.Host)
-		fmt.Fprintln(clientf, "Remote Address:", r.RemoteAddr)
-
-		// Headers
-		fmt.Fprintln(clientf, "Headers:")
-		for name, values := range r.Header {
-			for _, value := range values {
-				fmt.Fprintln(clientf, "Headers:", name, value)
-			}
-		}
-
-		// Query parameters
-		fmt.Fprintln(clientf, "Query Parameters:")
-		for param, values := range r.URL.Query() {
-			for _, value := range values {
-				fmt.Fprintln(clientf, "Query:", param, value)
-			}
-		}
-
-		// User-Agent
-		fmt.Fprintln(clientf, "User-Agent:", r.UserAgent())
-
-		// Content Length
-		fmt.Fprintln(clientf, "Content Length:", r.ContentLength)
-
-		// Cookies
-		fmt.Fprintln(clientf, "Cookies:")
-		for _, cookie := range r.Cookies() {
-			fmt.Fprintln(clientf, cookie.Name, cookie.Value)
-		}
-
-		// Request Body (if applicable)
-		if r.Body != nil {
-			body, err := ioutil.ReadAll(r.Body)
-			if err == nil {
-				fmt.Fprintln(clientf, "Body:", string(body))
-			}
-		}
-	*/
-}

machine.go

@@ -4,10 +4,11 @@
 package main
 
 import (
+	"fmt"
 	"net/http"
-	"strings"
 	"time"
 
+	"go.wit.com/lib/protobuf/httppb"
 	"go.wit.com/lib/protobuf/zoopb"
 	"go.wit.com/log"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -19,41 +20,54 @@ func rawGetHostname(data []byte) *zoopb.Machine {
 	return newm
 }
 
-func handleMachine(r *http.Request, w http.ResponseWriter, hostname string, data []byte) {
-	hostname = strings.TrimSpace(hostname)
-	newm := rawGetHostname(data)
+func handleMachine(w http.ResponseWriter, reqPB *httppb.HttpRequest) {
+	// hostname := strings.TrimSpace(reqPB.Hostname)
+	newm := rawGetHostname(reqPB.ClientData)
 	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
+		log.Info("unmarshal failed on data len =", len(reqPB.ClientData))
 	}
+	/*
+		if reqPB.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)
+	if reqPB.Hostname == "" {
+		ua := reqPB.DumpUserAgent()
+		ra := reqPB.DumpRemoteAddr()
+		log.Info("hostname is blank even after unmarshal. data len =", len(reqPB.ClientData), ra, ua, newm.Cpus, newm.Hostname)
 		return
 	}
 	// log.Info("lookoing for", hostname)
-	m := me.machines.FindByHostname(hostname)
+	m := me.machines.FindByHostname(reqPB.Hostname)
 	if m == nil {
 		am := new(zoopb.Machine)
 		am.Hostname = newm.Hostname
 		am.Memory = newm.Memory
-		me.machines2.Append(am)
 		me.machines.Append(newm)
 		log.Info("new machine", am.Hostname, am.Memory)
 		return
 	}
-	ua := dumpUserAgent(r)
-	ra := dumpRemoteAddr(r)
+	ua := reqPB.DumpUserAgent()
+	ra := reqPB.DumpRemoteAddr()
 	if m.UserAgent != ua {
-		log.Info("hostname ua changed len =", len(data), ra, hostname, ua)
+		log.Info("hostname ua changed len =", len(reqPB.ClientData), ra, reqPB.Hostname, ua)
 		m.UserAgent = ua
 	}
-	// log.Info("update machine protobuf", hostname)
+	if m.Upgrade {
+		log.Info(m.Hostname, "was told to upgrade zood")
+		if m.UpgradeCmd == "" {
+			fmt.Fprintln(w, "apt update")
+		} else {
+			fmt.Fprintln(w, m.UpgradeCmd)
+		}
+		m.UpgradeCmd = ""
+		m.Upgrade = false
+	} else {
+		fmt.Fprintln(w, "good")
+	}
+	// log.Info("update machine protobuf", reqPB.hostname)
 	updateMachine(newm)
 }
 
@@ -67,8 +81,12 @@ func updateMachine(u *zoopb.Machine) string {
 	if m == nil {
 		log.Info("adding new machine", u.Hostname)
 		me.machines.Append(u)
-		log.Info("save machines pb file here...")
-		me.machines2.ConfigSave()
+		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)
@@ -97,7 +115,9 @@ func updateMachine(u *zoopb.Machine) string {
 	}
 	m.Laststamp = timestamppb.New(time.Now())
 
-	updatePackages(m, u.Packages)
+	if updatePackages(m, u.Packages) {
+		// trigger save pb
+	}
 	return "upgrade"
 }
 
@@ -112,20 +132,36 @@ func updatePackages(m *zoopb.Machine, newp *zoopb.Packages) bool {
 	for loop.Scan() {
 		p := loop.Next()
 		if p.Name == "zood" {
-			if pold := m.Packages.FindByName("zood"); pold == nil {
+			if updatePackageVersion(m, p) {
+				changed = true
+			}
+		}
+		if p.Name == "virtigod" {
+			if updatePackageVersion(m, p) {
+				changed = true
+			}
+		}
+		if p.Name == "forge" {
+			if updatePackageVersion(m, p) {
 				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
 }
+
+func updatePackageVersion(m *zoopb.Machine, pnew *zoopb.Package) bool {
+	pold := m.Packages.FindByName(pnew.Name)
+	if pold == nil {
+		log.Log(NOW, "updatePackages() new package", pnew.Name, "version", pnew.Version, "machine", m.Hostname)
+		m.Packages.Append(pnew)
+		return true
+	}
+	if pold.Version == pnew.Version {
+		log.Log(ZOOD, "updatePackages() unchanged", pold.Version, "machine", m.Hostname)
+		return false
+	}
+	log.Log(NOW, "updatePackages() package", pnew.Name, "version changed", pold.Version, "to", pnew.Version, "machine", m.Hostname)
+	pold.Version = pnew.Version
+	return true
+}

main.go

@@ -4,11 +4,12 @@
 package main
 
 import (
-	"embed"
 	"os"
 	"time"
 
 	"go.wit.com/dev/alexflint/arg"
+	"go.wit.com/lib/gui/prep"
+	"go.wit.com/lib/protobuf/httppb"
 	"go.wit.com/lib/protobuf/zoopb"
 	"go.wit.com/log"
 )
@@ -16,42 +17,42 @@ import (
 var VERSION string
 var BUILDTIME string
 
-//go:embed resources/*
-var resources embed.FS
+var ARGNAME string = "zookeeper"
 
 func main() {
-	var pp *arg.Parser
-	pp = arg.MustParse(&argv)
-
-	if pp == nil {
-		pp.WriteHelp(os.Stdout)
-		os.Exit(0)
-	}
+	me = new(mainType)
+	prep.Bash(ARGNAME, argv.DoAutoComplete) // this line should be:  prep.Bash(argv)
+	me.myGui = prep.Gui()                   // prepares the GUI package for go-args
+	me.pp = arg.MustParse(&argv)
 
 	if argv.Daemon {
 		// turn off timestamps for STDOUT (systemd adds them)
 		log.DaemonMode(true)
 	}
 
-	me = new(stuff)
 	me.hostname, _ = os.Hostname()
-	me.pollDelay = 10 * time.Second
+	me.pollDelay = time.Hour
 	me.machines = zoopb.NewMachines()
-	me.machines2 = zoopb.NewMachines()
 	if err := me.machines.ConfigLoad(); err != nil {
 		log.Warn("load config failed", err)
 		os.Exit(-1)
 	}
-	if err := me.machines2.ConfigLoad(); err != nil {
-		log.Warn("load config failed", err)
-		os.Exit(-1)
+	if argv.List != nil {
+		log.Info("do list here")
+		okExit("")
 	}
-	// me.targets =  make(map[string]string) // keep track of what versions the machines should be running
-	me.upgrade = make(map[string]bool) // used to trigger upgrade attempts
 
 	go NewWatchdog()
+	if !argv.NoPort {
+		go httppb.StartHTTP(okHandler, argv.Port)
+	}
 
-	go startHTTP()
+	me.myGui.Start() // loads the GUI toolkit
+	doGui()          // start making our forge GUI
 
-	doGui()
+	// sit here forever refreshing the GUI
+	for {
+		refresh()
+		time.Sleep(90 * time.Second)
+	}
 }

structs.go

@@ -6,23 +6,30 @@ package main
 import (
 	"time"
 
+	"go.wit.com/dev/alexflint/arg"
 	"go.wit.com/gui"
+	"go.wit.com/lib/gadgets"
+	"go.wit.com/lib/gui/prep"
 	"go.wit.com/lib/protobuf/zoopb"
 )
 
-var me *stuff
+var me *mainType
 
 // this app's variables
-type stuff struct {
-	hostname  string            // my fqdn dns zookeeper hostname
-	pollDelay time.Duration     // how often to report our status
-	dog       *time.Ticker      // the watchdog timer
-	dogchan   chan bool         // can kill the watchdog
-	distro    string            // debian,redhat,gentoo,macos,wincrap
-	packages  *zoopb.Packages   // installed packages and versions
-	machines  *zoopb.Machines   // every machine that has reported itself to the zookeeper
-	machines2 *zoopb.Machines   // every machine that has reported itself to the zookeeper
-	targets   map[string]string // what versions the machines should be running
-	upgrade   map[string]bool   // use this to trigger builds
-	myGui     *gui.Node         // the gui toolkit handle
+type mainType struct {
+	pp          *arg.Parser            // for parsing the command line args.  Yay to alexf lint!
+	hostname    string                 // my fqdn dns zookeeper hostname
+	pollDelay   time.Duration          // how often to report our status
+	dog         *time.Ticker           // the watchdog timer
+	dogchan     chan bool              // can kill the watchdog
+	distro      string                 // debian,redhat,gentoo,macos,wincrap
+	packages    *zoopb.Packages        // installed packages and versions
+	machines    *zoopb.Machines        // every machine that has reported itself to the zookeeper
+	targets     map[string]string      // what versions the machines should be running
+	upgrade     map[string]bool        // use this to trigger builds
+	myGui       *prep.GuiPrep          // the gui toolkit handle
+	machinesWin *gadgets.GenericWindow // the machines gui window
+	machinesBox *gui.Node              // the machines gui parent box widget
+	machinesTB  *zoopb.MachinesTable   // the machines gui table buffer
+	zood        *stdTableWin           // the zood version window
 }

tableWindow.go

@@ -1,138 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-import (
-	"sync"
-
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/log"
-
-	"go.wit.com/gui"
-)
-
-type tableWindow struct {
-	once  sync.Once            // only init() the window once
-	win   *gadgets.BasicWindow // the patches window
-	stack *gui.Node            // the top box set as vertical
-	shelf *gui.Node            // the first box in the stack, set as horizontal
-	grid  *gui.Node            // the list of available patches
-	// summary *patchSummary        // summary of current patches
-	setgrid *gui.Node // the list of each patchset
-}
-
-// todo: autogenerate these or make them standared 'gui' package functions
-// make this an go interface somehow
-
-// is the window hidden right now?
-func (w *tableWindow) Hidden() bool {
-	return w.win.Hidden()
-}
-
-// switches between the window being visable or hidden on the desktop
-func (w *tableWindow) Toggle() {
-	if w.Hidden() {
-		w.Show()
-	} else {
-		w.Hide()
-	}
-}
-
-// hides the window completely
-func (w *tableWindow) Show() {
-	w.win.Show()
-}
-
-func (w *tableWindow) Hide() {
-	log.Info("hide window here")
-	w.win.Hide()
-}
-
-// should be the first box/widget in the window
-// greys out the window to the user
-func (w *tableWindow) Disable() {
-	w.stack.Disable()
-}
-
-func (w *tableWindow) Enable() {
-	w.stack.Enable()
-}
-
-// you can only have one of these
-func makeTableWindow() *tableWindow {
-	pw := new(tableWindow)
-
-	// sync.Once()
-	pw.win = gadgets.RawBasicWindow("Table window for ")
-	pw.win.Make()
-
-	pw.stack = pw.win.Box().NewBox("bw vbox", false)
-	// me.reposwin.Draw()
-	pw.win.Custom = func() {
-		// sets the hidden flag to false so Toggle() works
-		pw.win.Hide()
-	}
-
-	grid := pw.stack.NewGrid("", 0, 0)
-
-	grid.NewLabel("Patchset Details:")
-	grid.NextRow()
-
-	g := pw.stack.NewGroup("PatchSet List")
-
-	// make a grid to put the list of git repos that have patches
-	// in this particular patchset
-	pw.grid = g.NewGrid("", 0, 0)
-	pw.grid.NewLabel("hostname")
-	pw.grid.NewLabel("cpus")
-	pw.grid.NewLabel("Memory")
-	pw.grid.NewLabel("distro")
-	pw.grid.NewLabel("zood")
-	pw.grid.NewLabel("bash")
-	pw.grid.NewLabel("age")
-	pw.grid.NewLabel("upgrade")
-	pw.grid.NextRow()
-
-	// add the patches to the grid
-	// pw.addPatchset(grid, pset)
-	return pw
-}
-
-/*
-func (r *tableWindow) addPatchset(grid *gui.Node, pset *forgepb.Patchset) {
-
-	all := pset.Patches.SortByFilename()
-	for all.Scan() {
-		p := all.Next()
-		// for repo, patches := range repomap {
-		rn := p.RepoNamespace
-		repo := me.forge.FindByGoPath(rn)
-		if repo == nil {
-			log.Info("Could not figure out repo path", rn)
-			rn += " bad repo"
-		}
-		log.Info("Adding patches for", rn)
-		grid.NewLabel(rn)
-
-		// hash := repohash[repo]
-		grid.NewLabel(p.StartHash)
-		grid.NewLabel(p.Filename)
-
-		if repo == nil {
-			continue
-		}
-		grid.NewButton("apply", func() {
-			filename, _ := savePatch(p)
-			if err := applyPatch(repo, filename); err != nil {
-				log.Info("warn user of git am error", err)
-			}
-		})
-		grid.NewCheckbox("").SetChecked(true)
-		grid.NewCheckbox("").SetChecked(true)
-		grid.NewButton("save patch to /tmp", func() {
-		})
-		grid.NextRow()
-	}
-}
-*/

watchdog.go

@@ -55,7 +55,7 @@ func NewWatchdog() {
 					// log.Info("know about machine", m.Hostname, "zood version", zood.Version)
 				}
 			}
-			log.Info("zookeeper has", counter, "machines. Current time:", t)
+			log.Info("hour watchdog:", counter, "machines. Current time:", t)
 
 			// h.pollHypervisor()
 			// h.Scan()

windowZood.go

@@ -0,0 +1,250 @@
+// 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"
+	"sync"
+	"time"
+
+	"go.wit.com/gui"
+	"go.wit.com/lib/gadgets"
+	"go.wit.com/lib/protobuf/zoopb"
+	"go.wit.com/log"
+)
+
+type stdTableWin struct {
+	sync.Mutex
+	win       *gadgets.GenericWindow // the machines gui window
+	box       *gui.Node              // the machines gui parent box widget
+	TB        *zoopb.MachinesTable   // the machines gui table buffer
+	version   string                 // the current zood version
+	versionL  *gui.Node              // label widget to display the current zood version
+	outOfDate *gui.Node              // checkbox to only show out of date droplets
+	showAll   *gui.Node              // show everything in the zoo
+	update    bool                   // if the window should be updated
+}
+
+func (w *stdTableWin) Toggle() {
+	if w == nil {
+		return
+	}
+	if w.win == nil {
+		return
+	}
+	w.win.Toggle()
+}
+
+func makeZoodWin() *stdTableWin {
+	stdw := new(stdTableWin)
+	stdw.win = gadgets.NewGenericWindow("zood daemon versions", "todo: add global controls here")
+	stdw.win.Custom = func() {
+		log.Info("test delete window here")
+	}
+
+	grid := stdw.win.Group.RawGrid()
+	grid.NewButton("save machines.pb", func() {
+		saveMachineState()
+	})
+
+	grid.NewButton("show active", func() {
+		stdw.doMachinesUpgradeTable(me.machines)
+	})
+
+	grid.NewButton("refresh", func() {
+		stdw.refresh()
+	})
+
+	stdw.versionL = grid.NewLabel("scan")
+	stdw.outOfDate = grid.NewCheckbox("out of date")
+	stdw.showAll = grid.NewCheckbox("all")
+	grid.NewButton("upgrade 10", func() {
+		sendUpgrade(10)
+	})
+	grid.NewButton("upgrade all", func() {
+		sendUpgrade(-1)
+	})
+
+	// make a box at the bottom of the window for the protobuf table
+	stdw.box = stdw.win.Bottom.Box().SetProgName("TBOX")
+	stdw.doMachinesUpgradeTable(me.machines)
+
+	return stdw
+}
+
+func sendUpgrade(i int) {
+	var count int
+	all := me.machines.All()
+	for all.Scan() {
+		m := all.Next()
+		mtime := m.Laststamp.AsTime()
+		if time.Since(mtime) > 10*time.Hour {
+			continue
+		}
+		if m.FindVersion("zood") != me.zood.version {
+			count += 1
+			m.Upgrade = true
+			log.Info("upgrade", m.Hostname, count)
+		}
+		if i == -1 || count > i {
+			return
+		}
+	}
+}
+
+func (stdw *stdTableWin) refresh() {
+	if stdw.outOfDate.Checked() {
+		log.Info("refresh() showing out of date zoo")
+		found := zoopb.NewMachines()
+		all := me.machines.All()
+		for all.Scan() {
+			m := all.Next()
+			if !stdw.showAll.Checked() {
+				// skip non-active zoo members
+				mtime := m.Laststamp.AsTime()
+				if time.Since(mtime) > 10*time.Hour {
+					continue
+				}
+			}
+			if m.FindVersion("zood") != me.zood.version {
+				found.Append(m)
+			}
+		}
+		stdw.doMachinesUpgradeTable(found)
+		return
+	}
+	if stdw.showAll.Checked() {
+		log.Info("refresh() showing everything in zoo")
+		stdw.doMachinesUpgradeTable(me.machines)
+		return
+	}
+
+	log.Info("refresh() only show active zoo")
+	found := zoopb.NewMachines()
+	all := me.machines.All()
+	for all.Scan() {
+		m := all.Next()
+		mtime := m.Laststamp.AsTime()
+		// now := time.Now()
+		if time.Since(mtime) > 10*time.Hour {
+			continue
+		}
+		found.Append(m)
+	}
+	stdw.doMachinesUpgradeTable(found)
+}
+
+func (zood *stdTableWin) doMachinesUpgradeTable(pb *zoopb.Machines) {
+	zood.Lock()
+	defer zood.Unlock()
+	if zood.TB != nil {
+		zood.TB.Delete()
+		zood.TB = nil
+	}
+
+	/*
+		found := zoopb.NewMachines()
+		all := pb.SortByHostname()
+		for all.Scan() {
+			m := all.Next()
+			found.Append(m)
+		}
+	*/
+
+	// display the protobuf
+	zood.TB = AddMachinesPB(zood.box, pb)
+	f := func(m *zoopb.Machine) {
+		log.Info("Triggering machine", m.Hostname, "to upgrade zood")
+		m.Upgrade = true
+	}
+	zood.TB.Custom(f)
+	log.Info("table has uuid", zood.TB.GetUuid())
+}
+
+func AddMachinesPB(tbox *gui.Node, pb *zoopb.Machines) *zoopb.MachinesTable {
+	t := pb.NewTable("MachinesPB")
+	t.NewUuid()
+	t.SetParent(tbox)
+
+	upbut := t.AddButtonFunc("upgrade", func(m *zoopb.Machine) string {
+		if me.zood != nil {
+			mver := m.FindVersion("zood")
+			if mver == me.zood.version {
+				return ""
+			} else {
+				// log.Info("machine mismatch", m.Hostname, mver, me.zood.version)
+			}
+		}
+		// log.Info("machine =", m.Hostname)
+		return "now"
+	})
+	upbut.Custom = func(m *zoopb.Machine) {
+		log.Info("Triggering machine", m.Hostname, "to upgrade zood")
+		m.Upgrade = true
+	}
+
+	t.AddHostname()
+	t.AddMemory()
+	t.AddCpus()
+	t.AddStringFunc("sMB", func(m *zoopb.Machine) string {
+		if m.Memory/(1024*1024) > 10000 {
+			return fmt.Sprintf("%4d G", m.Memory/(1024*1024*1024))
+		}
+		return fmt.Sprintf("%4d M", m.Memory/(1024*1024))
+	})
+
+	t.AddStringFunc("zood", func(m *zoopb.Machine) string {
+		return m.FindVersion("zood")
+	})
+	virtbut := t.AddButtonFunc("virtigod", func(m *zoopb.Machine) string {
+		ver := m.FindVersion("virtigod")
+		if ver == "n/a" {
+			return ""
+		}
+		return ver
+	})
+	virtbut.Custom = func(m *zoopb.Machine) {
+		log.Info("Triggering machine", m.Hostname, "to upgrade virtigod")
+		m.Upgrade = true
+		m.UpgradeCmd = "apt install virtigod"
+	}
+
+	forgebut := t.AddButtonFunc("forge", func(m *zoopb.Machine) string {
+		ver := m.FindVersion("forge")
+		if ver == "n/a" {
+			return ""
+		}
+		return ver
+	})
+	forgebut.Custom = func(m *zoopb.Machine) {
+		log.Info("Triggering machine", m.Hostname, "to upgrade forge")
+		m.Upgrade = true
+		m.UpgradeCmd = "apt install forge"
+	}
+
+	delf := func(m *zoopb.Machine) string {
+		return "delete"
+	}
+	delbut := t.AddButtonFunc("delete", delf)
+	delbut.Custom = func(m *zoopb.Machine) {
+		log.Info("Need to delete the protobuf record here", m.Hostname)
+	}
+
+	/*
+		// show if the machine needs to be upgraded
+		t.AddStringFunc("triggered?", func(m *zoopb.Machine) string {
+			if m.Upgrade {
+				return "yes"
+			}
+			return ""
+		})
+	*/
+
+	t.AddTimeFunc("age", func(m *zoopb.Machine) time.Time {
+		return m.Laststamp.AsTime()
+	})
+
+	t.ShowTable()
+	return t
+}