zookeeper/machine.go

// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
// Use of this source code is governed by the GPL 3.0

package main

import (
	"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.machines2.Append(am)
		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
	}
	// 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)
		log.Info("save machines pb file here...")
		me.machines2.ConfigSave()
		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
}