github.com/anfernee/terraform@v0.6.16-0.20160430000239-06e5085a92f2/builtin/providers/azurerm/config.go (about)

     1  package azurerm
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"net/http"
     7  	"time"
     8  
     9  	"github.com/Azure/azure-sdk-for-go/Godeps/_workspace/src/github.com/Azure/go-autorest/autorest"
    10  	"github.com/Azure/azure-sdk-for-go/Godeps/_workspace/src/github.com/Azure/go-autorest/autorest/azure"
    11  	"github.com/Azure/azure-sdk-for-go/arm/cdn"
    12  	"github.com/Azure/azure-sdk-for-go/arm/compute"
    13  	"github.com/Azure/azure-sdk-for-go/arm/network"
    14  	"github.com/Azure/azure-sdk-for-go/arm/resources/resources"
    15  	"github.com/Azure/azure-sdk-for-go/arm/scheduler"
    16  	"github.com/Azure/azure-sdk-for-go/arm/storage"
    17  	mainStorage "github.com/Azure/azure-sdk-for-go/storage"
    18  	"github.com/hashicorp/terraform/terraform"
    19  	riviera "github.com/jen20/riviera/azure"
    20  )
    21  
    22  // ArmClient contains the handles to all the specific Azure Resource Manager
    23  // resource classes' respective clients.
    24  type ArmClient struct {
    25  	rivieraClient *riviera.Client
    26  
    27  	availSetClient         compute.AvailabilitySetsClient
    28  	usageOpsClient         compute.UsageOperationsClient
    29  	vmExtensionImageClient compute.VirtualMachineExtensionImagesClient
    30  	vmExtensionClient      compute.VirtualMachineExtensionsClient
    31  	vmImageClient          compute.VirtualMachineImagesClient
    32  	vmClient               compute.VirtualMachinesClient
    33  
    34  	appGatewayClient             network.ApplicationGatewaysClient
    35  	ifaceClient                  network.InterfacesClient
    36  	loadBalancerClient           network.LoadBalancersClient
    37  	localNetConnClient           network.LocalNetworkGatewaysClient
    38  	publicIPClient               network.PublicIPAddressesClient
    39  	secGroupClient               network.SecurityGroupsClient
    40  	secRuleClient                network.SecurityRulesClient
    41  	subnetClient                 network.SubnetsClient
    42  	netUsageClient               network.UsagesClient
    43  	vnetGatewayConnectionsClient network.VirtualNetworkGatewayConnectionsClient
    44  	vnetGatewayClient            network.VirtualNetworkGatewaysClient
    45  	vnetClient                   network.VirtualNetworksClient
    46  	routeTablesClient            network.RouteTablesClient
    47  	routesClient                 network.RoutesClient
    48  
    49  	cdnProfilesClient  cdn.ProfilesClient
    50  	cdnEndpointsClient cdn.EndpointsClient
    51  
    52  	providers           resources.ProvidersClient
    53  	resourceGroupClient resources.GroupsClient
    54  	tagsClient          resources.TagsClient
    55  
    56  	jobsClient            scheduler.JobsClient
    57  	jobsCollectionsClient scheduler.JobCollectionsClient
    58  
    59  	storageServiceClient storage.AccountsClient
    60  	storageUsageClient   storage.UsageOperationsClient
    61  
    62  	deploymentsClient resources.DeploymentsClient
    63  }
    64  
    65  func withRequestLogging() autorest.SendDecorator {
    66  	return func(s autorest.Sender) autorest.Sender {
    67  		return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
    68  			log.Printf("[DEBUG] Sending Azure RM Request %q to %q\n", r.Method, r.URL)
    69  			resp, err := s.Do(r)
    70  			if resp != nil {
    71  				log.Printf("[DEBUG] Received Azure RM Request status code %s for %s\n", resp.Status, r.URL)
    72  			} else {
    73  				log.Printf("[DEBUG] Request to %s completed with no response", r.URL)
    74  			}
    75  			return resp, err
    76  		})
    77  	}
    78  }
    79  
    80  func withPollWatcher() autorest.SendDecorator {
    81  	return func(s autorest.Sender) autorest.Sender {
    82  		return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
    83  			fmt.Printf("[DEBUG] Sending Azure RM Request %q to %q\n", r.Method, r.URL)
    84  			resp, err := s.Do(r)
    85  			fmt.Printf("[DEBUG] Received Azure RM Request status code %s for %s\n", resp.Status, r.URL)
    86  			if autorest.ResponseRequiresPolling(resp) {
    87  				fmt.Printf("[DEBUG] Azure RM request will poll %s after %d seconds\n",
    88  					autorest.GetPollingLocation(resp),
    89  					int(autorest.GetPollingDelay(resp, time.Duration(0))/time.Second))
    90  			}
    91  			return resp, err
    92  		})
    93  	}
    94  }
    95  
    96  func setUserAgent(client *autorest.Client) {
    97  	var version string
    98  	if terraform.VersionPrerelease != "" {
    99  		version = fmt.Sprintf("%s-%s", terraform.Version, terraform.VersionPrerelease)
   100  	} else {
   101  		version = terraform.Version
   102  	}
   103  
   104  	client.UserAgent = fmt.Sprintf("HashiCorp-Terraform-v%s", version)
   105  }
   106  
   107  // getArmClient is a helper method which returns a fully instantiated
   108  // *ArmClient based on the Config's current settings.
   109  func (c *Config) getArmClient() (*ArmClient, error) {
   110  	// client declarations:
   111  	client := ArmClient{}
   112  
   113  	rivieraClient, err := riviera.NewClient(&riviera.AzureResourceManagerCredentials{
   114  		ClientID:       c.ClientID,
   115  		ClientSecret:   c.ClientSecret,
   116  		TenantID:       c.TenantID,
   117  		SubscriptionID: c.SubscriptionID,
   118  	})
   119  	if err != nil {
   120  		return nil, fmt.Errorf("Error creating Riviera client: %s", err)
   121  	}
   122  
   123  	// validate that the credentials are correct using Riviera. Note that this must be
   124  	// done _before_ using the Microsoft SDK, because Riviera handles errors. Using a
   125  	// namespace registration instead of a simple OAuth token refresh guarantees that
   126  	// service delegation is correct. This has the effect of registering Microsoft.Compute
   127  	// which is neccessary anyway.
   128  	if err := registerProviderWithSubscription("Microsoft.Compute", rivieraClient); err != nil {
   129  		return nil, err
   130  	}
   131  	client.rivieraClient = rivieraClient
   132  
   133  	spt, err := azure.NewServicePrincipalToken(c.ClientID, c.ClientSecret, c.TenantID, azure.AzureResourceManagerScope)
   134  	if err != nil {
   135  		return nil, err
   136  	}
   137  
   138  	// NOTE: these declarations should be left separate for clarity should the
   139  	// clients be wished to be configured with custom Responders/PollingModess etc...
   140  	asc := compute.NewAvailabilitySetsClient(c.SubscriptionID)
   141  	setUserAgent(&asc.Client)
   142  	asc.Authorizer = spt
   143  	asc.Sender = autorest.CreateSender(withRequestLogging())
   144  	client.availSetClient = asc
   145  
   146  	uoc := compute.NewUsageOperationsClient(c.SubscriptionID)
   147  	setUserAgent(&uoc.Client)
   148  	uoc.Authorizer = spt
   149  	uoc.Sender = autorest.CreateSender(withRequestLogging())
   150  	client.usageOpsClient = uoc
   151  
   152  	vmeic := compute.NewVirtualMachineExtensionImagesClient(c.SubscriptionID)
   153  	setUserAgent(&vmeic.Client)
   154  	vmeic.Authorizer = spt
   155  	vmeic.Sender = autorest.CreateSender(withRequestLogging())
   156  	client.vmExtensionImageClient = vmeic
   157  
   158  	vmec := compute.NewVirtualMachineExtensionsClient(c.SubscriptionID)
   159  	setUserAgent(&vmec.Client)
   160  	vmec.Authorizer = spt
   161  	vmec.Sender = autorest.CreateSender(withRequestLogging())
   162  	client.vmExtensionClient = vmec
   163  
   164  	vmic := compute.NewVirtualMachineImagesClient(c.SubscriptionID)
   165  	setUserAgent(&vmic.Client)
   166  	vmic.Authorizer = spt
   167  	vmic.Sender = autorest.CreateSender(withRequestLogging())
   168  	client.vmImageClient = vmic
   169  
   170  	vmc := compute.NewVirtualMachinesClient(c.SubscriptionID)
   171  	setUserAgent(&vmc.Client)
   172  	vmc.Authorizer = spt
   173  	vmc.Sender = autorest.CreateSender(withRequestLogging())
   174  	client.vmClient = vmc
   175  
   176  	agc := network.NewApplicationGatewaysClient(c.SubscriptionID)
   177  	setUserAgent(&agc.Client)
   178  	agc.Authorizer = spt
   179  	agc.Sender = autorest.CreateSender(withRequestLogging())
   180  	client.appGatewayClient = agc
   181  
   182  	ifc := network.NewInterfacesClient(c.SubscriptionID)
   183  	setUserAgent(&ifc.Client)
   184  	ifc.Authorizer = spt
   185  	ifc.Sender = autorest.CreateSender(withRequestLogging())
   186  	client.ifaceClient = ifc
   187  
   188  	lbc := network.NewLoadBalancersClient(c.SubscriptionID)
   189  	setUserAgent(&lbc.Client)
   190  	lbc.Authorizer = spt
   191  	lbc.Sender = autorest.CreateSender(withRequestLogging())
   192  	client.loadBalancerClient = lbc
   193  
   194  	lgc := network.NewLocalNetworkGatewaysClient(c.SubscriptionID)
   195  	setUserAgent(&lgc.Client)
   196  	lgc.Authorizer = spt
   197  	lgc.Sender = autorest.CreateSender(withRequestLogging())
   198  	client.localNetConnClient = lgc
   199  
   200  	pipc := network.NewPublicIPAddressesClient(c.SubscriptionID)
   201  	setUserAgent(&pipc.Client)
   202  	pipc.Authorizer = spt
   203  	pipc.Sender = autorest.CreateSender(withRequestLogging())
   204  	client.publicIPClient = pipc
   205  
   206  	sgc := network.NewSecurityGroupsClient(c.SubscriptionID)
   207  	setUserAgent(&sgc.Client)
   208  	sgc.Authorizer = spt
   209  	sgc.Sender = autorest.CreateSender(withRequestLogging())
   210  	client.secGroupClient = sgc
   211  
   212  	src := network.NewSecurityRulesClient(c.SubscriptionID)
   213  	setUserAgent(&src.Client)
   214  	src.Authorizer = spt
   215  	src.Sender = autorest.CreateSender(withRequestLogging())
   216  	client.secRuleClient = src
   217  
   218  	snc := network.NewSubnetsClient(c.SubscriptionID)
   219  	setUserAgent(&snc.Client)
   220  	snc.Authorizer = spt
   221  	snc.Sender = autorest.CreateSender(withRequestLogging())
   222  	client.subnetClient = snc
   223  
   224  	vgcc := network.NewVirtualNetworkGatewayConnectionsClient(c.SubscriptionID)
   225  	setUserAgent(&vgcc.Client)
   226  	vgcc.Authorizer = spt
   227  	vgcc.Sender = autorest.CreateSender(withRequestLogging())
   228  	client.vnetGatewayConnectionsClient = vgcc
   229  
   230  	vgc := network.NewVirtualNetworkGatewaysClient(c.SubscriptionID)
   231  	setUserAgent(&vgc.Client)
   232  	vgc.Authorizer = spt
   233  	vgc.Sender = autorest.CreateSender(withRequestLogging())
   234  	client.vnetGatewayClient = vgc
   235  
   236  	vnc := network.NewVirtualNetworksClient(c.SubscriptionID)
   237  	setUserAgent(&vnc.Client)
   238  	vnc.Authorizer = spt
   239  	vnc.Sender = autorest.CreateSender(withRequestLogging())
   240  	client.vnetClient = vnc
   241  
   242  	rtc := network.NewRouteTablesClient(c.SubscriptionID)
   243  	setUserAgent(&rtc.Client)
   244  	rtc.Authorizer = spt
   245  	rtc.Sender = autorest.CreateSender(withRequestLogging())
   246  	client.routeTablesClient = rtc
   247  
   248  	rc := network.NewRoutesClient(c.SubscriptionID)
   249  	setUserAgent(&rc.Client)
   250  	rc.Authorizer = spt
   251  	rc.Sender = autorest.CreateSender(withRequestLogging())
   252  	client.routesClient = rc
   253  
   254  	rgc := resources.NewGroupsClient(c.SubscriptionID)
   255  	setUserAgent(&rgc.Client)
   256  	rgc.Authorizer = spt
   257  	rgc.Sender = autorest.CreateSender(withRequestLogging())
   258  	client.resourceGroupClient = rgc
   259  
   260  	pc := resources.NewProvidersClient(c.SubscriptionID)
   261  	setUserAgent(&pc.Client)
   262  	pc.Authorizer = spt
   263  	pc.Sender = autorest.CreateSender(withRequestLogging())
   264  	client.providers = pc
   265  
   266  	tc := resources.NewTagsClient(c.SubscriptionID)
   267  	setUserAgent(&tc.Client)
   268  	tc.Authorizer = spt
   269  	tc.Sender = autorest.CreateSender(withRequestLogging())
   270  	client.tagsClient = tc
   271  
   272  	jc := scheduler.NewJobsClient(c.SubscriptionID)
   273  	setUserAgent(&jc.Client)
   274  	jc.Authorizer = spt
   275  	jc.Sender = autorest.CreateSender(withRequestLogging())
   276  	client.jobsClient = jc
   277  
   278  	jcc := scheduler.NewJobCollectionsClient(c.SubscriptionID)
   279  	setUserAgent(&jcc.Client)
   280  	jcc.Authorizer = spt
   281  	jcc.Sender = autorest.CreateSender(withRequestLogging())
   282  	client.jobsCollectionsClient = jcc
   283  
   284  	ssc := storage.NewAccountsClient(c.SubscriptionID)
   285  	setUserAgent(&ssc.Client)
   286  	ssc.Authorizer = spt
   287  	ssc.Sender = autorest.CreateSender(withRequestLogging(), withPollWatcher())
   288  	client.storageServiceClient = ssc
   289  
   290  	suc := storage.NewUsageOperationsClient(c.SubscriptionID)
   291  	setUserAgent(&suc.Client)
   292  	suc.Authorizer = spt
   293  	suc.Sender = autorest.CreateSender(withRequestLogging())
   294  	client.storageUsageClient = suc
   295  
   296  	cpc := cdn.NewProfilesClient(c.SubscriptionID)
   297  	setUserAgent(&cpc.Client)
   298  	cpc.Authorizer = spt
   299  	cpc.Sender = autorest.CreateSender(withRequestLogging())
   300  	client.cdnProfilesClient = cpc
   301  
   302  	cec := cdn.NewEndpointsClient(c.SubscriptionID)
   303  	setUserAgent(&cec.Client)
   304  	cec.Authorizer = spt
   305  	cec.Sender = autorest.CreateSender(withRequestLogging())
   306  	client.cdnEndpointsClient = cec
   307  
   308  	dc := resources.NewDeploymentsClient(c.SubscriptionID)
   309  	setUserAgent(&dc.Client)
   310  	dc.Authorizer = spt
   311  	dc.Sender = autorest.CreateSender(withRequestLogging())
   312  	client.deploymentsClient = dc
   313  
   314  	return &client, nil
   315  }
   316  
   317  func (armClient *ArmClient) getKeyForStorageAccount(resourceGroupName, storageAccountName string) (string, error) {
   318  	keys, err := armClient.storageServiceClient.ListKeys(resourceGroupName, storageAccountName)
   319  	if err != nil {
   320  		return "", fmt.Errorf("Error retrieving keys for storage account %q: %s", storageAccountName, err)
   321  	}
   322  
   323  	if keys.Key1 == nil {
   324  		return "", fmt.Errorf("Nil key returned for storage account %q", storageAccountName)
   325  	}
   326  
   327  	return *keys.Key1, nil
   328  }
   329  
   330  func (armClient *ArmClient) getBlobStorageClientForStorageAccount(resourceGroupName, storageAccountName string) (*mainStorage.BlobStorageClient, error) {
   331  	key, err := armClient.getKeyForStorageAccount(resourceGroupName, storageAccountName)
   332  	if err != nil {
   333  		return nil, err
   334  	}
   335  
   336  	storageClient, err := mainStorage.NewBasicClient(storageAccountName, key)
   337  	if err != nil {
   338  		return nil, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
   339  	}
   340  
   341  	blobClient := storageClient.GetBlobService()
   342  	return &blobClient, nil
   343  }
   344  func (armClient *ArmClient) getQueueServiceClientForStorageAccount(resourceGroupName, storageAccountName string) (*mainStorage.QueueServiceClient, error) {
   345  	key, err := armClient.getKeyForStorageAccount(resourceGroupName, storageAccountName)
   346  	if err != nil {
   347  		return nil, err
   348  	}
   349  
   350  	storageClient, err := mainStorage.NewBasicClient(storageAccountName, key)
   351  	if err != nil {
   352  		return nil, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
   353  	}
   354  
   355  	queueClient := storageClient.GetQueueService()
   356  	return &queueClient, nil
   357  }