feat: add policy tables in data protection dashboard

cmd/collectors/commonutils.go

@@ -11,6 +11,7 @@ import (
 	"github.com/netapp/harvest/v2/third_party/tidwall/gjson"
 	"log/slog"
 	"os"
+	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -543,3 +544,84 @@ func PopulateIfgroupMetrics(portIfgroupMap map[string]string, portDataMap map[st
 	}
 	return nil
 }
+
+func HandleDuration(value string) float64 {
+	// Example: duration: PT8H35M42S
+	timeDurationRegex := `^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:.\d+)?)S)?$`
+
+	regexTimeDuration := regexp.MustCompile(timeDurationRegex)
+	if match := regexTimeDuration.MatchString(value); match {
+		// example: PT8H35M42S   ==>  30942
+		matches := regexTimeDuration.FindStringSubmatch(value)
+		if matches == nil {
+			return 0
+		}
+
+		seconds := 0.0
+
+		// years
+		// months
+
+		// days
+		if matches[3] != "" {
+			f, err := strconv.ParseFloat(matches[3], 64)
+			if err != nil {
+				fmt.Printf("%v", err)
+				return 0
+			}
+			seconds += f * 24 * 60 * 60
+		}
+
+		// hours
+		if matches[4] != "" {
+			f, err := strconv.ParseFloat(matches[4], 64)
+			if err != nil {
+				fmt.Printf("%v", err)
+				return 0
+			}
+			seconds += f * 60 * 60
+		}
+
+		// minutes
+		if matches[5] != "" {
+			f, err := strconv.ParseFloat(matches[5], 64)
+			if err != nil {
+				fmt.Printf("%v", err)
+				return 0
+			}
+			seconds += f * 60
+		}
+
+		// seconds & milliseconds
+		if matches[6] != "" {
+			f, err := strconv.ParseFloat(matches[6], 64)
+			if err != nil {
+				fmt.Printf("%v", err)
+				return 0
+			}
+			seconds += f
+		}
+		return seconds
+	}
+
+	return 0
+}
+
+// Example: timestamp: 2020-12-02T18:36:19-08:00
+var regexTimeStamp = regexp.MustCompile(
+	`[+-]?\d{4}(-[01]\d(-[0-3]\d(T[0-2]\d:[0-5]\d:?([0-5]\d(\.\d+)?)?[+-][0-2]\d:[0-5]\d?)?)?)?`)
+
+func HandleTimestamp(value string) float64 {
+	var timestamp time.Time
+	var err error
+
+	if match := regexTimeStamp.MatchString(value); match {
+		// example: 2020-12-02T18:36:19-08:00   ==>  1606962979
+		if timestamp, err = time.Parse(time.RFC3339, value); err != nil {
+			fmt.Printf("%v", err)
+			return 0
+		}
+		return float64(timestamp.Unix())
+	}
+	return 0
+}

cmd/collectors/commonutils_test.go

@@ -411,3 +411,65 @@ func Test_SplitVscanName(t *testing.T) {
 		})
 	}
 }
