Added resource and data source for aws ec2 capacity block reservation.

internal/service/ec2/ec2_capacity_block_offering_data_source.go

@@ -0,0 +1,135 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package ec2
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-provider-aws/internal/create"
+	"github.com/hashicorp/terraform-provider-aws/names"
+	"time"
+
+	aws_sdkv2 "github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+	"github.com/hashicorp/terraform-provider-aws/internal/conns"
+	"github.com/hashicorp/terraform-provider-aws/internal/errs/sdkdiag"
+)
+
+const (
+	ResNameCapacityBlockOffering = "Capacity Block Offering"
+)
+
+// @SDKDataSource("aws_ec2_capacity_block_offering")
+func DataSourceCapacityBlockOffering() *schema.Resource {
+	return &schema.Resource{
+		ReadWithoutTimeout: dataSourceCapacityBlockOfferingRead,
+		Schema: map[string]*schema.Schema{
+			"availability_zone": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"capacity_duration": {
+				Type:     schema.TypeInt,
+				Required: true,
+			},
+			"currency_code": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"end_date": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: validation.IsRFC3339Time,
+			},
+			"instance_count": {
+				Type:     schema.TypeInt,
+				Required: true,
+			},
+			"instance_type": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"start_date": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: validation.IsRFC3339Time,
+			},
+			"tenancy": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"upfront_fee": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func dataSourceCapacityBlockOfferingRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	var diags diag.Diagnostics
+	conn := meta.(*conns.AWSClient).EC2Conn(ctx)
+
+	input := &ec2.DescribeCapacityBlockOfferingsInput{
+		CapacityDurationHours: aws.Int64(int64(d.Get("capacity_duration").(int))),
+		InstanceCount:         aws.Int64(int64(d.Get("instance_count").(int))),
+		InstanceType:          aws.String(d.Get("instance_type").(string)),
+	}
+
+	if v, ok := d.GetOk("start_date"); ok {
+		v, _ := time.Parse(time.RFC3339, v.(string))
+		input.StartDateRange = aws.Time(v)
+	}
+
+	if v, ok := d.GetOk("end_date"); ok {
+		v, _ := time.Parse(time.RFC3339, v.(string))
+		input.EndDateRange = aws.Time(v)
+	}
+
+	output, err := conn.DescribeCapacityBlockOfferingsWithContext(ctx, input)
+
+	if err != nil {
+		return create.DiagError(names.EC2, create.ErrActionReading, ResNameCapacityBlockOffering, "unknown", err)
+	}
+
+	if len(output.CapacityBlockOfferings) == 0 {
+		return diag.Errorf("no %s %s found matching criteria; try different search", names.EC2, ResNameCapacityBlockOffering)
+	}
+
+	if len(output.CapacityBlockOfferings) > 1 {
+		return diag.Errorf("More than one %s %s found matching criteria; try different search", names.EC2, ResNameCapacityBlockOffering)
+	}
+
+	if err != nil {
+
+		return sdkdiag.AppendErrorf(diags, "creating EC2 Capacity Reservation: %s", err)
+	}
+
+	cbo := output.CapacityBlockOfferings[0]
+	{
+		d.SetId(aws_sdkv2.ToString(cbo.CapacityBlockOfferingId))
+		d.Set("availability_zone", cbo.AvailabilityZone)
+		d.Set("capacity_duration", cbo.CapacityBlockDurationHours)
+		d.Set("currency_code", cbo.CurrencyCode)
+		if cbo.EndDate != nil {
+			d.Set("end_date", aws.TimeValue(cbo.EndDate).Format(time.RFC3339))
+		} else {
+			d.Set("end_date", nil)
+		}
+		d.Set("instance_count", cbo.InstanceCount)
+		d.Set("instance_type", cbo.InstanceType)
+		if cbo.StartDate != nil {
+			d.Set("start_date", aws.TimeValue(cbo.StartDate).Format(time.RFC3339))
+		} else {
+			d.Set("start_date", nil)
+		}
+		d.Set("tenancy", cbo.Tenancy)
+		d.Set("upfront_fee", cbo.UpfrontFee)
+	}
+
+	return nil
+}

internal/service/ec2/ec2_capacity_block_offering_data_source_test.go

