Added auto-restart and started playing with init() function

internal/client/client.go

@@ -3,7 +3,6 @@ package client
 import (
 	fmt "fmt"
 	log "log"
-	http "net/http"
 	sync "sync"
 	time "time"
 
@@ -19,48 +18,38 @@ import (
  will contact the router and attempt to retrieve the results
  of it's most recent request.
 */
-func Main(wg *sync.WaitGroup, config gs.GagentConfig, rid int, agent string) {
+func Main(wg *sync.WaitGroup, config gs.GagentConfig, agent string) {
 	defer wg.Done()
 	log.Printf("[INFO] Starting client\n")
 
-	// Generate connect string for this router.
-	var rport = config.ClientPort
-	if config.Routers[rid].ClientPort != 0 {
-		rport = config.Routers[rid].ClientPort
-	}
-	connectString := fmt.Sprintf("tcp://%s:%d", config.Routers[rid].RouterAddr, rport)
-	log.Printf("[DEBUG] Attempting to connect to %s\n", connectString)
+	for key := range config.Routers {
+		// Generate connect string for this router.
+		rport := config.ClientPort
+		if config.Routers[key].ClientPort != 0 {
+			rport = config.Routers[key].ClientPort
+		}
+		connectString := fmt.Sprintf("tcp://%s:%d", config.Routers[key].RouterAddr, rport)
 
+		wg.Add(1)
+		go sendAgent(wg, config.UUID, connectString, agent)
+		time.Sleep(10 * time.Millisecond)
+	}
+}
+
+func sendAgent(wg *sync.WaitGroup, uuid string, connectString string, agent string) {
+	log.Printf("[DEBUG] Attempting to connect to %s\n", connectString)
+	defer wg.Done()
 	var mu sync.Mutex
+	mu.Lock()
 
 	sock, _ := zmq.NewSocket(zmq.REQ)
 	defer sock.Close()
 
-	sock.SetIdentity(config.UUID)
+	sock.SetIdentity(uuid)
 	sock.Connect(connectString)
 
-	go func() {
-		mu.Lock()
-		log.Printf("[DEBUG] Start sending agent...\n")
-		sock.SendMessage(agent)
-		log.Printf("[DEBUG] End sending agent...\n")
-		mu.Unlock()
-	}()
-
-	time.Sleep(10 * time.Millisecond)
-
-	// for {
-	// 	time.Sleep(10 * time.Millisecond)
-	// 	mu.Lock()
-	// 	msg, err := sock.RecvMessage(zmq.DONTWAIT)
-	// 	if err == nil {
-	// 		log.Println(msg[0], config.UUID)
-	// 	}
-	// 	mu.Unlock()
-	// }
-
-}
-
-func pushAgent(config gs.GagentConfig) {
-	http.Get(config.Routers[0].RouterAddr)
+	log.Printf("[DEBUG] Start sending agent...\n")
+	sock.SendMessage(agent)
+	log.Printf("[DEBUG] End sending agent...\n")
+	mu.Unlock()
 }

internal/gstructs/gstructs.go

@@ -14,6 +14,13 @@ type GagentConfig struct {
 	Workers    []*WorkerDetails `hcl:"worker,block"`
 	Version    string
 	File       string
+	CMode      bool
+}
+
+type Agent struct {
+	Client     string
+	ScriptCode []byte
+	Hints      []*string
 }
 
 // ClientDetails is details about known clients

internal/worker/worker.go

@@ -3,47 +3,57 @@ package worker
 import (
 	fmt "fmt"
 	log "log"
-	http "net/http"
 	sync "sync"
 
 	gs "git.dragonheim.net/dragonheim/gagent/internal/gstructs"
 
 	// picol "git.dragonheim.net/dragonheim/gagent/src/picol"
 
-	promhttp "github.com/prometheus/client_golang/prometheus/promhttp"
+	prometheus "github.com/prometheus/client_golang/prometheus"
+	promauto "github.com/prometheus/client_golang/prometheus/promauto"
 
 	zmq "github.com/pebbe/zmq4"
 )
 
+var (
+	opsProcessed = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "agent_requests_collected",
+	})
+)
+
 /*
  The "worker" processes the agent code. The worker nodes do not know
  anything about the network structure. Instead they know only to which
  router(s) they are connected. The worker will execute the agent code and
  pass the agent and it's results to a router.
 */
-func Main(wg *sync.WaitGroup, config gs.GagentConfig, rid int) {
+func Main(wg *sync.WaitGroup, config gs.GagentConfig) {
 	defer wg.Done()
-	http.Handle("/metrics", promhttp.Handler())
-
 	log.Printf("[INFO] Starting worker\n")
 
-	// Generate connect string for this router.
-	var rport = config.WorkerPort
-	if config.Routers[rid].WorkerPort != 0 {
-		rport = config.Routers[rid].WorkerPort
+	for key := range config.Routers {
+		rport := config.WorkerPort
+		if config.Routers[key].WorkerPort != 0 {
+			rport = config.Routers[key].WorkerPort
+		}
+
+		// Generate connect string for this router.
+		connectString := fmt.Sprintf("tcp://%s:%d", config.Routers[key].RouterAddr, rport)
+
+		wg.Add(1)
+		go getAgent(wg, config.UUID, connectString)
 	}
-	connectString := fmt.Sprintf("tcp://%s:%d", config.Routers[rid].RouterAddr, rport)
 	// workerListener := fmt.Sprintf("tcp://%s:%d", config.ListenAddr, config.WorkerPort)
-	clientListener := fmt.Sprintf("%s:%d", config.ListenAddr, config.ClientPort)
+
+}
+
+func getAgent(wg *sync.WaitGroup, uuid string, connectString string) {
+	log.Printf("[DEBUG] Attempting to connect to %s\n", connectString)
+	defer wg.Done()
 
 	subscriber, _ := zmq.NewSocket(zmq.REP)
 	defer subscriber.Close()
 
-	go func() {
-		http.ListenAndServe(clientListener, nil)
-	}()
-
-	log.Printf("[DEBUG] Attempting to connect to %s\n", connectString)
 	subscriber.Connect(connectString)
 
 	msg, err := subscriber.Recv(0)