+
+func Test_HandleDuration(t *testing.T) {
+
+	type test struct {
+		timeFieldValue string
+		want           float64
+	}
+
+	var tests = []test{
+		{
+			timeFieldValue: "PT54S",
+			want:           54,
+		},
+		{
+			timeFieldValue: "PT48M",
+			want:           2880,
+		},
+		{
+			timeFieldValue: "P428DT22H45M19S",
+			want:           37061119,
+		},
+		{
+			timeFieldValue: "PT8H35M42S",
+			want:           30942,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.timeFieldValue, func(t *testing.T) {
+			if got := HandleDuration(tt.timeFieldValue); got != tt.want {
+				t.Errorf("actual value = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_HandleTimestamp(t *testing.T) {
+
+	type test struct {
+		timeFieldValue string
+		want           float64
+	}
+
+	var tests = []test{
+		{
+			timeFieldValue: "2020-12-02T18:36:19-08:00",
+			want:           1606962979,
+		},
+		{
+			timeFieldValue: "2022-01-31T04:05:02-05:00",
+			want:           1643619902,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.timeFieldValue, func(t *testing.T) {
+			if got := HandleTimestamp(tt.timeFieldValue); got != tt.want {
+				t.Errorf("actual value = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

cmd/collectors/rest/plugins/clusterschedule/clusterschedule.go

@@ -0,0 +1,60 @@
+package clusterschedule
+
+import (
+	"github.com/netapp/harvest/v2/cmd/collectors"
+	"github.com/netapp/harvest/v2/cmd/poller/plugin"
+	"github.com/netapp/harvest/v2/pkg/matrix"
+	"github.com/netapp/harvest/v2/pkg/util"
+	"github.com/netapp/harvest/v2/third_party/tidwall/gjson"
+	"strconv"
+	"strings"
+)
+
+type ClusterScheule struct {
+	*plugin.AbstractPlugin
+}
+
+func New(p *plugin.AbstractPlugin) plugin.Plugin {
+	return &ClusterScheule{AbstractPlugin: p}
+}
+
+func (c *ClusterScheule) Run(dataMap map[string]*matrix.Matrix) ([]*matrix.Matrix, *util.Metadata, error) {
+	for _, instance := range dataMap[c.Object].GetInstances() {
+		intervalVal := collectors.HandleDuration(instance.GetLabel("interval"))
+		instance.SetLabel("interval", strconv.FormatFloat(intervalVal, 'f', -1, 64))
+
+		cron := instance.GetLabel("cron")
+		updateDetailsJSON := gjson.Result{Type: gjson.JSON, Raw: cron}
+		var cronVal, minStr, hourStr, weekDayStr string
+		if minutes := updateDetailsJSON.Get("minutes"); minutes.Exists() {
+			for _, m := range minutes.Array() {
+				minStr = minStr + m.String() + ", "
+			}
+			minStr = strings.TrimSuffix(minStr, ", ")
+		}
+		if hours := updateDetailsJSON.Get("hours"); hours.Exists() {
+			for _, h := range hours.Array() {
+				hourStr = hourStr + h.String() + ", "
+			}
+			hourStr = strings.TrimSuffix(hourStr, ", ")
+		}
+		if weekdays := updateDetailsJSON.Get("weekdays"); weekdays.Exists() {
+			for _, w := range weekdays.Array() {
+				weekDayStr = weekDayStr + w.String() + ", "
+			}
+			weekDayStr = strings.TrimSuffix(weekDayStr, ", ")
+		}
+
+		if minStr != "" {
+			cronVal = cronVal + "minutes: " + "[" + minStr + "] "
+		}
+		if hourStr != "" {
+			cronVal = cronVal + "hours: " + "[" + hourStr + "] "
+		}
+		if weekDayStr != "" {
+			cronVal = cronVal + "weekdays: " + "[" + weekDayStr + "]"
+		}
+		instance.SetLabel("cron", cronVal)
+	}
+	return nil, nil, nil
+}

cmd/collectors/rest/rest.go

@@ -7,6 +7,7 @@ import (
 	"github.com/netapp/harvest/v2/cmd/collectors/rest/plugins/aggregate"
 	"github.com/netapp/harvest/v2/cmd/collectors/rest/plugins/certificate"
 	"github.com/netapp/harvest/v2/cmd/collectors/rest/plugins/cluster"
+	"github.com/netapp/harvest/v2/cmd/collectors/rest/plugins/clusterschedule"
 	"github.com/netapp/harvest/v2/cmd/collectors/rest/plugins/clustersoftware"
 	"github.com/netapp/harvest/v2/cmd/collectors/rest/plugins/disk"
 	"github.com/netapp/harvest/v2/cmd/collectors/rest/plugins/health"
@@ -475,6 +476,8 @@ func (r *Rest) LoadPlugin(kind string, abc *plugin.AbstractPlugin) plugin.Plugin
 		return aggregate.New(abc)
 	case "Cluster":
 		return cluster.New(abc)
+	case "ClusterSchedule":
+		return clusterschedule.New(abc)
 	case "ClusterSoftware":
 		return clustersoftware.New(abc)
 	case "Disk":
@@ -633,9 +636,9 @@ func (r *Rest) HandleResults(mat *matrix.Matrix, result []gjson.Result, prop *pr
 				var floatValue float64
 				switch metric.MetricType {
 				case "duration":
-					floatValue = HandleDuration(f.ClonedString())
+					floatValue = collectors.HandleDuration(f.ClonedString())
 				case "timestamp":
-					floatValue = HandleTimestamp(f.ClonedString())
+					floatValue = collectors.HandleTimestamp(f.ClonedString())
 				case "":
 					floatValue = f.Float()
 				default:

cmd/collectors/rest/templating.go

@@ -1,18 +1,15 @@
 package rest
 
 import (
-	"fmt"
 	"github.com/netapp/harvest/v2/cmd/collectors"
 	"github.com/netapp/harvest/v2/pkg/errs"
 	"github.com/netapp/harvest/v2/pkg/tree/node"
 	"github.com/netapp/harvest/v2/pkg/util"
 	"log/slog"
 	"maps"
-	"regexp"
 	"slices"
 	"strconv"
 	"strings"
-	"time"
 )
 
 func (r *Rest) LoadTemplate() (string, error) {
@@ -94,87 +91,6 @@ func (r *Rest) InitCache() error {
 	return nil
 }
 
-func HandleDuration(value string) float64 {
-	// Example: duration: PT8H35M42S
-	timeDurationRegex := `^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:.\d+)?)S)?$`
-
-	regexTimeDuration := regexp.MustCompile(timeDurationRegex)
-	if match := regexTimeDuration.MatchString(value); match {
-		// example: PT8H35M42S   ==>  30942
-		matches := regexTimeDuration.FindStringSubmatch(value)
-		if matches == nil {
-			return 0
-		}
-
-		seconds := 0.0
-
-		// years
-		// months
-
-		// days
-		if matches[3] != "" {
-			f, err := strconv.ParseFloat(matches[3], 64)
-			if err != nil {
-				fmt.Printf("%v", err)
-				return 0
-			}
-			seconds += f * 24 * 60 * 60
-		}
-
-		// hours
-		if matches[4] != "" {
-			f, err := strconv.ParseFloat(matches[4], 64)
-			if err != nil {
-				fmt.Printf("%v", err)
-				return 0
-			}
-			seconds += f * 60 * 60
-		}
-
-		// minutes
-		if matches[5] != "" {
-			f, err := strconv.ParseFloat(matches[5], 64)
-			if err != nil {
-				fmt.Printf("%v", err)
-				return 0
-			}
-			seconds += f * 60
-		}
-
-		// seconds & milliseconds
-		if matches[6] != "" {
-			f, err := strconv.ParseFloat(matches[6], 64)
-			if err != nil {
-				fmt.Printf("%v", err)
-				return 0
-			}
-			seconds += f
-		}
-		return seconds
-	}
-
-	return 0
-}
-
-// Example: timestamp: 2020-12-02T18:36:19-08:00
-var regexTimeStamp = regexp.MustCompile(
-	`[+-]?\d{4}(-[01]\d(-[0-3]\d(T[0-2]\d:[0-5]\d:?([0-5]\d(\.\d+)?)?[+-][0-2]\d:[0-5]\d?)?)?)?`)
-
-func HandleTimestamp(value string) float64 {
-	var timestamp time.Time
-	var err error
-
-	if match := regexTimeStamp.MatchString(value); match {
-		// example: 2020-12-02T18:36:19-08:00   ==>  1606962979
-		if timestamp, err = time.Parse(time.RFC3339, value); err != nil {
-			fmt.Printf("%v", err)
-			return 0
-		}
-		return float64(timestamp.Unix())
-	}
-	return 0
-}
-
 func (r *Rest) ParseRestCounters(counter *node.Node, prop *prop) {
 	var (
 		display, name, kind, metricType string