Adding Operational Insight Workspace (a.k.a Log Analytics)

azurerm/config.go

@@ -19,6 +19,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/arm/graphrbac"
 	"github.com/Azure/azure-sdk-for-go/arm/keyvault"
 	"github.com/Azure/azure-sdk-for-go/arm/network"
+	"github.com/Azure/azure-sdk-for-go/arm/operationalinsights"
 	"github.com/Azure/azure-sdk-for-go/arm/redis"
 	"github.com/Azure/azure-sdk-for-go/arm/resources/resources"
 	"github.com/Azure/azure-sdk-for-go/arm/scheduler"
@@ -87,6 +88,8 @@ type ArmClient struct {
 	eventHubConsumerGroupClient eventhub.ConsumerGroupsClient
 	eventHubNamespacesClient    eventhub.NamespacesClient
 
+	workspacesClient operationalinsights.WorkspacesClient
+
 	providers           resources.ProvidersClient
 	resourceGroupClient resources.GroupsClient
 	tagsClient          resources.TagsClient
@@ -334,6 +337,12 @@ func (c *Config) getArmClient() (*ArmClient, error) {
 	lgc.Sender = autorest.CreateSender(withRequestLogging())
 	client.localNetConnClient = lgc
 
+	opwc := operationalinsights.NewWorkspacesClient(c.SubscriptionID)
+	setUserAgent(&opwc.Client)
+	opwc.Authorizer = auth
+	opwc.Sender = autorest.CreateSender(withRequestLogging())
+	client.workspacesClient = opwc
+
 	pipc := network.NewPublicIPAddressesClientWithBaseURI(endpoint, c.SubscriptionID)
 	setUserAgent(&pipc.Client)
 	pipc.Authorizer = auth

azurerm/import_arm_operational_insight_workspace_test.go

@@ -0,0 +1,56 @@
+package azurerm
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccAzureRMOperationalInsightWorkspace_importrequiredOnly(t *testing.T) {
+	resourceName := "azurerm_operational_insight_workspace.test"
+
+	ri := acctest.RandInt()
+	config := testAccAzureRMOperationalInsightWorkspace_requiredOnly(ri, testLocation())
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testCheckAzureRMOperationalInsightWorkspaceDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: config,
+			},
+
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
+func TestAccAzureRMOperationalInsightWorkspace_importoptional(t *testing.T) {
+	resourceName := "azurerm_operational_insight_workspace.test"
+
+	ri := acctest.RandInt()
+	config := testAccAzureRMOperationalInsightWorkspace_optional(ri, testLocation())
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testCheckAzureRMOperationalInsightWorkspaceDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: config,
+			},
+
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}

azurerm/provider.go

@@ -104,11 +104,12 @@ func Provider() terraform.ResourceProvider {
 			"azurerm_lb_rule":                 resourceArmLoadBalancerRule(),
 			"azurerm_local_network_gateway":   resourceArmLocalNetworkGateway(),
 
-			"azurerm_managed_disk":           resourceArmManagedDisk(),
-			"azurerm_network_interface":      resourceArmNetworkInterface(),
-			"azurerm_network_security_group": resourceArmNetworkSecurityGroup(),
-			"azurerm_network_security_rule":  resourceArmNetworkSecurityRule(),
-			"azurerm_public_ip":              resourceArmPublicIp(),
+			"azurerm_managed_disk":                  resourceArmManagedDisk(),
+			"azurerm_network_interface":             resourceArmNetworkInterface(),
+			"azurerm_network_security_group":        resourceArmNetworkSecurityGroup(),
+			"azurerm_network_security_rule":         resourceArmNetworkSecurityRule(),
+			"azurerm_operational_insight_workspace": resourceArmOperationalInsightWorkspaceService(),
+			"azurerm_public_ip":                     resourceArmPublicIp(),
 
 			"azurerm_redis_cache": resourceArmRedisCache(),
 			"azurerm_route":       resourceArmRoute(),
@@ -254,21 +255,22 @@ func registerAzureResourceProvidersWithSubscription(providerList []resources.Pro
 	var err error
 	providerRegistrationOnce.Do(func() {
 		providers := map[string]struct{}{
-			"Microsoft.Cache":             struct{}{},
-			"Microsoft.Cdn":               struct{}{},
-			"Microsoft.Compute":           struct{}{},
-			"Microsoft.ContainerRegistry": struct{}{},
-			"Microsoft.ContainerService":  struct{}{},
-			"Microsoft.DocumentDB":        struct{}{},
-			"Microsoft.EventHub":          struct{}{},
-			"Microsoft.KeyVault":          struct{}{},
-			"Microsoft.Insights":          struct{}{},
-			"Microsoft.Network":           struct{}{},
-			"Microsoft.Resources":         struct{}{},
-			"Microsoft.Search":            struct{}{},
-			"Microsoft.ServiceBus":        struct{}{},
-			"Microsoft.Sql":               struct{}{},
-			"Microsoft.Storage":           struct{}{},
+			"Microsoft.Cache":               struct{}{},
+			"Microsoft.Cdn":                 struct{}{},
+			"Microsoft.Compute":             struct{}{},
+			"Microsoft.ContainerRegistry":   struct{}{},
+			"Microsoft.ContainerService":    struct{}{},
+			"Microsoft.DocumentDB":          struct{}{},
+			"Microsoft.EventHub":            struct{}{},
+			"Microsoft.KeyVault":            struct{}{},
+			"Microsoft.Insights":            struct{}{},
+			"Microsoft.Network":             struct{}{},
+			"Microsoft.OperationalInsights": struct{}{},
+			"Microsoft.Resources":           struct{}{},
+			"Microsoft.Search":              struct{}{},
+			"Microsoft.ServiceBus":          struct{}{},
+			"Microsoft.Sql":                 struct{}{},
+			"Microsoft.Storage":             struct{}{},
 		}
 
 		// filter out any providers already registered

azurerm/resource_arm_operational_insight_workspace.go

@@ -0,0 +1,224 @@
+package azurerm
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"regexp"
+
+	"github.com/Azure/azure-sdk-for-go/arm/operationalinsights"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceArmOperationalInsightWorkspaceService() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceArmOperationalInsightWorkspaceCreateUpdate,
+		Read:   resourceArmOperationalInsightWorkspaceRead,
+		Update: resourceArmOperationalInsightWorkspaceCreateUpdate,
+		Delete: resourceArmOperationalInsightWorkspaceDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validateAzureRmOperationalInsightWorkspaceName,
+			},
+			"location": {
+				Type:      schema.TypeString,
+				Required:  true,
+				ForceNew:  true,
+				StateFunc: azureRMNormalizeLocation,
+			},
+			"resource_group_name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"workspace_id": { // a.k.a. customer_id
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"portal_url": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"sku": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"retention_in_days": {
+				Type:     schema.TypeInt,
+				Optional: true,
+				Computed: true,
+			},
+			"primary_shared_key": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"secondary_shared_key": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"tags": tagsSchema(),
+		},
+	}
+}
+
+func resourceArmOperationalInsightWorkspaceCreateUpdate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*ArmClient).workspacesClient
+	log.Printf("[INFO] preparing arguments for AzureRM Operational Insight workspace creation.")
+
+	name := d.Get("name").(string)
+	location := d.Get("location").(string)
+	resGroup := d.Get("resource_group_name").(string)
+
+	skuName := d.Get("sku")
+	sku, err := getSku(skuName)
+	if err != nil {
+		return err
+	}
+
+	retentionInDays := int32(d.Get("retention_in_days").(int))
+
+	tags := d.Get("tags").(map[string]interface{})
+
+	parameters := operationalinsights.Workspace{
+		Name:     &name,
+		Location: &location,
+		Tags:     expandTags(tags),
+		WorkspaceProperties: &operationalinsights.WorkspaceProperties{
+			Sku:             sku,
+			RetentionInDays: &retentionInDays,
+		},
+	}
+
+	cancel := make(chan struct{})
+	workspaceChannel, error := client.CreateOrUpdate(resGroup, name, parameters, cancel)
+	workspace := <-workspaceChannel
+	err = <-error
+	if err != nil {
+		return err
+	}
+	// The cosmos DB read rest api again for getting id. Try remove it.
+	// read, err := client.Get(resGroup, name)
+	// if err != nil {
+	//	return err
+	//}
+
+	//if read.ID == nil {
+	//	return fmt.Errorf("Cannot read Operational Inight Workspace '%s' (resource group %s) ID", name, resGroup)
+	//}
+	d.SetId(*workspace.ID)
+
+	return resourceArmOperationalInsightWorkspaceRead(d, meta)
+
+}
+
+func resourceArmOperationalInsightWorkspaceRead(d *schema.ResourceData, meta interface{}) error {
+	// I don't understand why we can get the meta data. How the framework set it.
+	client := meta.(*ArmClient).workspacesClient
+	id, err := parseAzureResourceID(d.Id())
+	if err != nil {
+		return err
+	}
+	resGroup := id.ResourceGroup
+	name := id.Path["workspaces"]
+
+	resp, err := client.Get(resGroup, name)
+	if err != nil {
+		if responseWasNotFound(resp.Response) {
+			d.SetId("")
+			return nil
+		}
+		return fmt.Errorf("Error making Read request on AzureRM Operational Insight workspaces '%s': %s", name, err)
+	}
+
+	d.Set("name", resp.Name)
+	d.Set("location", resp.Location)
+	d.Set("resource_group_name", resGroup)
+	d.Set("workspace_id", resp.CustomerID)
+	d.Set("portal_url", resp.PortalURL)
+	d.Set("sku", resp.Sku.Name)
+	d.Set("retention_in_days", resp.RetentionInDays)
+
+	sharedKeys, err := client.GetSharedKeys(resGroup, name)
+	if err != nil {
+		log.Printf("[ERROR] Unable to List Shared keys for Operatinal Insight workspaces %s: %s", name, err)
+	} else {
+		d.Set("primary_shared_key", sharedKeys.PrimarySharedKey)
+		d.Set("secondary_shared_key", sharedKeys.SecondarySharedKey)
+	}
+
+	flattenAndSetTags(d, resp.Tags)
+	return nil
+}
+
+func resourceArmOperationalInsightWorkspaceDelete(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*ArmClient).workspacesClient
+
+	id, err := parseAzureResourceID(d.Id())
+	if err != nil {
+		return err
+	}
+	resGroup := id.ResourceGroup
+	name := id.Path["workspaces"]
+
+	resp, err := client.Delete(resGroup, name)
+
+	if err != nil {
+		if resp.StatusCode == http.StatusNotFound {
+			return nil
+		}
+
+		return fmt.Errorf("Error issuing AzureRM delete request for Operational Insight Workspaces '%s': %+v", name, err)
+	}
+
+	return nil
+}
+
+func getSku(skuName interface{}) (*operationalinsights.Sku, error) {
+	if skuName == nil {
+		return nil, nil
+	}
+	skuEnum, err := getSkuNameEnum(skuName.(string))
+	if err != nil {
+		return nil, err
+	}
+	return &operationalinsights.Sku{
+		Name: skuEnum,
+	}, nil
+}
+
+func getSkuNameEnum(skuName string) (operationalinsights.SkuNameEnum, error) {
+	switch skuName {
+	case "Free":
+		return operationalinsights.Free, nil
+	case "PerNode":
+		return operationalinsights.PerNode, nil
+	case "Premium":
+		return operationalinsights.Premium, nil
+	case "Standalone":
+		return operationalinsights.Standalone, nil
+	case "Standard":
+		return operationalinsights.Standard, nil
+	case "Unlimited":
+		return operationalinsights.Unlimited, nil
+	default:
+		return operationalinsights.Free, fmt.Errorf("Sku name not found")
+	}
+}
+
+func validateAzureRmOperationalInsightWorkspaceName(v interface{}, k string) (ws []string, errors []error) {
+	value := v.(string)
+
+	r, _ := regexp.Compile("^[A-Za-z0-9][A-Za-z0-9-]+[A-Za-z0-9]$")
+	if !r.MatchString(value) {
+		errors = append(errors, fmt.Errorf("Workspace Name can only contain alphabet, number, and '-' charactor. You can not use '-' as the start and end of the name."))
+	}
+	return
+}