select instance 'MarketType' option

Author: athiruma

Diff for: pkg/actuators/machine/instances.go

@@ -447,6 +447,12 @@ func launchInstance(machine *machinev1beta1.Machine, machineProviderConfig *mach
 		return nil, err
 	}
 
+	instanceMarketOptions, err := getInstanceMarketOptionsRequest(machineProviderConfig)
+
+	if err != nil {
+		return nil, err
+	}
+
 	inputConfig := ec2.RunInstancesInput{
 		ImageId:      amiID,
 		InstanceType: aws.String(machineProviderConfig.InstanceType),
@@ -460,7 +466,7 @@ func launchInstance(machine *machinev1beta1.Machine, machineProviderConfig *mach
 		UserData:                         &userDataEnc,
 		Placement:                        placement,
 		MetadataOptions:                  getInstanceMetadataOptionsRequest(machineProviderConfig),
-		InstanceMarketOptions:            getInstanceMarketOptionsRequest(machineProviderConfig),
+		InstanceMarketOptions:            instanceMarketOptions,
 		CapacityReservationSpecification: capacityReservationSpecification,
 	}
 
@@ -566,34 +572,56 @@ func sortInstances(instances []*ec2.Instance) {
 	sort.Sort(instanceList(instances))
 }
 
-func getInstanceMarketOptionsRequest(providerConfig *machinev1beta1.AWSMachineProviderConfig) *ec2.InstanceMarketOptionsRequest {
-	if providerConfig.SpotMarketOptions == nil {
-		// Instance is not a Spot instance
-		return nil
+func getInstanceMarketOptionsRequest(providerConfig *machinev1beta1.AWSMachineProviderConfig) (*ec2.InstanceMarketOptionsRequest, error) {
+	if providerConfig.MarketType != "" && providerConfig.MarketType == machinev1beta1.MarketTypeCapacityBlock && providerConfig.SpotMarketOptions != nil {
+		return nil, errors.New("can't create spot capacity-blocks, remove spot market request")
 	}
 
-	// Set required values for Spot instances
-	spotOptions := &ec2.SpotMarketOptions{}
-	// The following two options ensure that:
-	// - If an instance is interrupted, it is terminated rather than hibernating or stopping
-	// - No replacement instance will be created if the instance is interrupted
-	// - If the spot request cannot immediately be fulfilled, it will not be created
-	// This behaviour should satisfy the 1:1 mapping of Machines to Instances as
-	// assumed by the machine API.
-	spotOptions.SetInstanceInterruptionBehavior(ec2.InstanceInterruptionBehaviorTerminate)
-	spotOptions.SetSpotInstanceType(ec2.SpotInstanceTypeOneTime)
+	// Infer MarketType if not explicitly set
+	if providerConfig.SpotMarketOptions != nil && providerConfig.MarketType == "" {
+		providerConfig.MarketType = machinev1beta1.MarketTypeSpot
+	}
 
-	// Set the MaxPrice if specified by the providerConfig
-	maxPrice := providerConfig.SpotMarketOptions.MaxPrice
-	if maxPrice != nil && *maxPrice != "" {
-		spotOptions.SetMaxPrice(*maxPrice)
+	if providerConfig.MarketType == "" {
+		providerConfig.MarketType = machinev1beta1.MarketTypeOnDemand
 	}
 
-	instanceMarketOptionsRequest := &ec2.InstanceMarketOptionsRequest{}
-	instanceMarketOptionsRequest.SetMarketType(ec2.MarketTypeSpot)
-	instanceMarketOptionsRequest.SetSpotOptions(spotOptions)
+	switch providerConfig.MarketType {
+	case machinev1beta1.MarketTypeCapacityBlock:
+		if providerConfig.CapacityReservationID == "" {
+			return nil, errors.New("capacityReservationID is required when CapacityBlock is enabled")
+		}
+		return &ec2.InstanceMarketOptionsRequest{
+			MarketType: aws.String(ec2.MarketTypeCapacityBlock),
+		}, nil
+	case machinev1beta1.MarketTypeSpot:
+		// Set required values for Spot instances
+		spotOpts := &ec2.SpotMarketOptions{
+			// The following two options ensure that:
+			// - If an instance is interrupted, it is terminated rather than hibernating or stopping
+			// - No replacement instance will be created if the instance is interrupted
+			// - If the spot request cannot immediately be fulfilled, it will not be created
+			// This behaviour should satisfy the 1:1 mapping of Machines to Instances as
+			// assumed by the Cluster API.
+			InstanceInterruptionBehavior: aws.String(ec2.InstanceInterruptionBehaviorTerminate),
+			SpotInstanceType:             aws.String(ec2.SpotInstanceTypeOneTime),
+		}
+
+		if maxPrice := aws.StringValue(providerConfig.SpotMarketOptions.MaxPrice); maxPrice != "" {
+			spotOpts.MaxPrice = aws.String(maxPrice)
+		}
 
-	return instanceMarketOptionsRequest
+		return &ec2.InstanceMarketOptionsRequest{
+			MarketType:  aws.String(ec2.MarketTypeSpot),
+			SpotOptions: spotOpts,
+		}, nil
+	case machinev1beta1.MarketTypeOnDemand:
+		// Instance is on-demand or empty
+		return nil, nil
+	default:
+		// Invalid MarketType provided
+		return nil, fmt.Errorf("invalid MarketType %q", providerConfig.MarketType)
+	}
 }
 
 // constructInstancePlacement configures the placement options for the RunInstances request

Diff for: pkg/actuators/machine/instances_test.go

@@ -1227,31 +1227,39 @@ func TestSortInstances(t *testing.T) {
 }
 
 func TestGetInstanceMarketOptionsRequest(t *testing.T) {
+	mockCapacityReservationID := "cr-123"
 	testCases := []struct {
-		name              string
-		spotMarketOptions *machinev1beta1.SpotMarketOptions
-		expectedRequest   *ec2.InstanceMarketOptionsRequest
+		name            string
+		providerConfig  *machinev1beta1.AWSMachineProviderConfig
+		expectedRequest *ec2.InstanceMarketOptionsRequest
+		wantErr         bool
 	}{
 		{
-			name:              "with no Spot options specified",
-			spotMarketOptions: nil,
-			expectedRequest:   nil,
+			name:            "with no Spot options specified",
+			providerConfig:  &machinev1beta1.AWSMachineProviderConfig{},
+			expectedRequest: nil,
+			wantErr:         false,
 		},
 		{
-			name:              "with an empty Spot options specified",
-			spotMarketOptions: &machinev1beta1.SpotMarketOptions{},
+			name: "with an empty Spot options specified",
+			providerConfig: &machinev1beta1.AWSMachineProviderConfig{
+				SpotMarketOptions: &machinev1beta1.SpotMarketOptions{},
+			},
 			expectedRequest: &ec2.InstanceMarketOptionsRequest{
 				MarketType: aws.String(ec2.MarketTypeSpot),
 				SpotOptions: &ec2.SpotMarketOptions{
 					InstanceInterruptionBehavior: aws.String(ec2.InstanceInterruptionBehaviorTerminate),
 					SpotInstanceType:             aws.String(ec2.SpotInstanceTypeOneTime),
 				},
 			},
+			wantErr: false,
 		},
 		{
 			name: "with an empty MaxPrice specified",
-			spotMarketOptions: &machinev1beta1.SpotMarketOptions{
-				MaxPrice: aws.String(""),
+			providerConfig: &machinev1beta1.AWSMachineProviderConfig{
+				SpotMarketOptions: &machinev1beta1.SpotMarketOptions{
+					MaxPrice: aws.String(""),
+				},
 			},
 			expectedRequest: &ec2.InstanceMarketOptionsRequest{
 				MarketType: aws.String(ec2.MarketTypeSpot),
@@ -1260,11 +1268,14 @@ func TestGetInstanceMarketOptionsRequest(t *testing.T) {
 					SpotInstanceType:             aws.String(ec2.SpotInstanceTypeOneTime),
 				},
 			},
+			wantErr: false,
 		},
 		{
 			name: "with a valid MaxPrice specified",
-			spotMarketOptions: &machinev1beta1.SpotMarketOptions{
-				MaxPrice: aws.String("0.01"),
+			providerConfig: &machinev1beta1.AWSMachineProviderConfig{
+				SpotMarketOptions: &machinev1beta1.SpotMarketOptions{
+					MaxPrice: aws.String("0.01"),
+				},
 			},
 			expectedRequest: &ec2.InstanceMarketOptionsRequest{
 				MarketType: aws.String(ec2.MarketTypeSpot),
@@ -1274,18 +1285,56 @@ func TestGetInstanceMarketOptionsRequest(t *testing.T) {
 					MaxPrice:                     aws.String("0.01"),
 				},
 			},
+			wantErr: false,
+		},
+		{
+			name:            "invalid MarketType specified",
+			expectedRequest: nil,
+			providerConfig: &machinev1beta1.AWSMachineProviderConfig{
+				MarketType: machinev1beta1.MarketType("invalid"),
+			},
+			wantErr: true,
+		},
+		{
+			name: "with a MarketType to MarketTypeCapacityBlock specified with capacityReservationID set to nil",
+			providerConfig: &machinev1beta1.AWSMachineProviderConfig{
+				MarketType:            machinev1beta1.MarketTypeCapacityBlock,
+				CapacityReservationID: "",
+			},
+			expectedRequest: nil,
+			wantErr:         true,
+		},
+		{
+			name: "with a MarketType to MarketTypeCapacityBlock with capacityReservationID set to nil",
+			providerConfig: &machinev1beta1.AWSMachineProviderConfig{
+				MarketType:            machinev1beta1.MarketTypeCapacityBlock,
+				CapacityReservationID: mockCapacityReservationID,
+			},
+			expectedRequest: &ec2.InstanceMarketOptionsRequest{
+				MarketType: aws.String(ec2.MarketTypeCapacityBlock),
+			},
+			wantErr: false,
+		},
+		{
+			name: "with a MarketType to MarketTypeCapacityBlock set with capacityReservationID set and empty Spot options specified",
+			providerConfig: &machinev1beta1.AWSMachineProviderConfig{
+				MarketType:            machinev1beta1.MarketTypeCapacityBlock,
+				CapacityReservationID: mockCapacityReservationID,
+				SpotMarketOptions:     &machinev1beta1.SpotMarketOptions{},
+			},
+			wantErr: true,
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			providerConfig := &machinev1beta1.AWSMachineProviderConfig{
-				SpotMarketOptions: tc.spotMarketOptions,
-			}
+			g := gmg.NewWithT(t)
 
-			request := getInstanceMarketOptionsRequest(providerConfig)
-			if !reflect.DeepEqual(request, tc.expectedRequest) {
-				t.Errorf("Case: %s. Got: %v, expected: %v", tc.name, request, tc.expectedRequest)
+			request, err := getInstanceMarketOptionsRequest(tc.providerConfig)
+			if err == nil {
+				g.Expect(request).To(gmg.BeEquivalentTo(tc.expectedRequest))
+			} else {
+				g.Expect(err).To(gmg.HaveOccurred())
 			}
 		})
 	}