Add estimates and pretty printing to exclusion status check (#1927)

* Add estimates and pretty printing to exclusion status check

* Correct exclusion status logic for more than 1 SS per Pod

Author: johscheuer

kubectl-fdb/cmd/exclusion_status.go

@@ -25,6 +25,7 @@ import (
 	"fmt"
 	"github.com/FoundationDB/fdb-kubernetes-operator/pkg/fdbstatus"
 	"sort"
+	"strconv"
 	"time"
 
 	fdbv1beta2 "github.com/FoundationDB/fdb-kubernetes-operator/api/v1beta2"
@@ -126,15 +127,17 @@ kubectl fdb get exclusion-status c1 --interval=5m
 
 type exclusionResult struct {
 	id          string
-	storedBytes int
 	estimate    string
+	storedBytes int
+	timestamp   time.Time
 }
 
 func getExclusionStatus(cmd *cobra.Command, restConfig *rest.Config, kubeClient *kubernetes.Clientset, clientPod string, namespace string, ignoreFullyExcluded bool, interval time.Duration) error {
 	timer := time.NewTicker(interval)
-	previousRun := map[string]int{}
+	previousRun := map[string]exclusionResult{}
 
 	for {
+		// TODO: Keeping a stream open is probably more efficient.
 		out, serr, err := executeCmd(restConfig, kubeClient, clientPod, namespace, "fdbcli --exec 'status json'")
 		if err != nil {
 			// If an error occurs retry
@@ -162,38 +165,48 @@ func getExclusionStatus(cmd *cobra.Command, restConfig *rest.Config, kubeClient
 		}
 
 		var ongoingExclusions []exclusionResult
+		timestamp := time.Now()
 		for _, process := range status.Cluster.Processes {
 			if !process.Excluded {
 				continue
 			}
 
+			// If more than one storage server per Pod is running we have to differentiate those processes. If the
+			// process ID is not set, fall back to the instance ID.
+			instance, ok := process.Locality[fdbv1beta2.FDBLocalityProcessIDKey]
+			if !ok {
+				instance = process.Locality[fdbv1beta2.FDBLocalityInstanceIDKey]
+			}
+
 			if !ignoreFullyExcluded && len(process.Roles) == 0 {
-				cmd.Println(process.Locality["instance_id"], "is fully excluded")
+				cmd.Println(instance, "is fully excluded")
+				continue
 			}
 
-			instance := process.Locality["instance_id"]
-			// TODO: Add estimate when an exclusion is done
 			// TODO: Add progress bars
 			for _, role := range process.Roles {
 				roleClass := fdbv1beta2.ProcessClass(role.Role)
 				if roleClass.IsStateful() {
 					var estimate string
 
-					previousBytes, ok := previousRun[instance]
+					previousResult, ok := previousRun[instance]
 					if ok {
-						// TODO calculate estimates for duration
-						_ = previousBytes
+						estimateDuration := time.Duration(role.StoredBytes/(previousResult.storedBytes-role.StoredBytes)) * timestamp.Sub(previousResult.timestamp)
+						estimate = estimateDuration.String()
+					} else {
 						estimate = "N/A"
 					}
 
-					// TODO: Check if StoredBytes is the correct value
-					ongoingExclusions = append(ongoingExclusions, exclusionResult{
+					result := exclusionResult{
 						id:          instance,
 						storedBytes: role.StoredBytes,
 						estimate:    estimate,
-					})
+						timestamp:   timestamp,
+					}
+					// TODO: Check if StoredBytes is the correct value
+					ongoingExclusions = append(ongoingExclusions, result)
 
-					previousRun[instance] = role.StoredBytes
+					previousRun[instance] = result
 				}
 			}
 		}
@@ -208,7 +221,7 @@ func getExclusionStatus(cmd *cobra.Command, restConfig *rest.Config, kubeClient
 		})
 
 		for _, exclusion := range ongoingExclusions {
-			cmd.Printf("%s:\t %d bytes are left - estimate: %s\n", exclusion.id, exclusion.storedBytes, exclusion.estimate)
+			cmd.Printf("%s:\t %s are left - estimate: %s\n", exclusion.id, prettyPrintStoredBytes(exclusion.storedBytes), exclusion.estimate)
 		}
 
 		cmd.Println("There are", len(ongoingExclusions), "processes that are not fully excluded.")
@@ -218,3 +231,20 @@ func getExclusionStatus(cmd *cobra.Command, restConfig *rest.Config, kubeClient
 
 	return nil
 }
+
+// prettyPrintStoredBytes will return a string that represents the storedBytes in a human-readable format.
+func prettyPrintStoredBytes(storedBytes int) string {
+	units := []string{"", "Ki", "Mi", "Gi", "Ti", "Pi"}
+
+	currentBytes := float64(storedBytes)
+	for _, unit := range units {
+		if currentBytes < 1024 {
+			return fmt.Sprintf("%3.2f%s", currentBytes, unit)
+		}
+
+		currentBytes /= 1024
+	}
+
+	// Fallback will be to printout the bytes.
+	return strconv.Itoa(storedBytes)
+}

kubectl-fdb/cmd/exclusion_status_test.go

@@ -0,0 +1,41 @@
+/*
+ * exclusion_status_test.go
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2021 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cmd
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("[plugin] exclustion stats command", func() {
+	DescribeTable("pretty printing the stored bytes", func(storedByes int, expected string) {
+		Expect(prettyPrintStoredBytes(storedByes)).To(Equal(expected))
+	},
+		Entry("a few bytes", 1023, "1023.00"),
+		Entry("two KiB", 2*1024, "2.00Ki"),
+		Entry("two and a half KiB", 2*1024+512, "2.50Ki"),
+		Entry("three MiB", 3*1024*1024, "3.00Mi"),
+		Entry("four GiB", 4*1024*1024*1024, "4.00Gi"),
+		Entry("five TiB", 5*1024*1024*1024*1024, "5.00Ti"),
+		Entry("six Pib", 6*1024*1024*1024*1024*1024, "6.00Pi"),
+	)
+
+})