Implement daily schedule sp

policy/subpolicy/daily_schedule_subpolicy.go

@@ -0,0 +1,105 @@
+package subpolicy
+
+import (
+	"fmt"
+
+	"github.com/datagovsg/nomad-parametric-autoscaler/resources"
+	"github.com/datagovsg/nomad-parametric-autoscaler/utils"
+	"github.com/mitchellh/mapstructure"
+)
+
+// DailyScheduleSubPolicy is a subpolicy that extends the `SubPolicy` interface
+// and takes in the GenericSubpolicy struct
+type DailyScheduleSubPolicy struct {
+	Name             string
+	managedResources []resources.Resource
+	metadata         DailyScheduleSubPolicyMetadata
+}
+
+type ScalingWindow struct {
+	Begin int `json:"Begin"`
+	End   int `json:"End"`
+	Count int `json:"Count"`
+}
+
+func (sw ScalingWindow) IsInWindow(time int) bool {
+	return sw.Begin <= time && time < sw.End
+}
+
+// DailyScheduleSubPolicyMetadata represents metadata unique to DailyScheduleSubPolicy
+// define windows of scaling through the day and a fallback default
+type DailyScheduleSubPolicyMetadata struct {
+	Default  *int            `json:"Default"`
+	Schedule []ScalingWindow `json:"Schedule"`
+}
+
+func NewDailyScheduleSubPolicy(name string, mr []resources.Resource, meta interface{}) (*DailyScheduleSubPolicy, error) {
+	var decoded DailyScheduleSubPolicyMetadata
+	mapstructure.Decode(meta, &decoded)
+
+	if err := verifyDailyScheduleMetadata(decoded); err != nil {
+		return nil, err
+	}
+
+	return &DailyScheduleSubPolicy{
+		Name:             name,
+		managedResources: mr,
+		metadata:         decoded,
+	}, nil
+}
+
+func verifyDailyScheduleMetadata(meta DailyScheduleSubPolicyMetadata) error {
+	if meta.Default == nil {
+		return fmt.Errorf("Default missing from DailyScheduleSubPolicyMetadata")
+	}
+
+	if meta.Schedule == nil {
+		return fmt.Errorf("Schedule missing from DailyScheduleSubPolicyMetadata")
+	}
+
+	return nil
+}
+
+func (dssp DailyScheduleSubPolicy) GetManagedResources() []resources.Resource {
+	return dssp.managedResources
+}
+
+func (dssp *DailyScheduleSubPolicy) RecommendCount() map[resources.Resource]int {
+	currentTime := utils.GetCurrentTimeHHMM()
+
+	output := make(map[resources.Resource]int)
+
+	for _, resc := range dssp.managedResources {
+		var recommendation int
+		windowExist := false
+
+		// uses count of the first window that current time falls into
+		for _, sw := range dssp.metadata.Schedule {
+			if sw.IsInWindow(currentTime) {
+				recommendation = sw.Count
+				windowExist = true
+				break
+			}
+		}
+
+		if !windowExist {
+			recommendation = *dssp.metadata.Default
+		}
+
+		output[resc] = recommendation
+	}
+	return output
+}
+
+func (dssp *DailyScheduleSubPolicy) DeriveGenericSubpolicy() GenericSubPolicy {
+	resourceNameList := make([]string, 0)
+	for _, r := range dssp.managedResources {
+		resourceNameList = append(resourceNameList, r.ResourceName())
+	}
+
+	return GenericSubPolicy{
+		Name:             dssp.Name,
+		ManagedResources: resourceNameList,
+		Metadata:         dssp.metadata,
+	}
+}

policy/subpolicy/daily_schedule_subpolicy_test.go