@@ -0,0 +1,54 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package ec2
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-provider-aws/internal/acctest"
+	"github.com/hashicorp/terraform-provider-aws/names"
+)
+
+func TestAccEC2CapacityBlockOffering_basic(t *testing.T) {
+	ctx := acctest.Context(t)
+	dataSourceName := "data.aws_ec2_capacity_block_offering.test"
+	startDate := time.Now().UTC().Add(25 * time.Hour).Format(time.RFC3339)
+	endDate := time.Now().UTC().Add(720 * time.Hour).Format(time.RFC3339)
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             nil,
+		ErrorCheck:               acctest.ErrorCheck(t, names.EC2),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCapacityBlockOfferingConfig_basic(startDate, endDate),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrSet(dataSourceName, "availability_zone"),
+					resource.TestCheckResourceAttr(dataSourceName, "capacity_duration", "24"),
+					resource.TestCheckResourceAttr(dataSourceName, "instance_count", "1"),
+					resource.TestCheckResourceAttr(dataSourceName, "instance_type", "p4d.24xlarge"),
+					resource.TestCheckResourceAttrSet(dataSourceName, "id"),
+					resource.TestCheckResourceAttr(dataSourceName, "tenancy", "default"),
+					resource.TestCheckResourceAttrSet(dataSourceName, "upfront_fee"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCapacityBlockOfferingConfig_basic(startDate, endDate string) string {
+	return fmt.Sprintf(`
+data "aws_ec2_capacity_block_offering" "test" {
+  instance_type = "p4d.24xlarge"
+  capacity_duration = 24
+  instance_count = 1
+  start_date = %[1]q
+  end_date = %[2]q
+}
+`, startDate, endDate)
+}

internal/service/ec2/ec2_capacity_block_reservation.go

@@ -0,0 +1,130 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package ec2
+
+import (
+	"context"
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+	"github.com/hashicorp/terraform-provider-aws/internal/conns"
+	"github.com/hashicorp/terraform-provider-aws/internal/errs/sdkdiag"
+	tftags "github.com/hashicorp/terraform-provider-aws/internal/tags"
+	"github.com/hashicorp/terraform-provider-aws/internal/verify"
+	"github.com/hashicorp/terraform-provider-aws/names"
+)
+
+// @SDKResource("aws_ec2_capacity_block_reservation", name="Capacity Block Reservation")
+// @Tags(identifierAttribute="id")
+func ResourceCapacityBlockReservation() *schema.Resource {
+	return &schema.Resource{
+		CreateWithoutTimeout: resourceCapacityBlockReservationCreate,
+		ReadWithoutTimeout:   resourceCapacityReservationRead,
+		UpdateWithoutTimeout: schema.NoopContext,
+		DeleteWithoutTimeout: schema.NoopContext,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+
+		CustomizeDiff: verify.SetTagsDiff,
+
+		Schema: map[string]*schema.Schema{
+			"arn": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"availability_zone": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"capacity_block_offering_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"ebs_optimized": {
+				Type:     schema.TypeBool,
+				Computed: true,
+			},
+			"end_date": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"end_date_type": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"ephemeral_storage": {
+				Type:     schema.TypeBool,
+				Computed: true,
+			},
+			"instance_count": {
+				Type:     schema.TypeInt,
+				Computed: true,
+			},
+			"instance_match_criteria": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"instance_platform": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validation.StringInSlice(ec2.CapacityReservationInstancePlatform_Values(), false),
+			},
+			"instance_type": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"outpost_arn": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"owner_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"placement_group_arn": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"start_date": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			names.AttrTags:    tftags.TagsSchema(),
+			names.AttrTagsAll: tftags.TagsSchemaComputed(),
+			"tenancy": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func resourceCapacityBlockReservationCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	var diags diag.Diagnostics
+	conn := meta.(*conns.AWSClient).EC2Conn(ctx)
+
+	input := &ec2.PurchaseCapacityBlockInput{
+		CapacityBlockOfferingId: aws.String(d.Get("capacity_block_offering_id").(string)),
+		InstancePlatform:        aws.String(d.Get("instance_platform").(string)),
+		TagSpecifications:       getTagSpecificationsIn(ctx, ec2.ResourceTypeCapacityReservation),
+	}
+
+	output, err := conn.PurchaseCapacityBlock(input)
+
+	if err != nil {
+		return sdkdiag.AppendErrorf(diags, "creating EC2 Capacity Reservation: %s", err)
+	}
+	d.SetId(aws.StringValue(output.CapacityReservation.CapacityReservationId))
+
+	if _, err := WaitCapacityReservationActive(ctx, conn, d.Id()); err != nil {
+		return sdkdiag.AppendErrorf(diags, "waiting for EC2 Capacity Reservation (%s) create: %s", d.Id(), err)
+	}
+
+	return append(diags, resourceCapacityReservationRead(ctx, d, meta)...)
+}