Improved status reporting

This commit rewrites status reporting used to control deployment
progress and get-status command

* Old reporter machinery was removed
* Resource classes were simplified:
  - they no longer wrap resources in SimpleReporter
  - they do not care about their metadata
  - Status method was replaced with GetProgress which reports
    deployment progress in float number 0..1. Most resources have
    either 0 or 1, but replicated resources can have all the variety
  - resources no longer dial with reporting
  - handling of success factor is now done in scheduler
As a result resource classes are now much simpler

On top of that new status methods were added that collect overall
deployment statistics and detailed per-resource status table.
Both can be retrieved using get-status CLI command

Author: Stan Lagun

cmd/get-status.go

@@ -23,8 +23,9 @@ import (
 	"github.com/Mirantis/k8s-AppController/pkg/client"
 	"github.com/Mirantis/k8s-AppController/pkg/interfaces"
 	"github.com/Mirantis/k8s-AppController/pkg/scheduler"
-	"github.com/spf13/cobra"
 
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
 	"k8s.io/client-go/pkg/labels"
 )
 
@@ -93,25 +94,48 @@ func getStatus(cmd *cobra.Command, args []string) {
 		AllowUndeclaredArgs: anyArgs,
 	}
 
-	status, report, err := scheduler.GetStatus(c, sel, options)
+	graph, err := scheduler.GetStatusGraph(c, sel, options)
 	if err != nil {
 		log.Fatal(err)
 	}
+
+	//status := graph.GetDeploymentStatus()
 	if getJSON {
-		data, err := json.Marshal(report)
+		data := graph.GetNodeStatuses()
+		out, err := json.Marshal(data)
 		if err != nil {
 			log.Fatal(err)
 		}
-		fmt.Printf(string(data))
+		fmt.Printf(string(out))
 	} else {
-		fmt.Printf("STATUS: %s\n", status)
+		status := graph.GetDeploymentStatus()
+		if status.Total == 0 {
+			fmt.Println("Dependency graph is empty")
+			return
+		}
+
+		fmt.Println()
+		fmt.Printf("Total nodes: %d (%d groups)\n", status.Total, status.TotalGroups)
+		fmt.Printf("   Finished: %d\n", status.Finished)
+		fmt.Printf("   Progress: %d %%\n", int(status.Progress*100))
+
 		if getReport {
-			data := report.AsText(0)
-			for _, line := range data {
-				fmt.Println(line)
+			fmt.Println()
+			table := tablewriter.NewWriter(os.Stdout)
+			table.SetHeader([]string{"Node", "Status", "Progress %"})
+			table.SetColWidth(70)
+			table.SetAutoFormatHeaders(false)
+			for _, node := range graph.GetNodeStatuses() {
+				table.Append([]string{
+					node.Name,
+					node.Status,
+					fmt.Sprintf("%d %%", node.Progress),
+				})
 			}
+			table.Render()
 		}
 	}
+
 }
 
 // InitGetStatusCommand is an initialiser for get-status

e2e/example_runner.go