@@ -0,0 +1,42 @@
+package subpolicy
+
+import (
+	"testing"
+
+	"github.com/datagovsg/nomad-parametric-autoscaler/resources"
+)
+
+func TestDecodingDailyScheduleSP(t *testing.T) {
+	input := map[string]interface{}{
+		"Default": 9.1,
+		"Schedule": []map[string]int{
+			{"Begin": 1, "End": 3, "Count": 3},
+			{"Begin": 3, "End": 4, "Count": 3},
+		},
+	}
+	emptyList := make([]resources.Resource, 0)
+	dssp, err := NewDailyScheduleSubPolicy("a", emptyList, input)
+	if err != nil {
+		t.Errorf("Expected to have no errors")
+	}
+
+	if *dssp.metadata.Default != 9 {
+		t.Errorf("Expected floats to be truncated")
+	}
+}
+
+func TestWindowChecking(t *testing.T) {
+	sw := ScalingWindow{
+		Begin: 0000,
+		End:   0200,
+		Count: 10,
+	}
+
+	if !sw.IsInWindow(0000) {
+		t.Errorf("Expected 000hrs to be within window")
+	}
+
+	if sw.IsInWindow(0200) {
+		t.Errorf("Expected 0200hrs to be out of window")
+	}
+}

policy/subpolicy/office_hour_subpolicy.go

@@ -2,9 +2,9 @@ package subpolicy
 
 import (
 	"fmt"
-	"time"
 
 	"github.com/datagovsg/nomad-parametric-autoscaler/resources"
+	"github.com/datagovsg/nomad-parametric-autoscaler/utils"
 	"github.com/mitchellh/mapstructure"
 )
 
@@ -63,7 +63,7 @@ func (ohsp OfficeHourSubPolicy) GetManagedResources() []resources.Resource {
 }
 
 func (ohsp *OfficeHourSubPolicy) RecommendCount() map[resources.Resource]int {
-	currentHour := time.Now().UTC().Hour() + 8
+	currentHour := utils.GetCurrentTime().Hour()
 
 	output := make(map[resources.Resource]int)
 

policy/subpolicy/subpolicy.go

@@ -42,6 +42,12 @@ func CreateSpecificSubpolicy(gsp GenericSubPolicy, mr []resources.Resource) (Sub
 			return nil, err
 		}
 		return sp, nil
+	case types.DailySchedule:
+		sp, err := NewDailyScheduleSubPolicy(gsp.Name, mr, gsp.Metadata)
+		if err != nil {
+			return nil, err
+		}
+		return sp, nil
 	default:
 		return nil, fmt.Errorf("%v is not a valid subpolicy", gsp.Name)
 	}

types/constants.go

@@ -2,12 +2,13 @@ package types
 
 const CoreRatio = "CoreRatio"
 const OfficeHour = "OfficeHour"
+const DailySchedule = "DailySchedule"
 
 const ChangeTypeMultiply = "multiply"
 const ChangeTypeUntil = "until"
 
 const EnsembleConservative = "Conservative"
 const EnsembleAverage = "Average"
 
-var SubpolicyList = []string{CoreRatio, OfficeHour}
+var SubpolicyList = []string{CoreRatio, OfficeHour, DailySchedule}
 var EnsemblerList = []string{EnsembleConservative, EnsembleAverage}

utils/env.go

@@ -0,0 +1,10 @@
+package utils
+
+import "os"
+
+func GetEnv(key, fallback string) string {
+	if value, ok := os.LookupEnv(key); ok {
+		return value
+	}
+	return fallback
+}

utils/time.go

@@ -0,0 +1,18 @@
+package utils
+
+import (
+	"time"
+)
+
+func GetCurrentTime() time.Time {
+	loc, err := time.LoadLocation(GetEnv("TZ", "Asia/Singapore"))
+	if err != nil {
+		return time.Now().UTC().Add(8 * time.Hour)
+	}
+	return time.Now().In(loc)
+}
+
+func GetCurrentTimeHHMM() int {
+	now := GetCurrentTime()
+	return (now.Hour())*100 + now.Minute()
+}