Update QP Scheduled Change event drain time, README, taint type

Author: AustinSiu

pkg/monitor/sqsevent/scheduled-event.go renamed to pkg/monitor/sqsevent/scheduled-change-event.go

@@ -16,7 +16,6 @@ package sqsevent
 import (
 	"encoding/json"
 	"fmt"
-	"strings"
 	"time"
 
 	"github.com/aws/aws-node-termination-handler/pkg/monitor"
@@ -61,49 +60,45 @@ type AffectedEntity struct {
 	EntityValue string `json:"entityValue"`
 }
 
-// ScheduledEventDetail holds the event details for AWS Health scheduled EC2 change events from Amazon EventBridge
-type ScheduledEventDetail struct {
+// ScheduledChangeEventDetail holds the event details for AWS Health scheduled EC2 change events from Amazon EventBridge
+type ScheduledChangeEventDetail struct {
 	EventTypeCategory string           `json:"eventTypeCategory"`
 	Service           string           `json:"service"`
 	AffectedEntities  []AffectedEntity `json:"affectedEntities"`
 }
 
-const supportedEventCategoryTypes = "scheduledChange"
-
 func (m SQSMonitor) scheduledEventToInterruptionEvents(event EventBridgeEvent, message *sqs.Message) ([]InterruptionEventWrapper, error) {
-	scheduledEventDetail := &ScheduledEventDetail{}
+	scheduledChangeEventDetail := &ScheduledChangeEventDetail{}
 
-	if err := json.Unmarshal(event.Detail, scheduledEventDetail); err != nil {
+	if err := json.Unmarshal(event.Detail, scheduledChangeEventDetail); err != nil {
 		return nil, err
 	}
 
-	if scheduledEventDetail.Service != "EC2" {
-		return nil, fmt.Errorf("events from Amazon EventBridge for service (%s) are not supported", scheduledEventDetail.Service)
+	if scheduledChangeEventDetail.Service != "EC2" {
+		return nil, fmt.Errorf("events from Amazon EventBridge for service (%s) are not supported", scheduledChangeEventDetail.Service)
 	}
 
-	if !strings.Contains(supportedEventCategoryTypes, scheduledEventDetail.EventTypeCategory) {
-		return nil, fmt.Errorf("events from Amazon EventBridge with EventTypeCategory (%s) are not supported", scheduledEventDetail.EventTypeCategory)
+	if scheduledChangeEventDetail.EventTypeCategory != "scheduledChange" {
+		return nil, fmt.Errorf("events from Amazon EventBridge with EventTypeCategory (%s) are not supported", scheduledChangeEventDetail.EventTypeCategory)
 	}
 
-	// interruptionEventWrappers := make([]InterruptionEventWrapper, len(event.Resources))
 	interruptionEventWrappers := []InterruptionEventWrapper{}
 
-	for _, affectedEntity := range scheduledEventDetail.AffectedEntities {
+	for _, affectedEntity := range scheduledChangeEventDetail.AffectedEntities {
 		nodeName, err := m.retrieveNodeName(affectedEntity.EntityValue)
 		if err != nil {
-			// interruptionEventWrappers[i] = InterruptionEventWrapper{nil, err}
 			interruptionEventWrappers = append(interruptionEventWrappers, InterruptionEventWrapper{nil, err})
 			continue
 		}
 		asgName, _ := m.retrieveAutoScalingGroupName(affectedEntity.EntityValue)
 		interruptionEvent := monitor.InterruptionEvent{
-			EventID:              fmt.Sprintf("aws-health-maintenance-event-%x", event.ID),
+			EventID:              fmt.Sprintf("aws-health-scheduled-change-event-%x", event.ID),
 			Kind:                 SQSTerminateKind,
 			AutoScalingGroupName: asgName,
 			StartTime:            time.Now(),
 			NodeName:             nodeName,
 			InstanceID:           affectedEntity.EntityValue,
-			Description:          fmt.Sprintf("AWS Health maintenance event received. Instance %s will be interrupted at %s \n", affectedEntity.EntityValue, event.getTime()),
+			Description:          fmt.Sprintf("AWS Health scheduled change event received. Instance %s will be interrupted at %s \n", affectedEntity.EntityValue, event.getTime()),
 		}
 		interruptionEvent.PostDrainTask = func(interruptionEvent monitor.InterruptionEvent, n node.Node) error {
 			errs := m.deleteMessages([]*sqs.Message{message})
@@ -120,9 +115,7 @@ func (m SQSMonitor) scheduledEventToInterruptionEvents(event EventBridgeEvent, m
 			return nil
 		}
 
-		// interruptionEventWrappers[i] = InterruptionEventWrapper{&interruptionEvent, nil}
 		interruptionEventWrappers = append(interruptionEventWrappers, InterruptionEventWrapper{&interruptionEvent, nil})
-
 	}
 
 	return interruptionEventWrappers, nil

pkg/monitor/sqsevent/sqs-monitor.go

@@ -85,7 +85,7 @@ func (m SQSMonitor) Monitor() error {
 				log.Warn().Err(eventWrapper.Err).Msg("dropping interruption event for an already terminated node")
 				if (i == len(interruptionEventWrappers)-1) && (failedInterruptionEventsCount == len(interruptionEventWrappers)-1) {
 					// Log that all events failed, and delete the message from the queue
-					log.Warn().Err(eventWrapper.Err).Msg("all interruption events failed, moving to delete message from queue")
+					log.Warn().Err(eventWrapper.Err).Msg("all interruption events erred during processing, moving to delete message from queue")
 					deletionErrs := m.deleteMessages([]*sqs.Message{message})
 					if len(deletionErrs) > 0 {
 						log.Err(deletionErrs[0]).Msg("error deleting queue event for already terminated node(s)")
@@ -95,7 +95,7 @@ func (m SQSMonitor) Monitor() error {
 
 			case eventWrapper.Err != nil:
 				// Log errors and record as failed events
-				log.Warn().Err(eventWrapper.Err).Msg("ignoring interruption event due to error") // is this what I want? Or break out specific unsupported error state?
+				log.Warn().Err(eventWrapper.Err).Msg("ignoring interruption event due to an error")
 				failedInterruptionEventsCount++
 
 			case eventWrapper.Err == nil && eventWrapper.InterruptionEvent != nil && eventWrapper.InterruptionEvent.Kind == SQSTerminateKind:
@@ -266,7 +266,7 @@ func (m SQSMonitor) retrieveNodeName(instanceID string) (string, error) {
 // isInstanceManaged returns whether the instance specified should be managed by node termination handler
 func (m SQSMonitor) isInstanceManaged(instanceID string) (bool, error) {
 	if instanceID == "" {
-		return false, fmt.Errorf("Instance ID was empty when calling isInstanceManaged")
+		return false, fmt.Errorf("instance ID was empty when calling isInstanceManaged")
 	}
 	asgName, err := m.retrieveAutoScalingGroupName(instanceID)
 	if asgName == "" {