Add option in IoTHub to Enable Fallback Route

azurerm/config.go

@@ -27,7 +27,6 @@ import (
 	"github.com/Azure/azure-sdk-for-go/services/devtestlabs/mgmt/2016-05-15/dtl"
 	"github.com/Azure/azure-sdk-for-go/services/eventhub/mgmt/2017-04-01/eventhub"
 	"github.com/Azure/azure-sdk-for-go/services/graphrbac/1.6/graphrbac"
-	"github.com/Azure/azure-sdk-for-go/services/iothub/mgmt/2018-04-01/devices"
 	keyVault "github.com/Azure/azure-sdk-for-go/services/keyvault/2016-10-01/keyvault"
 	"github.com/Azure/azure-sdk-for-go/services/keyvault/mgmt/2018-02-14/keyvault"
 	"github.com/Azure/azure-sdk-for-go/services/logic/mgmt/2016-06-01/logic"
@@ -40,6 +39,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/services/preview/devspaces/mgmt/2018-06-01-preview/devspaces"
 	"github.com/Azure/azure-sdk-for-go/services/preview/dns/mgmt/2018-03-01-preview/dns"
 	"github.com/Azure/azure-sdk-for-go/services/preview/eventgrid/mgmt/2018-09-15-preview/eventgrid"
+	"github.com/Azure/azure-sdk-for-go/services/preview/iothub/mgmt/2018-12-01-preview/devices"
 	"github.com/Azure/azure-sdk-for-go/services/preview/mariadb/mgmt/2018-06-01-preview/mariadb"
 	"github.com/Azure/azure-sdk-for-go/services/preview/monitor/mgmt/2018-03-01/insights"
 	"github.com/Azure/azure-sdk-for-go/services/preview/msi/mgmt/2015-08-31-preview/msi"

azurerm/resource_arm_iothub.go

@@ -4,13 +4,13 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"regexp"
 	"strconv"
 	"time"
 
 	"strings"
 
-	"github.com/Azure/azure-sdk-for-go/services/eventhub/mgmt/2017-04-01/eventhub"
-	"github.com/Azure/azure-sdk-for-go/services/iothub/mgmt/2018-04-01/devices"
+	"github.com/Azure/azure-sdk-for-go/services/preview/iothub/mgmt/2018-12-01-preview/devices"
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/hashicorp/terraform/helper/validation"
@@ -192,8 +192,9 @@ func resourceArmIotHub() *schema.Resource {
 							Optional:         true,
 							DiffSuppressFunc: suppress.CaseDifference,
 							ValidateFunc: validation.StringInSlice([]string{
-								string(eventhub.Avro),
-								string(eventhub.AvroDeflate),
+								string(devices.Avro),
+								string(devices.AvroDeflate),
+								string(devices.JSON),
 							}, true),
 						},
 						"file_name_format": {
@@ -211,9 +212,12 @@ func resourceArmIotHub() *schema.Resource {
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
 						"name": {
-							Type:         schema.TypeString,
-							Required:     true,
-							ValidateFunc: validation.StringLenBetween(0, 64),
+							Type:     schema.TypeString,
+							Required: true,
+							ValidateFunc: validation.StringMatch(
+								regexp.MustCompile("^[-_.a-zA-Z0-9]{1,64}$"),
+								"Route Name name can only include alphanumeric characters, periods, underscores, hyphens, has a maximum length of 64 characters, and must be unique.",
+							),
 						},
 						"source": {
 							Type:     schema.TypeString,
@@ -248,6 +252,50 @@ func resourceArmIotHub() *schema.Resource {
 				},
 			},
 
+			"fallback_route": {
+				Type:     schema.TypeList,
+				MaxItems: 1,
+				Optional: true,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"source": {
+							Type:     schema.TypeString,
+							Optional: true,
+							Default:  "DeviceMessages",
+							ValidateFunc: validation.StringInSlice([]string{
+								"DeviceJobLifecycleEvents",
+								"DeviceLifecycleEvents",
+								"DeviceMessages",
+								"Invalid",
+								"TwinChangeEvents",
+							}, false),
+						},
+						"condition": {
+							// The condition is a string value representing device-to-cloud message routes query expression
+							// https://docs.microsoft.com/en-us/azure/iot-hub/iot-hub-devguide-query-language#device-to-cloud-message-routes-query-expressions
+							Type:     schema.TypeString,
+							Optional: true,
+							Default:  "true",
+						},
+						"endpoint_names": {
+							Type:     schema.TypeList,
+							Optional: true,
+							Computed: true,
+							Elem: &schema.Schema{
+								Type:         schema.TypeString,
+								ValidateFunc: validation.StringLenBetween(0, 64),
+							},
+						},
+						"enabled": {
+							Type:     schema.TypeBool,
+							Optional: true,
+							Computed: true,
+						},
+					},
+				},
+			},
+
 			"tags": tagsSchema(),
 		},
 	}
