Add option in IoTHub to Enable Fallback Route

azurerm/resource_arm_iothub.go

@@ -248,6 +248,51 @@ func resourceArmIotHub() *schema.Resource {
 				},
 			},
 
+			"fallback_route": {
+				Type:     schema.TypeList,
+				MaxItems: 1,
+				Optional: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"name": {
+							Type:         schema.TypeString,
+							Optional:     true,
+							Default:      "$fallback",
+							ValidateFunc: validation.StringLenBetween(0, 64),
+						},
+						"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_name": {
+							Type:         schema.TypeString,
+							Optional:     true,
+							Default:      "events",
+							ValidateFunc: validation.StringLenBetween(0, 64),
+						},
+						"enabled": {
+							Type:     schema.TypeBool,
+							Optional: true,
+						},
+					},
+				},
+			},
+
 			"tags": tagsSchema(),
 		},
 	}
@@ -292,6 +337,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 +352,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),
@@ -393,6 +440,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)
@@ -573,6 +625,24 @@ func expandIoTHubEndpoints(d *schema.ResourceData, subscriptionId string) (*devi
 	}, nil
 }
 
+func expandIoTHubFallbackRoute(d *schema.ResourceData) *devices.FallbackRouteProperties {
+	fallbackRouteList := d.Get("fallback_route").([]interface{})
+	fallbackRouteMap := fallbackRouteList[0].(map[string]interface{})
+
+	name := fallbackRouteMap["name"].(string)
+	source := fallbackRouteMap["source"].(string)
+	endpointNames := make([]string, 0)
+	endpointNames = append(endpointNames, fallbackRouteMap["endpoint_name"].(string))
+	isEnabled := fallbackRouteMap["enabled"].(bool)
+
+	return &devices.FallbackRouteProperties{
+		Name:          &name,
+		Source:        &source,
+		EndpointNames: &endpointNames,
+		IsEnabled:     &isEnabled,
+	}
+}
+
 func expandIoTHubSku(d *schema.ResourceData) *devices.IotHubSkuInfo {
 	skuList := d.Get("sku").([]interface{})
 	skuMap := skuList[0].(map[string]interface{})
@@ -740,6 +810,28 @@ func flattenIoTHubRoute(input *devices.RoutingProperties) []interface{} {
 	return results
 }
 
+func flattenIoTHubFallbackRoute(input *devices.RoutingProperties) []interface{} {
+	output := make(map[string]interface{})
+
+	if input.FallbackRoute != nil {
+		if name := input.FallbackRoute.Name; name != nil {
+			output["name"] = *name
+		}
+		if condition := input.FallbackRoute.Condition; condition != nil {
+			output["condition"] = *condition
+		}
+		if endpointNames := input.FallbackRoute.EndpointNames; endpointNames != nil {
+			output["endpoint_name"] = (*endpointNames)[0]
+		}
+		if isEnabled := input.FallbackRoute.IsEnabled; isEnabled != nil {
+			output["enabled"] = *isEnabled
+		}
+		output["source"] = input.FallbackRoute.Source
+	}
+
+	return []interface{}{output}
+}
+
 func validateIoTHubEndpointName(v interface{}, _ string) (warnings []string, errors []error) {
 	value := v.(string)
 

azurerm/resource_arm_iothub_test.go

@@ -113,6 +113,30 @@ 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),
+				),
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func testCheckAzureRMIotHubDestroy(s *terraform.State) error {
 	client := testAccProvider.Meta().(*ArmClient).iothubResourceClient
 	ctx := testAccProvider.Meta().(*ArmClient).StopContext
@@ -298,3 +322,35 @@ 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 {
+    name           = "fallback"
+    source         = "DeviceMessages"
+    endpoint_name  = "fallback"
+    enabled        = true
+  }
+
+	tags {
+    "purpose" = "testing"
+  }
+}
+`, rInt, location, rInt)
+}

website/docs/r/iothub.html.markdown

@@ -34,9 +34,9 @@ resource "azurerm_storage_container" "test" {
 }
 
 resource "azurerm_iothub" "test" {
-  name                = "test"
-  resource_group_name = "${azurerm_resource_group.test.name}"
-  location            = "${azurerm_resource_group.test.location}"
+  name                  = "test"
+  resource_group_name   = "${azurerm_resource_group.test.name}"
+  location              = "${azurerm_resource_group.test.location}"
 
   sku {
     name     = "S1"
@@ -63,6 +63,10 @@ resource "azurerm_iothub" "test" {
     enabled        = true
   }
 
+  fallback_route {
+    enabled        = true
+  }
+
   tags {
     "purpose" = "testing"
   }
@@ -85,6 +89,8 @@ The following arguments are supported:
 
 * `route` - (Optional) A `route` block as defined below.
 
+* `fallback_route` - (Optional) A `fallback_route` block as defined below. If the fallback route is enabled, messages that don't match any of the supplied routes are automatically sent to this route. Defaults to messages/events.
+
 * `tags` - (Optional) A mapping of tags to assign to the resource.
 
 ---
@@ -133,6 +139,20 @@ A `route` block supports the following:
 
 * `enabled` - (Required) Used to specify whether a route is enabled.
 
+---
+
+A `fallback_route` block supports the following:
+
+* `name` - (Optional) The name of the route. The name can only include alphanumeric characters, periods, underscores, hyphens, has a maximum length of 64 characters, and must be unique.
+
+* `source` - (Optional) The source that the routing rule is to be applied to, such as `DeviceMessages`. Possible values include: `RoutingSourceInvalid`, `RoutingSourceDeviceMessages`, `RoutingSourceTwinChangeEvents`, `RoutingSourceDeviceLifecycleEvents`, `RoutingSourceDeviceJobLifecycleEvents`.
+
+* `condition` - (Optional) The condition that is evaluated to apply the routing rule. If no condition is provided, it evaluates to true by default. For grammar, see: https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-query-language.
+
+* `endpoint_name` - (Optional) The endpoint to which messages that satisfy the condition are routed. Currently only 1 endpoint is allowed.
+
+* `enabled` - (Optional) Used to specify whether the fallback route is enabled.
+
 ## Attributes Reference
 
 The following attributes are exported: