[CSGI-2879] Migrate data source pagerduty_service to TPF

main.go

@@ -4,12 +4,13 @@ import (
 	"context"
 	"log"
 
+	pd "github.com/PagerDuty/terraform-provider-pagerduty/pagerduty"
+	pdp "github.com/PagerDuty/terraform-provider-pagerduty/pagerdutyplugin"
 	"github.com/hashicorp/terraform-plugin-framework/providerserver"
-	"github.com/hashicorp/terraform-plugin-go/tfprotov5/tf5server"
-	"github.com/hashicorp/terraform-plugin-mux/tf5muxserver"
-
-	"github.com/PagerDuty/terraform-provider-pagerduty/pagerduty"
-	pagerdutyplugin "github.com/PagerDuty/terraform-provider-pagerduty/pagerdutyplugin"
+	"github.com/hashicorp/terraform-plugin-go/tfprotov6"
+	"github.com/hashicorp/terraform-plugin-go/tfprotov6/tf6server"
+	"github.com/hashicorp/terraform-plugin-mux/tf5to6server"
+	"github.com/hashicorp/terraform-plugin-mux/tf6muxserver"
 )
 
 func main() {
@@ -19,21 +20,26 @@ func main() {
 func Serve() {
 	ctx := context.Background()
 
-	muxServer, err := tf5muxserver.NewMuxServer(
+	upgradedSdkServer, err := tf5to6server.UpgradeServer(ctx, pd.Provider(pd.IsMuxed).GRPCProvider)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	muxServer, err := tf6muxserver.NewMuxServer(
 		ctx,
-		// terraform-plugin-framework
-		providerserver.NewProtocol5(pagerdutyplugin.New()),
-		// terraform-plugin-sdk
-		pagerduty.Provider(pagerduty.IsMuxed).GRPCProvider,
+		providerserver.NewProtocol6(pdp.New()),
+		func() tfprotov6.ProviderServer { return upgradedSdkServer },
 	)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	var serveOpts []tf5server.ServeOpt
-
 	address := "registry.terraform.io/pagerduty/pagerduty"
-	err = tf5server.Serve(address, muxServer.ProviderServer, serveOpts...)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = tf6server.Serve(address, muxServer.ProviderServer)
 	if err != nil {
 		log.Fatal(err)
 	}

pagerdutyplugin/data_source_pagerduty_business_service_test.go

@@ -14,7 +14,7 @@ func TestAccDataSourcePagerDutyBusinessService_Basic(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourcePagerDutyBusinessServiceConfig(name),

pagerdutyplugin/data_source_pagerduty_service.go

@@ -0,0 +1,148 @@
+package pagerduty
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/PagerDuty/go-pagerduty"
+	"github.com/PagerDuty/terraform-provider-pagerduty/util"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/path"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/retry"
+)
+
+type dataSourceService struct{ client *pagerduty.Client }
+
+var _ datasource.DataSource = (*dataSourceService)(nil)
+
+func (d *dataSourceService) Metadata(ctx context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+}
+
+func (d *dataSourceService) Schema(ctx context.Context, req datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"id":                      schema.StringAttribute{Computed: true},
+			"name":                    schema.StringAttribute{Required: true},
+			"auto_resolve_timeout":    schema.Int64Attribute{Computed: true},
+			"acknowledgement_timeout": schema.Int64Attribute{Computed: true},
+			"alert_creation":          schema.StringAttribute{Computed: true},
+			"description":             schema.StringAttribute{Computed: true},
+			"escalation_policy":       schema.StringAttribute{Computed: true},
+			"type":                    schema.StringAttribute{Computed: true},
+			"teams": schema.ListNestedAttribute{
+				Computed:    true,
+				Description: "The set of teams associated with the service",
+				NestedObject: schema.NestedAttributeObject{
+					Attributes: map[string]schema.Attribute{
+						"id":   schema.StringAttribute{Computed: true},
+						"name": schema.StringAttribute{Computed: true},
+					},
+				},
+			},
+		},
+	}
+}
+
+func (d *dataSourceService) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	log.Printf("[INFO] Reading PagerDuty service")
+
+	var searchName types.String
+	if d := req.Config.GetAttribute(ctx, path.Root("name"), &searchName); d.HasError() {
+		resp.Diagnostics.Append(d...)
+		return
+	}
+	opts := pagerduty.ListServiceOptions{Query: searchName.ValueString()}
+
+	var found *pagerduty.Service
+	err := retry.RetryContext(ctx, 5*time.Minute, func() *retry.RetryError {
+		resp, err := d.client.ListServicesWithContext(ctx, opts)
+		if err != nil {
+			if util.IsBadRequestError(err) {
+				return retry.NonRetryableError(err)
+			}
+
+			// Delaying retry by 30s as recommended by PagerDuty
+			// https://developer.pagerduty.com/docs/rest-api-v2/rate-limiting/#what-are-possible-workarounds-to-the-events-api-rate-limit
+			time.Sleep(30 * time.Second)
+			return retry.RetryableError(err)
+		}
+
+		for _, service := range resp.Services {
+			if service.Name == searchName.ValueString() {
+				found = &service
+				break
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		resp.Diagnostics.AddError(
+			fmt.Sprintf("Error searching Service %s", searchName),
+			err.Error(),
+		)
+		return
+	}
+
+	if found == nil {
+		resp.Diagnostics.AddError(
+			fmt.Sprintf("Unable to locate any service with the name: %s", searchName),
+			"",
+		)
+		return
+	}
+	model := flattenServiceData(ctx, found, &resp.Diagnostics)
+	resp.Diagnostics.Append(resp.State.Set(ctx, &model)...)
+}
+
+type dataSourceServiceModel struct {
+	ID                     types.String `tfsdk:"id"`
+	Name                   types.String `tfsdk:"name"`
+	AutoResolveTimeout     types.Int64  `tfsdk:"auto_resolve_timeout"`
+	AcknowledgementTimeout types.Int64  `tfsdk:"acknowledgement_timeout"`
+	AlertCreation          types.String `tfsdk:"alert_creation"`
+	Description            types.String `tfsdk:"description"`
+	EscalationPolicy       types.String `tfsdk:"escalation_policy"`
+	Type                   types.String `tfsdk:"type"`
+	Teams                  types.List   `tfsdk:"teams"`
+}
+
+func flattenServiceData(ctx context.Context, service *pagerduty.Service, diags *diag.Diagnostics) dataSourceServiceModel {
+	teamObjectType := types.ObjectType{
+		AttrTypes: map[string]attr.Type{
+			"id":   types.StringType,
+			"name": types.StringType,
+		},
+	}
+
+	teams, d := types.ListValueFrom(ctx, teamObjectType, service.Teams)
+	diags.Append(d...)
+	if d.HasError() {
+		return dataSourceServiceModel{}
+	}
+
+	model := dataSourceServiceModel{
+		ID:                     types.StringValue(service.ID),
+		Name:                   types.StringValue(service.Name),
+		Type:                   types.StringValue(service.Type),
+		AutoResolveTimeout:     types.Int64Null(),
+		AcknowledgementTimeout: types.Int64Null(),
+		AlertCreation:          types.StringValue(service.AlertCreation),
+		Description:            types.StringValue(service.Description),
+		EscalationPolicy:       types.StringValue(service.EscalationPolicy.ID),
+		Teams:                  teams,
+	}
+
+	if service.AutoResolveTimeout != nil {
+		model.AutoResolveTimeout = types.Int64Value(int64(*service.AutoResolveTimeout))
+	}
+	if service.AcknowledgementTimeout != nil {
+		model.AcknowledgementTimeout = types.Int64Value(int64(*service.AcknowledgementTimeout))
+	}
+	return model
+}

pagerduty/data_source_pagerduty_service_test.go → pagerdutyplugin/data_source_pagerduty_service_test.go

@@ -17,8 +17,8 @@ func TestAccDataSourcePagerDutyService_Basic(t *testing.T) {
 	teamname := fmt.Sprintf("tf-%s", acctest.RandString(5))
 
 	resource.Test(t, resource.TestCase{
-		PreCheck:  func() { testAccPreCheck(t) },
-		Providers: testAccProviders,
+		PreCheck:                 func() { testAccPreCheck(t) },
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourcePagerDutyServiceConfig(username, email, service, escalationPolicy, teamname),
@@ -38,8 +38,8 @@ func TestAccDataSourcePagerDutyService_HasNoTeam(t *testing.T) {
 	teamname := fmt.Sprintf("tf-%s", acctest.RandString(5))
 
 	resource.Test(t, resource.TestCase{
-		PreCheck:  func() { testAccPreCheck(t) },
-		Providers: testAccProviders,
+		PreCheck:                 func() { testAccPreCheck(t) },
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourcePagerDutyServiceConfig(username, email, service, escalationPolicy, teamname),
@@ -59,8 +59,8 @@ func TestAccDataSourcePagerDutyService_HasOneTeam(t *testing.T) {
 	teamname := fmt.Sprintf("tf-%s", acctest.RandString(5))
 
 	resource.Test(t, resource.TestCase{
-		PreCheck:  func() { testAccPreCheck(t) },
-		Providers: testAccProviders,
+		PreCheck:                 func() { testAccPreCheck(t) },
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourcePagerDutyServiceConfig(username, email, service, escalationPolicy, teamname),
@@ -75,7 +75,6 @@ func TestAccDataSourcePagerDutyService_HasOneTeam(t *testing.T) {
 
 func testAccDataSourcePagerDutyService(src, n string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
-
 		srcR := s.RootModule().Resources[src]
 		srcA := srcR.Primary.Attributes
 
@@ -162,6 +161,5 @@ data "pagerduty_service" "no_team_service" {
 data "pagerduty_service" "one_team_service" {
   name = pagerduty_service.one_team_service.name
 }
-
-`, teamname, username, email, service, escalationPolicy)
+`, teamname, username, email, escalationPolicy, service)
 }

pagerdutyplugin/data_source_pagerduty_standards_resource_scores_test.go

@@ -13,7 +13,7 @@ func TestAccDataSourcePagerDutyStandardsResourceScores_Basic(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourcePagerDutyStandardsResourceScoresConfig(name),

pagerdutyplugin/data_source_pagerduty_standards_resources_scores_test.go

@@ -13,7 +13,7 @@ func TestAccDataSourcePagerDutyStandardsResourcesScores_Basic(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourcePagerDutyStandardsResourcesScoresConfig(name),

pagerdutyplugin/data_source_pagerduty_standards_test.go

@@ -14,7 +14,7 @@ func TestAccDataSourcePagerDutyStandards_Basic(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourcePagerDutyStandardsConfig(name),
@@ -34,7 +34,7 @@ func TestAccDataSourcePagerDutyStandards_WithResourceType(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourcePagerDutyStandardsConfigWithResourceType(name, resourceType),

pagerdutyplugin/import_pagerduty_business_service_test.go

@@ -15,7 +15,7 @@ func TestAccPagerDutyBusinessService_import(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		CheckDestroy:             testAccCheckPagerDutyBusinessServiceDestroy,
 		Steps: []resource.TestStep{
 			{

pagerdutyplugin/provider_test.go

@@ -5,13 +5,13 @@ import (
 	"os"
 	"testing"
 
+	pd "github.com/PagerDuty/terraform-provider-pagerduty/pagerduty"
 	"github.com/hashicorp/terraform-plugin-framework/providerserver"
-	"github.com/hashicorp/terraform-plugin-go/tfprotov5"
-	"github.com/hashicorp/terraform-plugin-mux/tf5muxserver"
+	"github.com/hashicorp/terraform-plugin-go/tfprotov6"
+	"github.com/hashicorp/terraform-plugin-mux/tf5to6server"
+	"github.com/hashicorp/terraform-plugin-mux/tf6muxserver"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
-
-	pd "github.com/PagerDuty/terraform-provider-pagerduty/pagerduty"
 )
 
 var testAccProvider = New()
@@ -51,16 +51,21 @@ func testAccExternalProviders() map[string]resource.ExternalProvider {
 	return m
 }
 
-func testAccProtoV5ProviderFactories() map[string]func() (tfprotov5.ProviderServer, error) {
-	return map[string]func() (tfprotov5.ProviderServer, error){
-		"pagerduty": func() (tfprotov5.ProviderServer, error) {
+func testAccProtoV6ProviderFactories() map[string]func() (tfprotov6.ProviderServer, error) {
+	return map[string]func() (tfprotov6.ProviderServer, error){
+		"pagerduty": func() (tfprotov6.ProviderServer, error) {
 			ctx := context.Background()
-			providers := []func() tfprotov5.ProviderServer{
-				pd.Provider(pd.IsMuxed).GRPCProvider,
-				providerserver.NewProtocol5(testAccProvider),
+
+			upgradedSdkServer, err := tf5to6server.UpgradeServer(ctx, pd.Provider(pd.IsMuxed).GRPCProvider)
+			if err != nil {
+				return nil, err
 			}
 
-			muxServer, err := tf5muxserver.NewMuxServer(ctx, providers...)
+			muxServer, err := tf6muxserver.NewMuxServer(
+				ctx,
+				providerserver.NewProtocol6(testAccProvider),
+				func() tfprotov6.ProviderServer { return upgradedSdkServer },
+			)
 			if err != nil {
 				return nil, err
 			}

pagerdutyplugin/resource_pagerduty_business_service_test.go

@@ -22,7 +22,7 @@ func TestAccPagerDutyBusinessService_Basic(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		CheckDestroy:             testAccCheckPagerDutyBusinessServiceDestroy,
 		Steps: []resource.TestStep{
 			{
@@ -58,7 +58,7 @@ func TestAccPagerDutyBusinessService_WithTeam(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { testAccPreCheck(t) },
-		ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 		CheckDestroy:             testAccCheckPagerDutyBusinessServiceDestroy,
 		Steps: []resource.TestStep{
 			{
@@ -98,7 +98,7 @@ func TestAccPagerDutyBusinessService_SDKv2Compatibility(t *testing.T) {
 				),
 			},
 			{
-				ProtoV5ProviderFactories: testAccProtoV5ProviderFactories(),
+				ProtoV6ProviderFactories: testAccProtoV6ProviderFactories(),
 				Config:                   commonConfig,
 				ConfigPlanChecks:         resource.ConfigPlanChecks{PreApply: []plancheck.PlanCheck{plancheck.ExpectEmptyPlan()}},
 			},