mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-06-29 06:42:36 +00:00
372 lines
11 KiB
Go
372 lines
11 KiB
Go
package google
|
|
|
|
import (
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/terraform/helper/schema"
|
|
"github.com/hashicorp/terraform/helper/validation"
|
|
"google.golang.org/api/cloudiot/v1"
|
|
)
|
|
|
|
const (
|
|
mqttEnabled = "MQTT_ENABLED"
|
|
mqttDisabled = "MQTT_DISABLED"
|
|
httpEnabled = "HTTP_ENABLED"
|
|
httpDisabled = "HTTP_DISABLED"
|
|
x509CertificatePEM = "X509_CERTIFICATE_PEM"
|
|
)
|
|
|
|
func resourceCloudIoTRegistry() *schema.Resource {
|
|
return &schema.Resource{
|
|
Create: resourceCloudIoTRegistryCreate,
|
|
Update: resourceCloudIoTRegistryUpdate,
|
|
Read: resourceCloudIoTRegistryRead,
|
|
Delete: resourceCloudIoTRegistryDelete,
|
|
|
|
Importer: &schema.ResourceImporter{
|
|
State: resourceCloudIoTRegistryStateImporter,
|
|
},
|
|
|
|
Schema: map[string]*schema.Schema{
|
|
"name": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
ForceNew: true,
|
|
ValidateFunc: validateCloudIoTID,
|
|
},
|
|
"project": {
|
|
Type: schema.TypeString,
|
|
Optional: true,
|
|
Computed: true,
|
|
ForceNew: true,
|
|
},
|
|
"region": {
|
|
Type: schema.TypeString,
|
|
Optional: true,
|
|
Computed: true,
|
|
ForceNew: true,
|
|
},
|
|
"event_notification_config": {
|
|
Type: schema.TypeMap,
|
|
Optional: true,
|
|
Elem: &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"pubsub_topic_name": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
DiffSuppressFunc: compareSelfLinkOrResourceName,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"state_notification_config": {
|
|
Type: schema.TypeMap,
|
|
Optional: true,
|
|
Elem: &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"pubsub_topic_name": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
DiffSuppressFunc: compareSelfLinkOrResourceName,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"mqtt_config": {
|
|
Type: schema.TypeMap,
|
|
Computed: true,
|
|
Optional: true,
|
|
Elem: &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"mqtt_enabled_state": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
ValidateFunc: validation.StringInSlice(
|
|
[]string{mqttEnabled, mqttDisabled}, false),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"http_config": {
|
|
Type: schema.TypeMap,
|
|
Computed: true,
|
|
Optional: true,
|
|
Elem: &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"http_enabled_state": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
ValidateFunc: validation.StringInSlice(
|
|
[]string{httpEnabled, httpDisabled}, false),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"credentials": {
|
|
Type: schema.TypeList,
|
|
Optional: true,
|
|
MaxItems: 10,
|
|
Elem: &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"public_key_certificate": {
|
|
Type: schema.TypeMap,
|
|
Optional: true,
|
|
Elem: &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"format": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
ValidateFunc: validation.StringInSlice(
|
|
[]string{x509CertificatePEM}, false),
|
|
},
|
|
"certificate": {
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func buildEventNotificationConfig(config map[string]interface{}) *cloudiot.EventNotificationConfig {
|
|
if v, ok := config["pubsub_topic_name"]; ok {
|
|
return &cloudiot.EventNotificationConfig{
|
|
PubsubTopicName: v.(string),
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func buildStateNotificationConfig(config map[string]interface{}) *cloudiot.StateNotificationConfig {
|
|
if v, ok := config["pubsub_topic_name"]; ok {
|
|
return &cloudiot.StateNotificationConfig{
|
|
PubsubTopicName: v.(string),
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func buildMqttConfig(config map[string]interface{}) *cloudiot.MqttConfig {
|
|
if v, ok := config["mqtt_enabled_state"]; ok {
|
|
return &cloudiot.MqttConfig{
|
|
MqttEnabledState: v.(string),
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func buildHttpConfig(config map[string]interface{}) *cloudiot.HttpConfig {
|
|
if v, ok := config["http_enabled_state"]; ok {
|
|
return &cloudiot.HttpConfig{
|
|
HttpEnabledState: v.(string),
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func buildPublicKeyCertificate(certificate map[string]interface{}) *cloudiot.PublicKeyCertificate {
|
|
cert := &cloudiot.PublicKeyCertificate{
|
|
Format: certificate["format"].(string),
|
|
Certificate: certificate["certificate"].(string),
|
|
}
|
|
return cert
|
|
}
|
|
|
|
func expandCredentials(credentials []interface{}) []*cloudiot.RegistryCredential {
|
|
certificates := make([]*cloudiot.RegistryCredential, len(credentials))
|
|
for i, raw := range credentials {
|
|
cred := raw.(map[string]interface{})
|
|
certificates[i] = &cloudiot.RegistryCredential{
|
|
PublicKeyCertificate: buildPublicKeyCertificate(cred["public_key_certificate"].(map[string]interface{})),
|
|
}
|
|
}
|
|
return certificates
|
|
}
|
|
|
|
func createDeviceRegistry(d *schema.ResourceData) *cloudiot.DeviceRegistry {
|
|
deviceRegistry := &cloudiot.DeviceRegistry{}
|
|
if v, ok := d.GetOk("event_notification_config"); ok {
|
|
deviceRegistry.EventNotificationConfigs = make([]*cloudiot.EventNotificationConfig, 1, 1)
|
|
deviceRegistry.EventNotificationConfigs[0] = buildEventNotificationConfig(v.(map[string]interface{}))
|
|
}
|
|
if v, ok := d.GetOk("state_notification_config"); ok {
|
|
deviceRegistry.StateNotificationConfig = buildStateNotificationConfig(v.(map[string]interface{}))
|
|
}
|
|
if v, ok := d.GetOk("mqtt_config"); ok {
|
|
deviceRegistry.MqttConfig = buildMqttConfig(v.(map[string]interface{}))
|
|
}
|
|
if v, ok := d.GetOk("http_config"); ok {
|
|
deviceRegistry.HttpConfig = buildHttpConfig(v.(map[string]interface{}))
|
|
}
|
|
if v, ok := d.GetOk("credentials"); ok {
|
|
deviceRegistry.Credentials = expandCredentials(v.([]interface{}))
|
|
}
|
|
return deviceRegistry
|
|
}
|
|
|
|
func resourceCloudIoTRegistryCreate(d *schema.ResourceData, meta interface{}) error {
|
|
config := meta.(*Config)
|
|
project, err := getProject(d, config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
region, err := getRegion(d, config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
deviceRegistry := createDeviceRegistry(d)
|
|
deviceRegistry.Id = d.Get("name").(string)
|
|
parent := fmt.Sprintf("projects/%s/locations/%s", project, region)
|
|
registryId := fmt.Sprintf("%s/registries/%s", parent, deviceRegistry.Id)
|
|
d.SetId(registryId)
|
|
|
|
err = retryTime(func() error {
|
|
_, err := config.clientCloudIoT.Projects.Locations.Registries.Create(parent, deviceRegistry).Do()
|
|
return err
|
|
}, 5)
|
|
if err != nil {
|
|
d.SetId("")
|
|
return err
|
|
}
|
|
|
|
// If we infer project and region, they are never actually set so we set them here
|
|
d.Set("project", project)
|
|
d.Set("region", region)
|
|
|
|
return resourceCloudIoTRegistryRead(d, meta)
|
|
}
|
|
|
|
func resourceCloudIoTRegistryUpdate(d *schema.ResourceData, meta interface{}) error {
|
|
config := meta.(*Config)
|
|
updateMask := make([]string, 0, 5)
|
|
hasChanged := false
|
|
deviceRegistry := &cloudiot.DeviceRegistry{}
|
|
|
|
d.Partial(true)
|
|
|
|
if d.HasChange("event_notification_config") {
|
|
hasChanged = true
|
|
updateMask = append(updateMask, "event_notification_configs")
|
|
if v, ok := d.GetOk("event_notification_config"); ok {
|
|
deviceRegistry.EventNotificationConfigs = make([]*cloudiot.EventNotificationConfig, 1, 1)
|
|
deviceRegistry.EventNotificationConfigs[0] = buildEventNotificationConfig(v.(map[string]interface{}))
|
|
}
|
|
}
|
|
if d.HasChange("state_notification_config") {
|
|
hasChanged = true
|
|
updateMask = append(updateMask, "state_notification_config.pubsub_topic_name")
|
|
if v, ok := d.GetOk("state_notification_config"); ok {
|
|
deviceRegistry.StateNotificationConfig = buildStateNotificationConfig(v.(map[string]interface{}))
|
|
}
|
|
}
|
|
if d.HasChange("mqtt_config") {
|
|
hasChanged = true
|
|
updateMask = append(updateMask, "mqtt_config.mqtt_enabled_state")
|
|
if v, ok := d.GetOk("mqtt_config"); ok {
|
|
deviceRegistry.MqttConfig = buildMqttConfig(v.(map[string]interface{}))
|
|
}
|
|
}
|
|
if d.HasChange("http_config") {
|
|
hasChanged = true
|
|
updateMask = append(updateMask, "http_config.http_enabled_state")
|
|
if v, ok := d.GetOk("http_config"); ok {
|
|
deviceRegistry.HttpConfig = buildHttpConfig(v.(map[string]interface{}))
|
|
}
|
|
}
|
|
if d.HasChange("credentials") {
|
|
hasChanged = true
|
|
updateMask = append(updateMask, "credentials")
|
|
if v, ok := d.GetOk("credentials"); ok {
|
|
deviceRegistry.Credentials = expandCredentials(v.([]interface{}))
|
|
}
|
|
}
|
|
if hasChanged {
|
|
_, err := config.clientCloudIoT.Projects.Locations.Registries.Patch(d.Id(),
|
|
deviceRegistry).UpdateMask(strings.Join(updateMask, ",")).Do()
|
|
if err != nil {
|
|
return fmt.Errorf("Error updating registry %s: %s", d.Get("name").(string), err)
|
|
}
|
|
for _, updateMaskItem := range updateMask {
|
|
d.SetPartial(updateMaskItem)
|
|
}
|
|
}
|
|
d.Partial(false)
|
|
return resourceCloudIoTRegistryRead(d, meta)
|
|
}
|
|
|
|
func resourceCloudIoTRegistryRead(d *schema.ResourceData, meta interface{}) error {
|
|
config := meta.(*Config)
|
|
name := d.Id()
|
|
res, err := config.clientCloudIoT.Projects.Locations.Registries.Get(name).Do()
|
|
if err != nil {
|
|
return handleNotFoundError(err, d, fmt.Sprintf("Registry %q", name))
|
|
}
|
|
|
|
d.Set("name", res.Id)
|
|
|
|
if len(res.EventNotificationConfigs) > 0 {
|
|
eventConfig := map[string]string{"pubsub_topic_name": res.EventNotificationConfigs[0].PubsubTopicName}
|
|
d.Set("event_notification_config", eventConfig)
|
|
} else {
|
|
d.Set("event_notification_config", nil)
|
|
}
|
|
pubsubTopicName := res.StateNotificationConfig.PubsubTopicName
|
|
if pubsubTopicName != "" {
|
|
d.Set("state_notification_config",
|
|
map[string]string{"pubsub_topic_name": pubsubTopicName})
|
|
} else {
|
|
d.Set("state_notification_config", nil)
|
|
}
|
|
|
|
d.Set("mqtt_config", map[string]string{"mqtt_enabled_state": res.MqttConfig.MqttEnabledState})
|
|
d.Set("http_config", map[string]string{"http_enabled_state": res.HttpConfig.HttpEnabledState})
|
|
|
|
credentials := make([]map[string]interface{}, len(res.Credentials))
|
|
for i, item := range res.Credentials {
|
|
pubcert := make(map[string]interface{})
|
|
pubcert["format"] = item.PublicKeyCertificate.Format
|
|
pubcert["certificate"] = item.PublicKeyCertificate.Certificate
|
|
credentials[i] = make(map[string]interface{})
|
|
credentials[i]["public_key_certificate"] = pubcert
|
|
}
|
|
d.Set("credentials", credentials)
|
|
return nil
|
|
}
|
|
|
|
func resourceCloudIoTRegistryDelete(d *schema.ResourceData, meta interface{}) error {
|
|
config := meta.(*Config)
|
|
name := d.Id()
|
|
call := config.clientCloudIoT.Projects.Locations.Registries.Delete(name)
|
|
_, err := call.Do()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
d.SetId("")
|
|
return nil
|
|
}
|
|
|
|
func resourceCloudIoTRegistryStateImporter(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
|
|
r, _ := regexp.Compile("^projects/(.+)/locations/(.+)/registries/(.+)$")
|
|
if !r.MatchString(d.Id()) {
|
|
return nil, fmt.Errorf("Invalid registry specifier. " +
|
|
"Expecting: projects/{project}/locations/{region}/registries/{name}")
|
|
}
|
|
parms := r.FindAllStringSubmatch(d.Id(), -1)[0]
|
|
project := parms[1]
|
|
region := parms[2]
|
|
name := parms[3]
|
|
|
|
id := fmt.Sprintf("projects/%s/locations/%s/registries/%s", project, region, name)
|
|
d.Set("project", project)
|
|
d.Set("region", region)
|
|
d.SetId(id)
|
|
return []*schema.ResourceData{d}, nil
|
|
}
|