@@ -292,6 +340,7 @@ func resourceArmIotHubCreateUpdate(d *schema.ResourceData, meta interface{}) err
 	location := azureRMNormalizeLocation(d.Get("location").(string))
 	skuInfo := expandIoTHubSku(d)
 	tags := d.Get("tags").(map[string]interface{})
+	fallbackRoute := expandIoTHubFallbackRoute(d)
 
 	endpoints, err := expandIoTHubEndpoints(d, subscriptionID)
 	if err != nil {
@@ -306,8 +355,9 @@ func resourceArmIotHubCreateUpdate(d *schema.ResourceData, meta interface{}) err
 		Sku:      skuInfo,
 		Properties: &devices.IotHubProperties{
 			Routing: &devices.RoutingProperties{
-				Endpoints: endpoints,
-				Routes:    routes,
+				Endpoints:     endpoints,
+				Routes:        routes,
+				FallbackRoute: fallbackRoute,
 			},
 		},
 		Tags: expandTags(tags),
@@ -328,6 +378,7 @@ func resourceArmIotHubCreateUpdate(d *schema.ResourceData, meta interface{}) err
 	}
 
 	d.SetId(*resp.ID)
+
 	return resourceArmIotHubRead(d, meta)
 }
 
@@ -393,6 +444,11 @@ func resourceArmIotHubRead(d *schema.ResourceData, meta interface{}) error {
 		if err := d.Set("route", routes); err != nil {
 			return fmt.Errorf("Error setting `route` in IoTHub %q: %+v", name, err)
 		}
+
+		fallbackRoute := flattenIoTHubFallbackRoute(properties.Routing)
+		if err := d.Set("fallback_route", fallbackRoute); err != nil {
+			return fmt.Errorf("Error setting `fallbackRoute` in IoTHub %q: %+v", name, err)
+		}
 	}
 
 	d.Set("name", name)
@@ -479,18 +535,14 @@ func expandIoTHubRoutes(d *schema.ResourceData) *[]devices.RouteProperties {
 		condition := route["condition"].(string)
 
 		endpointNamesRaw := route["endpoint_names"].([]interface{})
-		endpointsNames := make([]string, 0)
-		for _, n := range endpointNamesRaw {
-			endpointsNames = append(endpointsNames, n.(string))
-		}
 
 		isEnabled := route["enabled"].(bool)
 
 		routeProperties = append(routeProperties, devices.RouteProperties{
 			Name:          &name,
 			Source:        source,
 			Condition:     &condition,
-			EndpointNames: &endpointsNames,
+			EndpointNames: utils.ExpandStringArray(endpointNamesRaw),
 			IsEnabled:     &isEnabled,
 		})
 	}
@@ -532,7 +584,7 @@ func expandIoTHubEndpoints(d *schema.ResourceData, subscriptionId string) (*devi
 				FileNameFormat:          &fileNameFormat,
 				BatchFrequencyInSeconds: &batchFrequencyInSeconds,
 				MaxChunkSizeInBytes:     &maxChunkSizeInBytes,
-				Encoding:                &encoding,
+				Encoding:                devices.Encoding(encoding),
 			}
 			storageContainerProperties = append(storageContainerProperties, storageContainer)
 
@@ -573,6 +625,26 @@ func expandIoTHubEndpoints(d *schema.ResourceData, subscriptionId string) (*devi
 	}, nil
 }
 
