Added team to pagerduty_business_service resource

pagerduty/resource_pagerduty_business_service.go

@@ -2,7 +2,9 @@ package pagerduty
 
 import (
 	"log"
+	"time"
 
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
 	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
 	"github.com/heimweh/go-pagerduty/pagerduty"
 )
@@ -51,6 +53,10 @@ func resourcePagerDutyBusinessService() *schema.Resource {
 				Type:     schema.TypeString,
 				Optional: true,
 			},
+			"team": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
 		},
 	}
 }
@@ -77,27 +83,37 @@ func buildBusinessServiceStruct(d *schema.ResourceData) (*pagerduty.BusinessServ
 	if attr, ok := d.GetOk("html_url"); ok {
 		businessService.HTMLUrl = attr.(string)
 	}
+	if attr, ok := d.GetOk("team"); ok {
+		businessService.Team = &pagerduty.BusinessServiceTeam{
+			ID: attr.(string),
+		}
+	}
 
 	return &businessService, nil
 }
 
 func resourcePagerDutyBusinessServiceCreate(d *schema.ResourceData, meta interface{}) error {
 	client := meta.(*pagerduty.Client)
 
-	businessService, err := buildBusinessServiceStruct(d)
-	if err != nil {
-		return err
+	retryErr := resource.Retry(2*time.Minute, func() *resource.RetryError {
+
+		businessService, err := buildBusinessServiceStruct(d)
+		if err != nil {
+			return resource.NonRetryableError(err)
+		}
+		log.Printf("[INFO] Creating PagerDuty business service %s", businessService.Name)
+		if businessService, _, err = client.BusinessServices.Create(businessService); err != nil {
+			return resource.RetryableError(err)
+		} else if businessService != nil {
+			d.SetId(businessService.ID)
+		}
+		return nil
+	})
+	if retryErr != nil {
+		time.Sleep(2 * time.Second)
+		return retryErr
 	}
 
-	log.Printf("[INFO] Creating PagerDuty business service %s", businessService.Name)
-
-	businessService, _, err = client.BusinessServices.Create(businessService)
-	if err != nil {
-		return err
-	}
-
-	d.SetId(businessService.ID)
-
 	return resourcePagerDutyBusinessServiceRead(d, meta)
 }
 
@@ -106,19 +122,29 @@ func resourcePagerDutyBusinessServiceRead(d *schema.ResourceData, meta interface
 
 	log.Printf("[INFO] Reading PagerDuty business service %s", d.Id())
 
-	businessService, _, err := client.BusinessServices.Get(d.Id())
-	if err != nil {
-		return handleNotFoundError(err, d)
+	retryErr := resource.Retry(2*time.Minute, func() *resource.RetryError {
+		if businessService, _, err := client.BusinessServices.Get(d.Id()); err != nil {
+			return resource.RetryableError(err)
+		} else if businessService != nil {
+			d.Set("name", businessService.Name)
+			d.Set("html_url", businessService.HTMLUrl)
+			d.Set("description", businessService.Description)
+			d.Set("type", businessService.Type)
+			d.Set("point_of_contact", businessService.PointOfContact)
+			d.Set("summary", businessService.Summary)
+			d.Set("self", businessService.Self)
+			if businessService.Team != nil {
+				d.Set("team", businessService.Team.ID)
+			}
+		}
+		return nil
+	})
+
+	if retryErr != nil {
+		time.Sleep(2 * time.Second)
+		return retryErr
 	}
 
-	d.Set("name", businessService.Name)
-	d.Set("html_url", businessService.HTMLUrl)
-	d.Set("description", businessService.Description)
-	d.Set("type", businessService.Type)
-	d.Set("point_of_contact", businessService.PointOfContact)
-	d.Set("summary", businessService.Summary)
-	d.Set("self", businessService.Self)
-
 	return nil
 }
 

pagerduty/resource_pagerduty_business_service_test.go

@@ -91,6 +91,36 @@ func TestAccPagerDutyBusinessService_Basic(t *testing.T) {
 		},
 	})
 }
