Add spawnpoint inspect capability

Author: jhkolb

spawnclient/client.go

@@ -6,6 +6,7 @@ import (
 	"encoding/base64"
 	"io/ioutil"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/SoftwareDefinedBuildings/spawnpoint/service"
@@ -60,6 +61,48 @@ func (sc *SpawnClient) Scan(baseURI string) (map[string]daemon.Heartbeat, error)
 	return spawnpoints, nil
 }
 
+func (sc *SpawnClient) Inspect(uri string) (*daemon.Heartbeat, map[string]daemon.ServiceHeartbeat, error) {
+	daemonHbs, err := sc.Scan(uri)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "Initial spawnpoint scan failed")
+	} else if len(daemonHbs) == 0 {
+		return nil, nil, errors.New("No spawnpoints found at URI")
+	} else if len(daemonHbs) > 1 {
+		return nil, nil, errors.New("Multiple spawnpoints found at URI")
+	}
+	// This loop is guaranteed to iterate just once
+	var daemonHb daemon.Heartbeat
+	for _, hb := range daemonHbs {
+		daemonHb = hb
+	}
+
+	svcClient := sc.bwClient.RegisterService(uri, "s.spawnpoint")
+	iFaceClient := svcClient.RegisterInterface("+", "i.spawnable")
+	svcHeartbeatMsgs, err := sc.bwClient.Query(&bw2.QueryParams{
+		URI: iFaceClient.SignalURI("heartbeat"),
+	})
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "Bosswave query failed")
+	}
+	svcHeartbeats := make(map[string]daemon.ServiceHeartbeat)
+	for svcHbMsg := range svcHeartbeatMsgs {
+		for _, po := range svcHbMsg.POs {
+			if po.IsTypeDF(bw2.PODFSpawnpointSvcHb) {
+				var svcHb daemon.ServiceHeartbeat
+				if err := po.(bw2.MsgPackPayloadObject).ValueInto(&svcHb); err != nil {
+					// Ignore this query result
+					continue
+				}
+				tokens := strings.Split(svcHbMsg.URI, "/")
+				svcName := tokens[len(tokens)-4]
+				svcHeartbeats[svcName] = svcHb
+			}
+		}
+	}
+
+	return &daemonHb, svcHeartbeats, nil
+}
+
 func (sc *SpawnClient) Deploy(config *service.Configuration, uri string) error {
 	if err := validateConfig(config); err != nil {
 		return errors.Wrap(err, "Invalid service configuration")

spawnctl/main.go

@@ -298,9 +298,22 @@ func actionScan(c *cli.Context) error {
 		fmt.Printf("Scan failed: %s\n", err)
 		os.Exit(1)
 	}
-	fmt.Printf("Discovered %v Spawnpoint(s)\n", len(heartbeats))
-	for uri, hb := range heartbeats {
-		printSpawnpointStatus(uri, &hb)
+
+	if len(heartbeats) == 1 {
+		// Guaranteed to iterate once
+		for uri, _ := range heartbeats {
+			daemonHb, svcHbs, err := spawnClient.Inspect(uri)
+			if err != nil {
+				fmt.Printf("Inspect failed: %s\n", err)
+				os.Exit(1)
+			}
+			printSpawnpointDetails(uri, daemonHb, svcHbs)
+		}
+	} else {
+		fmt.Printf("Discovered %v Spawnpoint(s)\n", len(heartbeats))
+		for uri, hb := range heartbeats {
+			printSpawnpointStatus(uri, &hb)
+		}
 	}
 
 	return nil
@@ -339,10 +352,12 @@ func parseSvcConfig(configFile string) (*service.Configuration, error) {
 }
 
 func printSpawnpointStatus(uri string, hb *daemon.Heartbeat) {
+	tokens := strings.Split(uri, "/")
+	alias := tokens[len(tokens)-1]
 	lastSeen := time.Unix(0, hb.Time)
 	duration := time.Now().Sub(lastSeen) / (10 * time.Millisecond) * (10 * time.Millisecond)
 
-	fmt.Printf("[%s] seen %s (%s) ago at %s\n", hb.Alias, lastSeen.Format(time.RFC822), duration.String(), uri)
+	fmt.Printf("[%s] seen %s (%s) ago at %s\n", alias, lastSeen.Format(time.RFC822), duration.String(), uri)
 	fmt.Printf("Available CPU Shares: %v/%v\n", hb.AvailableCPU, hb.TotalCPU)
 	fmt.Printf("Available Memory: %v/%v\n", hb.AvailableMemory, hb.TotalMemory)
 
@@ -351,3 +366,23 @@ func printSpawnpointStatus(uri string, hb *daemon.Heartbeat) {
 		fmt.Printf("  • %s\n", service)
 	}
 }
+
+func printSpawnpointDetails(uri string, daemonHb *daemon.Heartbeat, svcHbs map[string]daemon.ServiceHeartbeat) {
+	tokens := strings.Split(uri, "/")
+	alias := tokens[len(tokens)-1]
+	lastSeen := time.Unix(0, daemonHb.Time)
+	duration := time.Now().Sub(lastSeen) / (10 * time.Millisecond) * (10 * time.Millisecond)
+
+	fmt.Printf("[%s] seen %s (%s) ago at %s\n", alias, lastSeen.Format(time.RFC822), duration.String(), uri)
+	fmt.Printf("Available CPU Shares: %v/%v\n", daemonHb.AvailableCPU, daemonHb.TotalCPU)
+	fmt.Printf("Available Memory: %v/%v\n", daemonHb.AvailableMemory, daemonHb.TotalMemory)
+
+	fmt.Printf("%v Running Service(s)\n", len(daemonHb.Services))
+	for name, svcHb := range svcHbs {
+		lastSeen := time.Unix(0, svcHb.Time)
+		duration := time.Now().Sub(lastSeen) / (10 * time.Millisecond) * (10 * time.Millisecond)
+		fmt.Printf("• [%s] seen %s (%s) ago.\n", name, lastSeen.Format(time.RFC822), duration.String())
+		fmt.Printf("  CPU: ~%.2f/%d Shares. Memory: %.2f/%d MiB\n", svcHb.UsedCPUShares, svcHb.CPUShares,
+			svcHb.UsedMemory, svcHb.Memory)
+	}
+}

spawnd/daemon/heartbeat.go

@@ -10,7 +10,6 @@ import (
 )
 
 type Heartbeat struct {
-	Alias           string
 	Version         string
 	Time            int64
 	TotalMemory     uint64
@@ -56,7 +55,6 @@ func (daemon *SpawnpointDaemon) publishHearbeats(ctx context.Context, delay time
 			daemon.registryLock.RUnlock()
 
 			hb := Heartbeat{
-				Alias:           daemon.alias,
 				Version:         util.VersionNum,
 				Time:            time.Now().UnixNano(),
 				TotalCPU:        daemon.totalCPUShares,
@@ -111,7 +109,7 @@ func (daemon *SpawnpointDaemon) publishServiceHeartbeats(ctx context.Context, sv
 
 func (daemon *SpawnpointDaemon) Decommission() error {
 	bw2Iface := daemon.bw2Service.RegisterInterface("daemon", "i.spawnpoint")
-	daemon.logger.Debugf("Decomissioning spawnpoint %s", daemon.alias)
+	daemon.logger.Debugf("Decomissioning spawnpoint %s", daemon.path)
 	// A message without any POs is effectively a metadata de-persist
 	if err := bw2Iface.PublishSignal("heartbeat"); err != nil {
 		daemon.logger.Errorf("Failed to publish de-persist message: %s", err)

spawnd/daemon/management.go

@@ -44,6 +44,9 @@ func (daemon *SpawnpointDaemon) manageService(svc *serviceManifest, done chan<-
 			}
 
 			daemon.logger.Debugf("(%s) Attempting to start new service", svc.Name)
+			if err := daemon.publishLogMessage(svc.Name, "[INFO] Launching service..."); err != nil {
+				daemon.logger.Errorf("(%s) Failed to publish log message: %s", svc.Name, err)
+			}
 			svcID, err := daemon.backend.StartService(ctx, svc.Configuration)
 			if err != nil {
 				daemon.logger.Errorf("(%s) Failed to start service: %s", svc.Name, err)