this is such stupid code because I haven't switched to protobuf

Signed-off-by: Jeff Carr <[email protected]>

1 files changed, 68 insertions, 16 deletions

diff --git a/event.go b/event.go
index 2956b0e..5bc1fdf 100644
--- a/event.go
+++ b/event.go
@@ -1,6 +1,8 @@
 package main
 
 import (
+	"fmt"
+	"math/rand"
 	"time"
 
 	"go.wit.com/lib/gui/shell"
@@ -24,45 +26,95 @@ func (h *HyperT) RestartDaemon() {
 }
 
 // checks if the cluster is ready and stable
-func clusterReady() bool {
+func clusterReady() (bool, string) {
 	last := time.Since(me.unstable)
 	if last > 133*time.Second {
 		// the cluster has not been stable for 133 seconds
 		log.Warn("clusterReady() is stable for 133s")
-		return true
+		return true, "clusterReady() is stable for 133s"
 	}
 	log.Warn("clusterReady() is unstable for", shell.FormatDuration(last))
-	return false
+	return false, "clusterReady() is unstable for " + shell.FormatDuration(last)
 }
 
-func (d *DropletT) dropletReady() bool {
+func (d *DropletT) dropletReady() (bool, string) {
 	if d.CurrentState == "ON" {
-		log.Warn("EVENT start droplet is already ON")
-		return false
+		return false, "EVENT start droplet is already ON"
 	}
 	if d.starts > 2 {
-		log.Warn("EVENT start droplet has already been started", d.starts, "times")
-		return false
+		// reason := "EVENT start droplet has already been started " + d.starts + " times"
+		return false, fmt.Sprintln("EVENT start droplet has already been started ", d.starts, " times")
 	}
-	return true
+	return true, ""
 }
 
-func (h *HyperT) Start(d *DropletT) {
-	if ! clusterReady() {
-		return
+func (h *HyperT) Start(d *DropletT) (bool, string) {
+	ready, result := clusterReady()
+	if !ready {
+		return false, result
 	}
-	if ! d.dropletReady() {
-		return
+	ready, result = d.dropletReady()
+	if !ready {
+		return false, result
 	}
 
 	url := "http://" + h.Hostname + ":2520/start?start=" + d.Hostname
 	s := shell.Wget(url)
-	log.Warn("EVENT start droplet url:", url)
-	log.Warn("EVENT start droplet response:", s)
+	result = "EVENT start droplet url: " + url + "\n"
+	result += "EVENT start droplet response: " + s.String()
 
 	// increment the counter for a start attempt working
 	d.starts += 1
 
 	// mark the cluster as unstable so droplet starts can be throttled
 	me.unstable = time.Now()
+
+	return true, result
+}
+
+func Start(name string) (bool, string) {
+	var result string
+	dur := time.Since(me.unstable) // how long has the cluster been stable?
+
+	result = fmt.Sprintln("should start droplet", name, "here. grid stable for:", shell.FormatDuration(dur))
+	if dur < 17*time.Second {
+		result += "grid is still too unstable"
+		return false, result
+	}
+	d := findDroplet(name)
+	if d == nil {
+		result += "can't start unknown droplet"
+		return false, result
+	}
+
+	// make the list of hypervisors that are active and can start new droplets
+	var pool []*HyperT
+	for _, h := range me.hypers {
+		result += fmt.Sprintln("could start droplet on", name, "on", h.Hostname, h.Active)
+		if d.hyperPreferred == h.Hostname {
+			// the config file says this droplet should run on this hypervisor
+			a, b := h.Start(d)
+			return a, result + b
+		}
+
+		if h.Active != true {
+			continue
+		}
+		pool = append(pool, h)
+	}
+
+	// left here as an example of how to actually do random numbers
+	// it's complete mathematical chaos. Randomness is simple when
+	// human interaction occurs -- which is exactly what happens most
+	// of the time. most random shit is bullshit. all you really need
+	// is exactly this to make sure the random functions work as they
+	// should. Probably, just use this everywhere in all cases. --jcarr
+	rand.Seed(time.Now().UnixNano())
+	a := 0
+	b := len(pool)
+	n := a + rand.Intn(b-a)
+	result += fmt.Sprintln("pool has", len(pool), "members", "rand =", n)
+	h := pool[n]
+	startbool, startresult := h.Start(d)
+	return startbool, result + startresult
 }