+
+func TestAccPagerDutyBusinessService_WithTeam(t *testing.T) {
+	businessService := fmt.Sprintf("tf-%s", acctest.RandString(5))
+	teamName := fmt.Sprintf("tf-%s", acctest.RandString(5))
+	description := fmt.Sprintf("tf-%s", acctest.RandString(5))
+	pointOfContact := fmt.Sprintf("tf-%s", acctest.RandString(5))
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckPagerDutyBusinessServiceDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckPagerDutyBusinessServiceWithTeamConfig(businessService, teamName, description, pointOfContact),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckPagerDutyBusinessServiceExists("pagerduty_business_service.bar"),
+					resource.TestCheckResourceAttr(
+						"pagerduty_business_service.bar", "name", businessService),
+					resource.TestCheckResourceAttr(
+						"pagerduty_business_service.bar", "description", description),
+					resource.TestCheckResourceAttr(
+						"pagerduty_business_service.bar", "point_of_contact", pointOfContact),
+					resource.TestCheckResourceAttrSet(
+						"pagerduty_business_service.bar", "self"),
+				),
+			},
+		},
+	})
+}
+
 func testAccCheckPagerDutyBusinessServiceExists(n string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]
@@ -150,3 +180,19 @@ resource "pagerduty_business_service" "foo" {
 }
 `, name, description, poc)
 }
+
+func testAccCheckPagerDutyBusinessServiceWithTeamConfig(businessServiceName, teamName, description, poc string) string {
+	return fmt.Sprintf(`
+
+resource "pagerduty_team" "bar" {
+	name = "%s"
+}
+
+resource "pagerduty_business_service" "bar" {
+	name = "%s"
+	description = "%s"
+	point_of_contact = "%s"
+	team = pagerduty_team.bar.id
+}
+`, teamName, businessServiceName, description, poc)
+}

pagerduty/resource_pagerduty_ruleset_rule.go

@@ -600,7 +600,7 @@ func resourcePagerDutyRulesetRuleCreate(d *schema.ResourceData, meta interface{}
 
 	log.Printf("[INFO] Creating PagerDuty ruleset rule for ruleset: %s", rule.Ruleset.ID)
 
-	retryErr := resource.Retry(30*time.Second, func() *resource.RetryError {
+	retryErr := resource.Retry(2*time.Minute, func() *resource.RetryError {
 		if rule, _, err := client.Rulesets.CreateRule(rule.Ruleset.ID, rule); err != nil {
 			return resource.RetryableError(err)
 		} else if rule != nil {
@@ -621,7 +621,7 @@ func resourcePagerDutyRulesetRuleRead(d *schema.ResourceData, meta interface{})
 	log.Printf("[INFO] Reading PagerDuty ruleset rule: %s", d.Id())
 	rulesetID := d.Get("ruleset").(string)
 
-	return resource.Retry(30*time.Second, func() *resource.RetryError {
+	return resource.Retry(2*time.Minute, func() *resource.RetryError {
 		if rule, _, err := client.Rulesets.GetRule(rulesetID, d.Id()); err != nil {
 			time.Sleep(2 * time.Second)
 			return resource.RetryableError(err)

website/docs/r/business_service.html.markdown

@@ -18,6 +18,7 @@ resource "pagerduty_business_service" "example" {
   name             = "My Web App"
   description      = "A very descriptive description of this business service"
   point_of_contact = "PagerDuty Admin"
+  team = "P37RSRS"
 }
 ```
 
@@ -30,7 +31,8 @@ The following arguments are supported:
     If not set, a placeholder of "Managed by Terraform" will be set.
   * `point_of_contact` - (Optional) The owner of the business service. 
   * `type` - (Optional) Default value is `business_service`. Can also be set as `business_service_reference`.
-
+  * `team` - (Optional) ID of the team that owns the business service.
+
 ## Attributes Reference
 
 The following attributes are exported: