/
data_source_pagerduty_vendor.go
133 lines (102 loc) · 2.89 KB
/
data_source_pagerduty_vendor.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
package pagerduty
import (
"fmt"
"log"
"regexp"
pagerduty "github.com/PagerDuty/go-pagerduty"
"github.com/hashicorp/terraform/helper/schema"
)
func dataSourcePagerDutyVendor() *schema.Resource {
return &schema.Resource{
Read: dataSourcePagerDutyVendorRead,
Schema: map[string]*schema.Schema{
"name_regex": {
Type: schema.TypeString,
Optional: true,
Deprecated: "Use field name instead",
ConflictsWith: []string{"name"},
},
"name": {
Type: schema.TypeString,
Computed: true,
Optional: true,
ConflictsWith: []string{"name_regex"},
},
"type": {
Type: schema.TypeString,
Computed: true,
},
},
}
}
func dataSourcePagerDutyVendorRead(d *schema.ResourceData, meta interface{}) error {
client := meta.(*pagerduty.Client)
// Check if we're doing a normal or legacy lookup
_, ok := d.GetOk("name")
_, legacyOk := d.GetOk("name_regex")
if !ok && !legacyOk {
return fmt.Errorf("Either name or name_regex must be set")
}
// If name_regex is set, we're doing a legacy lookup
if legacyOk {
return dataSourcePagerDutyVendorLegacyRead(d, meta)
}
log.Printf("[INFO] Reading PagerDuty vendor")
searchName := d.Get("name").(string)
o := &pagerduty.ListVendorOptions{
Query: searchName,
}
resp, err := client.ListVendors(*o)
if err != nil {
return err
}
var found *pagerduty.Vendor
r := regexp.MustCompile("(?i)" + searchName)
for _, vendor := range resp.Vendors {
if r.MatchString(vendor.Name) {
found = &vendor
break
}
}
if found == nil {
return fmt.Errorf("Unable to locate any vendor with the name: %s", searchName)
}
d.SetId(found.ID)
d.Set("name", found.Name)
d.Set("type", found.GenericServiceType)
return nil
}
func dataSourcePagerDutyVendorLegacyRead(d *schema.ResourceData, meta interface{}) error {
client := meta.(*pagerduty.Client)
log.Printf("[INFO] Reading PagerDuty vendor (legacy)")
resp, err := getVendors(client)
if err != nil {
return err
}
r := regexp.MustCompile("(?i)" + d.Get("name_regex").(string))
var vendors []pagerduty.Vendor
var vendorNames []string
for _, v := range resp {
if r.MatchString(v.Name) {
vendors = append(vendors, v)
vendorNames = append(vendorNames, v.Name)
}
}
if len(vendors) == 0 {
return fmt.Errorf("Unable to locate any vendor using the regex string: %s", r.String())
} else if len(vendors) > 1 {
return fmt.Errorf("Your query returned more than one result using the regex string: %#v. Found vendors: %#v", r.String(), vendorNames)
}
vendor := vendors[0]
genericServiceType := vendor.GenericServiceType
switch {
case genericServiceType == "email":
genericServiceType = "generic_email_inbound_integration"
case genericServiceType == "api":
genericServiceType = "generic_events_api_inbound_integration"
}
d.SetId(vendor.ID)
d.Set("name", vendor.Name)
d.Set("type", genericServiceType)
return nil
}