+func expandIoTHubFallbackRoute(d *schema.ResourceData) *devices.FallbackRouteProperties {
+	fallbackRouteList := d.Get("fallback_route").([]interface{})
+	if len(fallbackRouteList) == 0 {
+		return nil
+	}
+
+	fallbackRouteMap := fallbackRouteList[0].(map[string]interface{})
+
+	source := fallbackRouteMap["source"].(string)
+	condition := fallbackRouteMap["condition"].(string)
+	isEnabled := fallbackRouteMap["enabled"].(bool)
+
+	return &devices.FallbackRouteProperties{
+		Source:        &source,
+		Condition:     &condition,
+		EndpointNames: utils.ExpandStringArray(fallbackRouteMap["endpoint_names"].([]interface{})),
+		IsEnabled:     &isEnabled,
+	}
+}
+
 func expandIoTHubSku(d *schema.ResourceData) *devices.IotHubSkuInfo {
 	skuList := d.Get("sku").([]interface{})
 	skuMap := skuList[0].(map[string]interface{})
@@ -654,9 +726,8 @@ func flattenIoTHubEndpoint(input *devices.RoutingProperties) []interface{} {
 				if chunkSize := container.MaxChunkSizeInBytes; chunkSize != nil {
 					output["max_chunk_size_in_bytes"] = *chunkSize
 				}
-				if encoding := container.Encoding; encoding != nil {
-					output["encoding"] = *encoding
-				}
+
+				output["encoding"] = string(container.Encoding)
 				output["type"] = "AzureIotHub.StorageContainer"
 
 				results = append(results, output)
@@ -740,6 +811,29 @@ func flattenIoTHubRoute(input *devices.RoutingProperties) []interface{} {
 	return results
 }
 
+func flattenIoTHubFallbackRoute(input *devices.RoutingProperties) []interface{} {
+	if input.FallbackRoute == nil {
+		return []interface{}{}
+	}
+
+	output := make(map[string]interface{})
+	route := input.FallbackRoute
+
+	if condition := route.Condition; condition != nil {
+		output["condition"] = *condition
+	}
+	if isEnabled := route.IsEnabled; isEnabled != nil {
+		output["enabled"] = *isEnabled
+	}
+	if source := route.Source; source != nil {
+		output["source"] = *source
+	}
+
+	output["endpoint_names"] = utils.FlattenStringArray(route.EndpointNames)
+
+	return []interface{}{output}
+}
+
 func validateIoTHubEndpointName(v interface{}, _ string) (warnings []string, errors []error) {
 	value := v.(string)
 

azurerm/resource_arm_iothub_test.go

@@ -113,6 +113,33 @@ func TestAccAzureRMIotHub_customRoutes(t *testing.T) {
 	})
 }
 
+func TestAccAzureRMIotHub_fallbackRoute(t *testing.T) {
+	resourceName := "azurerm_iothub.test"
+	rInt := tf.AccRandTimeInt()
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testCheckAzureRMIotHubDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAzureRMIotHub_fallbackRoute(rInt, testLocation()),
+				Check: resource.ComposeTestCheckFunc(
+					testCheckAzureRMIotHubExists(resourceName),
+					resource.TestCheckResourceAttr(resourceName, "fallback_route.0.source", "DeviceMessages"),
+					resource.TestCheckResourceAttr(resourceName, "fallback_route.0.endpoint_names.#", "1"),
+					resource.TestCheckResourceAttr(resourceName, "fallback_route.0.enabled", "true"),
+				),
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func testCheckAzureRMIotHubDestroy(s *terraform.State) error {
 	client := testAccProvider.Meta().(*ArmClient).iothubResourceClient
 	ctx := testAccProvider.Meta().(*ArmClient).StopContext
@@ -298,3 +325,34 @@ resource "azurerm_iothub" "test" {
 }
 `, rInt, location, rStr, rInt)
 }
+
+func testAccAzureRMIotHub_fallbackRoute(rInt int, location string) string {
+	return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-%d"
+  location = "%s"
+}
+
+resource "azurerm_iothub" "test" {
+  name                  = "acctestIoTHub-%d"
+  resource_group_name   = "${azurerm_resource_group.test.name}"
+  location              = "${azurerm_resource_group.test.location}"
+
+  sku {
+    name     = "S1"
+    tier     = "Standard"
+    capacity = "1"
+  }
+
+  fallback_route {
+    source         = "DeviceMessages"
+    endpoint_names = ["events"]
+    enabled        = true
+  }
+
+	tags {
+    "purpose" = "testing"
+  }
+}
+`, rInt, location, rInt)
+}