Add support for managing maintenance windows

pagerduty/import_pagerduty_maintenance_window_test.go

@@ -0,0 +1,33 @@
+package pagerduty
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccPagerDutyMaintenanceWindow_import(t *testing.T) {
+	window := fmt.Sprintf("tf-%s", acctest.RandString(5))
+	windowStartTime := time.Now().Add(24 * time.Hour).Format(time.RFC3339)
+	windowEndTime := time.Now().Add(48 * time.Hour).Format(time.RFC3339)
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckPagerDutyTeamMembershipDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckPagerDutyMaintenanceWindowConfig(window, windowStartTime, windowEndTime),
+			},
+
+			{
+				ResourceName:      "pagerduty_maintenance_window.foo",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}

pagerduty/provider.go

@@ -35,9 +35,10 @@ func Provider() terraform.ResourceProvider {
 		ResourcesMap: map[string]*schema.Resource{
 			"pagerduty_addon":               resourcePagerDutyAddon(),
 			"pagerduty_escalation_policy":   resourcePagerDutyEscalationPolicy(),
+			"pagerduty_maintenance_window":  resourcePagerDutyMaintenanceWindow(),
 			"pagerduty_schedule":            resourcePagerDutySchedule(),
-			"pagerduty_service_integration": resourcePagerDutyServiceIntegration(),
 			"pagerduty_service":             resourcePagerDutyService(),
+			"pagerduty_service_integration": resourcePagerDutyServiceIntegration(),
 			"pagerduty_team":                resourcePagerDutyTeam(),
 			"pagerduty_team_membership":     resourcePagerDutyTeamMembership(),
 			"pagerduty_user":                resourcePagerDutyUser(),

pagerduty/resource_pagerduty_maintenance_window.go

@@ -0,0 +1,148 @@
+package pagerduty
+
+import (
+	"log"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/heimweh/go-pagerduty/pagerduty"
+)
+
+func resourcePagerDutyMaintenanceWindow() *schema.Resource {
+	return &schema.Resource{
+		Create: resourcePagerDutyMaintenanceWindowCreate,
+		Read:   resourcePagerDutyMaintenanceWindowRead,
+		Update: resourcePagerDutyMaintenanceWindowUpdate,
+		Delete: resourcePagerDutyMaintenanceWindowDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+		Schema: map[string]*schema.Schema{
+			"start_time": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ValidateFunc: validateRFC3339,
+			},
+			"end_time": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ValidateFunc: validateRFC3339,
+			},
+
+			"services": {
+				Type:     schema.TypeList,
+				Required: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+
+			"description": {
+				Type:     schema.TypeString,
+				Optional: true,
+				Default:  "Managed by Terraform",
+			},
+		},
+	}
+}
+
+func buildMaintenanceWindowStruct(d *schema.ResourceData) *pagerduty.MaintenanceWindow {
+	window := &pagerduty.MaintenanceWindow{
+		StartTime: d.Get("start_time").(string),
+		EndTime:   d.Get("end_time").(string),
+		Services:  expandServices(d.Get("services")),
+	}
+
+	if v, ok := d.GetOk("description"); ok {
+		window.Description = v.(string)
+	}
+
+	return window
+}
+
+func resourcePagerDutyMaintenanceWindowCreate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*pagerduty.Client)
+
+	window := buildMaintenanceWindowStruct(d)
+
+	log.Printf("[INFO] Creating PagerDuty maintenance window")
+
+	window, _, err := client.MaintenanceWindows.Create(window)
+	if err != nil {
+		return err
+	}
+
+	d.SetId(window.ID)
+
+	return nil
+}
+
+func resourcePagerDutyMaintenanceWindowRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*pagerduty.Client)
+
+	log.Printf("[INFO] Reading PagerDuty maintenance window %s", d.Id())
+
+	window, _, err := client.MaintenanceWindows.Get(d.Id())
+	if err != nil {
+		return handleNotFoundError(err, d)
+	}
+
+	d.Set("description", window.Description)
+	d.Set("start_time", window.StartTime)
+	d.Set("end_time", window.EndTime)
+
+	if err := d.Set("services", flattenServices(window.Services)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func resourcePagerDutyMaintenanceWindowUpdate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*pagerduty.Client)
+
+	window := buildMaintenanceWindowStruct(d)
+
+	log.Printf("[INFO] Updating PagerDuty maintenance window %s", d.Id())
+
+	if _, _, err := client.MaintenanceWindows.Update(d.Id(), window); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func resourcePagerDutyMaintenanceWindowDelete(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*pagerduty.Client)
+
+	log.Printf("[INFO] Deleting PagerDuty maintenance window %s", d.Id())
+
+	if _, err := client.MaintenanceWindows.Delete(d.Id()); err != nil {
+		return err
+	}
+
+	d.SetId("")
+
+	return nil
+}
+
+func expandServices(v interface{}) []*pagerduty.ServiceReference {
+	var services []*pagerduty.ServiceReference
+
+	for _, srv := range v.([]interface{}) {
+		service := &pagerduty.ServiceReference{
+			Type: "service_reference",
+			ID:   srv.(string),
+		}
+		services = append(services, service)
+	}
+
+	return services
+}
+
+func flattenServices(v []*pagerduty.ServiceReference) []interface{} {
+	var services []interface{}
+
+	for _, srv := range v {
+		services = append(services, srv.ID)
+	}
+
+	return services
+}