Makefile

@@ -9,14 +9,14 @@ REDOMOD = $(shell if [ -e go.sum ]; then  echo go.sum exists; else GO111MODULE=
 
 all: build
 	./zood --version
-	./zood test
+	./zood
 
 build: goimports
-	GO111MODULE=off go build -v -x \
+	GO111MODULE=off go build \
 		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
 
 install:
-	GO111MODULE=off go install -v -x \
+	GO111MODULE=off go install \
 		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
 
 sudo: build

README

@@ -1,3 +1 @@
 This is the zookeeper daemon.
-
-It is simple. It's just designed to keep packages up to date.

argv.go

@@ -16,13 +16,9 @@ import (
 var argv args
 
 type args struct {
-	Test   *EmptyCmd `arg:"subcommand:test"                      help:"New to forge? This is for you.'"`
+	Daemon bool   `arg:"--daemon"           default:"false"  help:"run in daemon mode"`
-	Daemon bool      `arg:"--daemon"           default:"false"  help:"run in daemon mode"`
+	Port   int    `arg:"--port"             default:"2521"   help:"port to run on"`
-	Port   int       `arg:"--port"             default:"2521"   help:"port to run on"`
+	URL    string `arg:"--url"                               help:"url to use"`
-	URL    string    `arg:"--url"                               help:"url to use"`
-}
-
-type EmptyCmd struct {
 }
 
 func (args) Version() string {

http.go

@@ -0,0 +1,119 @@
+// 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"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strings"
+
+	"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)
+
+	domname := r.URL.Query().Get("domain")
+	flag := r.URL.Query().Get("flag")
+
+	msg, err := ioutil.ReadAll(r.Body) // Read the body as []byte
+	if err != nil {
+		fmt.Fprintln(w, "ReadAll() error =", err)
+		return
+	}
+
+	log.Info("Got URL msg:", string(msg))
+	if route == "/" {
+		fmt.Fprintln(w, "OK")
+		return
+	}
+
+	// exit the virtigo daemon & have systemd restart it
+	// this can happen & when it does, access to
+	// to libvirtd will hang (aka: virsh list will hang)
+	// One way to trigger this is to not properly close
+	// domain sockets opened from go-qemu/hypervisor
+	// it's a good idea in any case so leave it here
+	if route == "/kill" {
+		log.Warn("KILLED")
+		fmt.Fprintln(w, "KILLED")
+		os.Exit(-1)
+		return
+	}
+
+	// curl http://localhost:2520/import?domain=foo.bar.com
+	if route == "/import" {
+		fmt.Fprint(w, "import domain:", domname)
+
+		return
+	}
+
+	// toggle logging flags
+	if route == "/flag" {
+		log.HttpMode(w)
+		defer log.HttpMode(nil)
+		log.Info("going to toggle flag:", flag)
+		switch flag {
+		case "PING":
+			if PING.Enabled() {
+				log.Log(NOW, "toogle PING false")
+				PING.SetBool(false)
+			} else {
+				log.Log(NOW, "toogle PING true")
+				PING.SetBool(true)
+			}
+		default:
+			log.Info("unknown looging flag:", flag)
+		}
+		return
+	}
+
+	if route == "/favicon.ico" {
+		writeFile(w, "ipv6.png")
+		return
+	}
+
+	log.Warn("BAD URL =", route)
+}
+
+func writeFile(w http.ResponseWriter, filename string) {
+	// fmt.Fprintln(w, "GOT TEST?")
+	fullname := "resources/" + filename
+	pfile, err := resources.ReadFile(fullname)
+	if err != nil {
+		log.Println("ERROR:", err)
+		// w.Write(pfile)
+		return
+	}
+
+	var repohtml string
+	repohtml = string(pfile)
+	if filename == "goReference.svg" {
+		w.Header().Set("Content-Type", "image/svg+xml")
+	}
+	fmt.Fprintln(w, repohtml)
+	log.Println("writeFile() found internal file:", filename)
+}
+
+// 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)
+	}
+}

main.go

@@ -5,13 +5,11 @@ package main
 
 import (
 	"embed"
-	"fmt"
 	"os"
 	"time"
 
 	"go.wit.com/dev/alexflint/arg"
-	"go.wit.com/lib/hostname"
+	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/lib/protobuf/zoopb"
 	"go.wit.com/log"
 )
 
@@ -22,94 +20,35 @@ var BUILDTIME string
 var resources embed.FS
 
 func main() {
-	me = new(zoodStruct)
+	var pp *arg.Parser
-	me.pp = arg.MustParse(&argv)
+	pp = arg.MustParse(&argv)
 
-	if me.pp == nil {
+	if pp == nil {
-		me.pp.WriteHelp(os.Stdout)
+		pp.WriteHelp(os.Stdout)
 		os.Exit(0)
 	}
 
 	if argv.Daemon {
 		// turn off timestamps for STDOUT (systemd adds them)
 		log.DaemonMode(true)
-		me.machine, me.fullpath = zoopb.InitDaemon()
-	} else {
-		me.machine, me.fullpath = zoopb.InitMachine()
-
 	}
 
-	if err := testZoo(); err != nil {
+	me = new(stuff)
-		log.Info("FAILED TO CONNECT TO ZOOKEEPER: ", err)
+	me.urlbase = "http://zookeeper.grid.wit.com:8080"
-		log.Info("sleeping for 3 minutes")
+	if argv.URL != "" {
-		time.Sleep(3 * time.Minute)
+		log.Info("USING ARGV URL:", argv.URL)
-		os.Exit(0)
+		me.urlbase = argv.URL
 	}
+
 	me.pollDelay = 3 * time.Second
 	me.failcountmax = 20 // die every minute if zookeeper can't be found
 
-	if argv.Test != nil {
+	// me.machine.ConfigLoad()
-		testURL(me.urlbase, me.machine)
-		os.Exit(0)
-	}
 
-	zood() // talks to zookeeper
+	me.forge = forgepb.InitPB()
-}
+	me.forge.InitMachine()
-
+
-func testZoo() error {
+	go NewWatchdog()
-	var err error
+
-	if argv.URL != "" {
+	startHTTP()
-		log.Info("USING ARGV URL:", argv.URL)
-		if err = testURL(argv.URL, me.machine); err == nil {
-			me.urlbase = argv.URL
-			return nil
-		}
-	}
-
-	zooname := findZookeeper()
-
-	url := fmt.Sprintf("http://%s:8080/", zooname)
-	if err = testURL(url, me.machine); err == nil {
-		me.urlbase = url
-		return nil
-	}
-	url = fmt.Sprintf("https://%s/", zooname)
-	if err = testURL(url, me.machine); err == nil {
-		me.urlbase = url
-		return nil
-	}
-	url = "http://zookeeper.wit.com:8080/"
-	if err = testURL(url, me.machine); err == nil {
-		me.urlbase = url
-		return nil
-	}
-	url = "https://zookeeper.wit.com/"
-	if err = testURL(url, me.machine); err == nil {
-		me.urlbase = url
-		return nil
-	}
-	return err
-}
-
-func findZookeeper() string {
-	hname, dname, err := hostname.GetDomainname()
-	if err != nil {
-		log.Info("error with os.Hostname()", hname, dname, err)
-	}
-	if dname == "" {
-		return "zookeeper.wit.com"
-	}
-	return hostname.Join("zookeeper", dname)
-}
-
-func testURL(urlbase string, pb *zoopb.Machine) error {
-	newpb, wsPB, err := pb.HttpPost(urlbase, "test")
-	if err != nil {
-		log.Info("got error:", err)
-		return err
-	}
-	wsPB.DumpClient()
-	newpb.Dump()
-	log.Info("got error:", err)
-	return err
 }

send.go

@@ -13,9 +13,9 @@ import (
 
 func pingStatus() error {
 	var url string
-	url = me.urlbase + "/status?hostname=" + me.machine.Hostname
+	url = me.urlbase + "/status?hostname=" + me.forge.Machine.Hostname
 	/*
-		msg, err := me.machine.Packages.Marshal()
+		msg, err := me.forge.Machine.Packages.Marshal()
 		if err != nil {
 			log.Info("proto.Marshal() failed:", err)
 			return err
@@ -23,7 +23,7 @@ func pingStatus() error {
 		log.Info("proto Marshal len =", len(msg))
 	*/
 
-	body, err := me.machine.HttpPostMachine(url)
+	body, err := me.forge.HttpPostMachine(url)
 	if err != nil {
 		log.Info("httpPost() failed:", err)
 		return err
@@ -45,51 +45,33 @@ func pingStatus() error {
 func sendMachine(s string) error {
 	var url string
 	url = me.urlbase + "/machine"
-	body, err := me.machine.HttpPostMachine(url)
+	body, err := me.forge.HttpPostMachine(url)
 	if err != nil {
 		log.Info("httpPost() failed: url", url)
 		log.Info("httpPost() failed:", err)
 		log.Info("httpPost() data:", string(body))
 		return err
 	}
-	// out := strings.TrimSpace(string(body))
+	out := strings.TrimSpace(string(body))
-	// log.Info("httpPost() data:", out, len(body))
+	log.Info("httpPost() data:", out, len(body))
 
 	test := strings.TrimSpace(string(body))
 	// log.Info("virtigo returned body:", test)
 	for _, line := range strings.Split(test, "\n") {
-		if line == "good" {
+		if line == "upgrade" {
 			log.Info(s, "zookeeper is healthy")
 			me.failcount = 0
 		} else if line == "kill" {
 			os.Exit(0)
 		} else if strings.HasPrefix(line, "apt update") {
 			log.Info("machine upgrade now", line)
-			shell.RunRealtime([]string{"mv", "-f", "/usr/bin/zood", "/usr/bin/zood.last"})
+			shell.Run([]string{"apt", "update"})
-			shell.RunRealtime([]string{"apt", "update"})
+			shell.Run([]string{"apt", "install", "zood"})
-			shell.RunRealtime([]string{"apt", "install", "zood"})
+			log.Sleep(1)
-			if shell.Exists("/usr/bin/zood") {
-				shell.RunRealtime([]string{"rm", "-f", "/usr/bin/zood.last"})
-			} else {
-				// there is not a new version of the binary. move the old one back
-				shell.RunRealtime([]string{"mv", "-f", "/usr/bin/zood.last", "/usr/bin/zood"})
-			}
 			os.Exit(0)
-		} else if strings.HasPrefix(line, "apt install") {
-			log.Info("Got to apt install", line)
-			parts := strings.Fields(line)
-			if len(parts) > 1 {
-				cmd := []string{"apt"}
-				cmd = append(cmd, parts[1:]...)
-				log.Info("Got to parts =", parts)
-				log.Info("Got to cmd =", cmd)
-				shell.RunRealtime(cmd)
-			} else {
-				log.Info("nothing to install for line:", line)
-			}
 		} else {
 			log.Info(me.urlbase, "is maybe not working GOT:", line)
-			log.Info(me.urlbase, "fail count", me.failcount, "from hostname", me.machine.Hostname)
+			log.Info(me.urlbase, "fail count", me.failcount, "from hostname", me.forge.Machine.Hostname)
 		}
 	}
 	return nil

structs.go

@@ -6,21 +6,19 @@ package main
 import (
 	"time"
 
-	"go.wit.com/dev/alexflint/arg"
+	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/lib/protobuf/zoopb"
 )
 
-var me *zoodStruct
+var me *stuff
 
 // this app's variables
-type zoodStruct struct {
+type stuff struct {
-	urlbase      string         // the dns name for the zookeeper
+	urlbase   string        // the dns name for the zookeeper
-	hostname     string         // my hostname
+	hostname  string        // my hostname
-	pollDelay    time.Duration  // how often to report our status
+	pollDelay time.Duration // how often to report our status
-	dog          *time.Ticker   // the watchdog timer
+	dog       *time.Ticker  // the watchdog timer
-	machine      *zoopb.Machine // populated from protobuf based zoopb
+	// machine      zoopb.Machine  // populated from protobuf based zoopb
+	forge        *forgepb.Forge // handle to forge
 	failcount    int            // how many times we've failed to contact the zookeeper
 	failcountmax int            // after this, exit and let systemd restart the daemon
-	fullpath     string         // where to save the machine PB file
-	pp           *arg.Parser    // from go-args
 }

watchdog.go

@@ -16,26 +16,10 @@ func TimeFunction(f func()) time.Duration {
 	return time.Since(startTime) // Calculate the elapsed time
 }
 
-// sends updates to zookeeper
+func NewWatchdog() {
-func zood() {
 	me.dog = time.NewTicker(me.pollDelay)
 	defer me.dog.Stop()
 	done := make(chan bool)
-	for {
-		select {
-		case <-done:
-			fmt.Println("Done!")
-			return
-		case _ = <-me.dog.C:
-			s := me.machine.UpdatePackages()
-			me.failcount += 1
-			sendMachine(s)
-
-			if me.failcount > 20 {
-				os.Exit(0)
-			}
-		}
-	}
 	/*
 		// this example would exit/destroy the ticker in 10 seconds
 		go func() {
@@ -43,4 +27,23 @@ func zood() {
 			done <- true
 		}()
 	*/
+	for {
+		select {
+		case <-done:
+			fmt.Println("Done!")
+			return
+		case _ = <-me.dog.C:
+			// log.Info("Watchdog() ticked", me.zookeeper, "Current time: ", t)
+			s := me.forge.Machine.UpdatePackages()
+			// pingStatus()
+			me.failcount += 1
+			sendMachine(s)
+
+			if me.failcount > 20 {
+				os.Exit(0)
+			}
+			// h.pollHypervisor()
+			// h.Scan()
+		}
+	}
 }

zood.service

@@ -1,14 +1,13 @@
 [Unit]
 Description=zood
-After=network.target
 
 [Service]
 User=root
 Type=simple
 ExecStart=/usr/bin/zood --daemon
-Restart=always
+ExecStop=killall zood
-RestartSec=5s
+Restart=on-failure
-KillMode=process
+RestartSec=5
 
 [Install]
 WantedBy=multi-user.target