@@ -25,7 +25,6 @@ import (
 	"github.com/Mirantis/k8s-AppController/e2e/utils"
 	"github.com/Mirantis/k8s-AppController/pkg/client"
 	"github.com/Mirantis/k8s-AppController/pkg/interfaces"
-	"github.com/Mirantis/k8s-AppController/pkg/report"
 	"github.com/Mirantis/k8s-AppController/pkg/scheduler"
 
 	. "github.com/onsi/ginkgo"
@@ -105,18 +104,16 @@ func (f *examplesFramework) handleListCreation(ustList *runtime.UnstructuredList
 }
 
 func (f *examplesFramework) VerifyStatus(options interfaces.DependencyGraphOptions) {
-	var depReport report.DeploymentReport
 	Eventually(
 		func() bool {
-			status, r, err := scheduler.GetStatus(f.Client, nil, options)
+			graph, err := scheduler.GetStatusGraph(f.Client, nil, options)
 			if err != nil {
 				return false
 			}
-			depReport = r.(report.DeploymentReport)
-			utils.Logf("STATUS: %s\n", status)
-			return status == interfaces.Finished || status == interfaces.Empty
+			status := graph.GetDeploymentStatus()
+			return status.Progress == 1 || status.Total == 0
 		},
-		300*time.Second, 5*time.Second).Should(BeTrue(), strings.Join(depReport.AsText(0), "\n"))
+		300*time.Second, 5*time.Second).Should(BeTrue())
 }
 
 func (f *examplesFramework) CreateRunAndVerify(exampleName string, options interfaces.DependencyGraphOptions) {

glide.lock

@@ -6,3 +6,4 @@ import:
 - package: k8s.io/apimachinery
 - package: github.com/fatih/color
   version: ^1.1.0
+- package: github.com/olekukonko/tablewriter

glide.yaml

@@ -18,42 +18,15 @@ import (
 	"github.com/Mirantis/k8s-AppController/pkg/client"
 )
 
-// ResourceStatus is an enum of k8s resource statuses
-type ResourceStatus string
-
-// Possible ResourceStatus values
-const (
-	ResourceReady    ResourceStatus = "ready"
-	ResourceNotReady ResourceStatus = "not ready"
-	ResourceError    ResourceStatus = "error"
-)
-
 // DefaultFlowName is the name of default flow (main dependency graph)
 const DefaultFlowName = "DEFAULT"
 
-// BaseResource is an interface for AppController supported resources
-type BaseResource interface {
+// Resource is an interface for AppController supported resources
+type Resource interface {
 	Key() string
-	// Ensure that Status() supports nil as meta
-	Status(meta map[string]string) (ResourceStatus, error)
+	GetProgress() (float32, error)
 	Create() error
 	Delete() error
-	Meta(string) interface{}
-}
-
-// DependencyReport is a report of a single dependency of a node in graph
-type DependencyReport struct {
-	Dependency string
-	Blocks     bool
-	Percentage int
-	Needed     int
-	Message    string
-}
-
-// Resource is an interface for a base resource that implements getting dependency reports
-type Resource interface {
-	BaseResource
-	GetDependencyReport(map[string]string) DependencyReport
 }
 
 // ResourceTemplate is an interface for AppController supported resource templates
@@ -64,14 +37,28 @@ type ResourceTemplate interface {
 	NewExisting(string, client.Interface, GraphContext) Resource
 }
 
-// DeploymentReport is an interface to get string representation of current deployment progress
-type DeploymentReport interface {
-	AsText(int) []string
+// DeploymentStatus is the structure containing deployment status - different stats and progress info
+type DeploymentStatus struct {
+	Total       int
+	TotalGroups int
+	Failed      int
+	Skipped     int
+	Finished    int
+	Replicas    int
+	Progress    float32
+}
+
+// NodeStatus represents status of each graph node
+type NodeStatus struct {
+	Name     string
+	Status   string
+	Progress int
 }
 
 // DependencyGraph represents operations on dependency graph
 type DependencyGraph interface {
-	GetStatus() (DeploymentStatus, DeploymentReport)
+	GetDeploymentStatus() DeploymentStatus
+	GetNodeStatuses() []NodeStatus
 	Deploy(<-chan struct{}) bool
 	Options() DependencyGraphOptions
 }

pkg/interfaces/enums.go

@@ -19,14 +19,13 @@ import (
 
 	"github.com/Mirantis/k8s-AppController/pkg/client"
 	"github.com/Mirantis/k8s-AppController/pkg/interfaces"
-	"github.com/Mirantis/k8s-AppController/pkg/report"
 )
 
 // CountingResource is a fake resource that becomes ready after given timeout.
 // It also increases the counter when started and decreases it when becomes ready
 type CountingResource struct {
 	key       string
-	status    interfaces.ResourceStatus
+	progress  float32
 	counter   *CounterWithMemo
 	timeout   time.Duration
 	startTime time.Time
@@ -37,15 +36,15 @@ func (c CountingResource) Key() string {
 	return c.key
 }
 
-// Status returns a status of the CountingResource. It also updates the status
+// GetProgress returns a progress of the CountingResource. It also updates the progress
 // after provided timeout and decrements counter
-func (c *CountingResource) Status(meta map[string]string) (interfaces.ResourceStatus, error) {
-	if time.Since(c.startTime) >= c.timeout && c.status != interfaces.ResourceReady {
+func (c *CountingResource) GetProgress() (float32, error) {
+	if time.Since(c.startTime) >= c.timeout && c.progress < 1 {
 		c.counter.Dec()
-		c.status = interfaces.ResourceReady
+		c.progress = 1
 	}
 
-	return c.status, nil
+	return c.progress, nil
 }
 
 // Create increments counter and sets creation time
@@ -60,32 +59,22 @@ func (c *CountingResource) Delete() error {
 	return nil
 }
 
-// Meta returns empty string
-func (c *CountingResource) Meta(string) interface{} {
-	return nil
-}
-
-// NameMatches returns true
-func (c *CountingResource) NameMatches(_ client.ResourceDefinition, _ string) bool {
-	return true
-}
-
 // New returns new fake resource
-func (c *CountingResource) New(_ client.ResourceDefinition, _ client.Interface) interfaces.BaseResource {
-	return report.SimpleReporter{BaseResource: NewResource("fake", interfaces.ResourceReady)}
+func (c *CountingResource) New(_ client.ResourceDefinition, _ client.Interface) interfaces.Resource {
+	return NewResource("fake", 1)
 }
 
 // NewExisting returns new existing resource
-func (c *CountingResource) NewExisting(name string, _ client.Interface) interfaces.BaseResource {
-	return report.SimpleReporter{BaseResource: NewResource(name, interfaces.ResourceReady)}
+func (c *CountingResource) NewExisting(name string, _ client.Interface) interfaces.Resource {
+	return NewResource(name, 1)
 }
 
 // NewCountingResource creates new instance of CountingResource
 func NewCountingResource(key string, counter *CounterWithMemo, timeout time.Duration) *CountingResource {
 	return &CountingResource{
-		key:     key,
-		status:  interfaces.ResourceNotReady,
-		counter: counter,
-		timeout: timeout,
+		key:      key,
+		progress: 0,
+		counter:  counter,
+		timeout:  timeout,
 	}
 }