github.com/IBM-Cloud/terraform@v0.6.4-0.20170726051544-8872b87621df/builtin/providers/azurerm/config.go (about)

     1  package azurerm
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"log"
     7  	"net/http"
     8  	"net/http/httputil"
     9  
    10  	"github.com/Azure/azure-sdk-for-go/arm/cdn"
    11  	"github.com/Azure/azure-sdk-for-go/arm/compute"
    12  	"github.com/Azure/azure-sdk-for-go/arm/containerregistry"
    13  	"github.com/Azure/azure-sdk-for-go/arm/containerservice"
    14  	"github.com/Azure/azure-sdk-for-go/arm/disk"
    15  	"github.com/Azure/azure-sdk-for-go/arm/eventhub"
    16  	"github.com/Azure/azure-sdk-for-go/arm/keyvault"
    17  	"github.com/Azure/azure-sdk-for-go/arm/network"
    18  	"github.com/Azure/azure-sdk-for-go/arm/redis"
    19  	"github.com/Azure/azure-sdk-for-go/arm/resources/resources"
    20  	"github.com/Azure/azure-sdk-for-go/arm/scheduler"
    21  	"github.com/Azure/azure-sdk-for-go/arm/servicebus"
    22  	"github.com/Azure/azure-sdk-for-go/arm/sql"
    23  	"github.com/Azure/azure-sdk-for-go/arm/storage"
    24  	"github.com/Azure/azure-sdk-for-go/arm/trafficmanager"
    25  	mainStorage "github.com/Azure/azure-sdk-for-go/storage"
    26  	"github.com/Azure/go-autorest/autorest"
    27  	"github.com/Azure/go-autorest/autorest/azure"
    28  	"github.com/hashicorp/terraform/terraform"
    29  	riviera "github.com/jen20/riviera/azure"
    30  )
    31  
    32  // ArmClient contains the handles to all the specific Azure Resource Manager
    33  // resource classes' respective clients.
    34  type ArmClient struct {
    35  	clientId       string
    36  	tenantId       string
    37  	subscriptionId string
    38  	environment    azure.Environment
    39  
    40  	StopContext context.Context
    41  
    42  	rivieraClient *riviera.Client
    43  
    44  	availSetClient         compute.AvailabilitySetsClient
    45  	usageOpsClient         compute.UsageClient
    46  	vmExtensionImageClient compute.VirtualMachineExtensionImagesClient
    47  	vmExtensionClient      compute.VirtualMachineExtensionsClient
    48  	vmScaleSetClient       compute.VirtualMachineScaleSetsClient
    49  	vmImageClient          compute.VirtualMachineImagesClient
    50  	vmClient               compute.VirtualMachinesClient
    51  
    52  	diskClient disk.DisksClient
    53  
    54  	appGatewayClient             network.ApplicationGatewaysClient
    55  	ifaceClient                  network.InterfacesClient
    56  	expressRouteCircuitClient    network.ExpressRouteCircuitsClient
    57  	loadBalancerClient           network.LoadBalancersClient
    58  	localNetConnClient           network.LocalNetworkGatewaysClient
    59  	publicIPClient               network.PublicIPAddressesClient
    60  	secGroupClient               network.SecurityGroupsClient
    61  	secRuleClient                network.SecurityRulesClient
    62  	subnetClient                 network.SubnetsClient
    63  	netUsageClient               network.UsagesClient
    64  	vnetGatewayConnectionsClient network.VirtualNetworkGatewayConnectionsClient
    65  	vnetGatewayClient            network.VirtualNetworkGatewaysClient
    66  	vnetClient                   network.VirtualNetworksClient
    67  	vnetPeeringsClient           network.VirtualNetworkPeeringsClient
    68  	routeTablesClient            network.RouteTablesClient
    69  	routesClient                 network.RoutesClient
    70  
    71  	cdnProfilesClient  cdn.ProfilesClient
    72  	cdnEndpointsClient cdn.EndpointsClient
    73  
    74  	containerRegistryClient containerregistry.RegistriesClient
    75  	containerServicesClient containerservice.ContainerServicesClient
    76  
    77  	eventHubClient              eventhub.EventHubsClient
    78  	eventHubConsumerGroupClient eventhub.ConsumerGroupsClient
    79  	eventHubNamespacesClient    eventhub.NamespacesClient
    80  
    81  	providers           resources.ProvidersClient
    82  	resourceGroupClient resources.GroupsClient
    83  	tagsClient          resources.TagsClient
    84  	resourceFindClient  resources.GroupClient
    85  
    86  	jobsClient            scheduler.JobsClient
    87  	jobsCollectionsClient scheduler.JobCollectionsClient
    88  
    89  	storageServiceClient storage.AccountsClient
    90  	storageUsageClient   storage.UsageOperationsClient
    91  
    92  	deploymentsClient resources.DeploymentsClient
    93  
    94  	redisClient redis.GroupClient
    95  
    96  	trafficManagerProfilesClient  trafficmanager.ProfilesClient
    97  	trafficManagerEndpointsClient trafficmanager.EndpointsClient
    98  
    99  	serviceBusNamespacesClient    servicebus.NamespacesClient
   100  	serviceBusTopicsClient        servicebus.TopicsClient
   101  	serviceBusSubscriptionsClient servicebus.SubscriptionsClient
   102  
   103  	keyVaultClient keyvault.VaultsClient
   104  
   105  	sqlElasticPoolsClient sql.ElasticPoolsClient
   106  }
   107  
   108  func withRequestLogging() autorest.SendDecorator {
   109  	return func(s autorest.Sender) autorest.Sender {
   110  		return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
   111  			// dump request to wire format
   112  			if dump, err := httputil.DumpRequestOut(r, true); err == nil {
   113  				log.Printf("[DEBUG] AzureRM Request: \n%s\n", dump)
   114  			} else {
   115  				// fallback to basic message
   116  				log.Printf("[DEBUG] AzureRM Request: %s to %s\n", r.Method, r.URL)
   117  			}
   118  
   119  			resp, err := s.Do(r)
   120  			if resp != nil {
   121  				// dump response to wire format
   122  				if dump, err := httputil.DumpResponse(resp, true); err == nil {
   123  					log.Printf("[DEBUG] AzureRM Response for %s: \n%s\n", r.URL, dump)
   124  				} else {
   125  					// fallback to basic message
   126  					log.Printf("[DEBUG] AzureRM Response: %s for %s\n", resp.Status, r.URL)
   127  				}
   128  			} else {
   129  				log.Printf("[DEBUG] Request to %s completed with no response", r.URL)
   130  			}
   131  			return resp, err
   132  		})
   133  	}
   134  }
   135  
   136  func setUserAgent(client *autorest.Client) {
   137  	version := terraform.VersionString()
   138  	client.UserAgent = fmt.Sprintf("HashiCorp-Terraform-v%s", version)
   139  }
   140  
   141  // getArmClient is a helper method which returns a fully instantiated
   142  // *ArmClient based on the Config's current settings.
   143  func (c *Config) getArmClient() (*ArmClient, error) {
   144  	// detect cloud from environment
   145  	env, envErr := azure.EnvironmentFromName(c.Environment)
   146  	if envErr != nil {
   147  		// try again with wrapped value to support readable values like german instead of AZUREGERMANCLOUD
   148  		wrapped := fmt.Sprintf("AZURE%sCLOUD", c.Environment)
   149  		var innerErr error
   150  		if env, innerErr = azure.EnvironmentFromName(wrapped); innerErr != nil {
   151  			return nil, envErr
   152  		}
   153  	}
   154  
   155  	// client declarations:
   156  	client := ArmClient{
   157  		clientId:       c.ClientID,
   158  		tenantId:       c.TenantID,
   159  		subscriptionId: c.SubscriptionID,
   160  		environment:    env,
   161  	}
   162  
   163  	rivieraClient, err := riviera.NewClient(&riviera.AzureResourceManagerCredentials{
   164  		ClientID:                c.ClientID,
   165  		ClientSecret:            c.ClientSecret,
   166  		TenantID:                c.TenantID,
   167  		SubscriptionID:          c.SubscriptionID,
   168  		ResourceManagerEndpoint: env.ResourceManagerEndpoint,
   169  		ActiveDirectoryEndpoint: env.ActiveDirectoryEndpoint,
   170  	})
   171  	if err != nil {
   172  		return nil, fmt.Errorf("Error creating Riviera client: %s", err)
   173  	}
   174  	client.rivieraClient = rivieraClient
   175  
   176  	oauthConfig, err := env.OAuthConfigForTenant(c.TenantID)
   177  	if err != nil {
   178  		return nil, err
   179  	}
   180  
   181  	// OAuthConfigForTenant returns a pointer, which can be nil.
   182  	if oauthConfig == nil {
   183  		return nil, fmt.Errorf("Unable to configure OAuthConfig for tenant %s", c.TenantID)
   184  	}
   185  
   186  	spt, err := azure.NewServicePrincipalToken(*oauthConfig, c.ClientID, c.ClientSecret, env.ResourceManagerEndpoint)
   187  	if err != nil {
   188  		return nil, err
   189  	}
   190  
   191  	endpoint := env.ResourceManagerEndpoint
   192  
   193  	// NOTE: these declarations should be left separate for clarity should the
   194  	// clients be wished to be configured with custom Responders/PollingModess etc...
   195  	asc := compute.NewAvailabilitySetsClientWithBaseURI(endpoint, c.SubscriptionID)
   196  	setUserAgent(&asc.Client)
   197  	asc.Authorizer = spt
   198  	asc.Sender = autorest.CreateSender(withRequestLogging())
   199  	client.availSetClient = asc
   200  
   201  	uoc := compute.NewUsageClientWithBaseURI(endpoint, c.SubscriptionID)
   202  	setUserAgent(&uoc.Client)
   203  	uoc.Authorizer = spt
   204  	uoc.Sender = autorest.CreateSender(withRequestLogging())
   205  	client.usageOpsClient = uoc
   206  
   207  	vmeic := compute.NewVirtualMachineExtensionImagesClientWithBaseURI(endpoint, c.SubscriptionID)
   208  	setUserAgent(&vmeic.Client)
   209  	vmeic.Authorizer = spt
   210  	vmeic.Sender = autorest.CreateSender(withRequestLogging())
   211  	client.vmExtensionImageClient = vmeic
   212  
   213  	vmec := compute.NewVirtualMachineExtensionsClientWithBaseURI(endpoint, c.SubscriptionID)
   214  	setUserAgent(&vmec.Client)
   215  	vmec.Authorizer = spt
   216  	vmec.Sender = autorest.CreateSender(withRequestLogging())
   217  	client.vmExtensionClient = vmec
   218  
   219  	vmic := compute.NewVirtualMachineImagesClientWithBaseURI(endpoint, c.SubscriptionID)
   220  	setUserAgent(&vmic.Client)
   221  	vmic.Authorizer = spt
   222  	vmic.Sender = autorest.CreateSender(withRequestLogging())
   223  	client.vmImageClient = vmic
   224  
   225  	vmssc := compute.NewVirtualMachineScaleSetsClientWithBaseURI(endpoint, c.SubscriptionID)
   226  	setUserAgent(&vmssc.Client)
   227  	vmssc.Authorizer = spt
   228  	vmssc.Sender = autorest.CreateSender(withRequestLogging())
   229  	client.vmScaleSetClient = vmssc
   230  
   231  	vmc := compute.NewVirtualMachinesClientWithBaseURI(endpoint, c.SubscriptionID)
   232  	setUserAgent(&vmc.Client)
   233  	vmc.Authorizer = spt
   234  	vmc.Sender = autorest.CreateSender(withRequestLogging())
   235  	client.vmClient = vmc
   236  
   237  	agc := network.NewApplicationGatewaysClientWithBaseURI(endpoint, c.SubscriptionID)
   238  	setUserAgent(&agc.Client)
   239  	agc.Authorizer = spt
   240  	agc.Sender = autorest.CreateSender(withRequestLogging())
   241  	client.appGatewayClient = agc
   242  
   243  	crc := containerregistry.NewRegistriesClientWithBaseURI(endpoint, c.SubscriptionID)
   244  	setUserAgent(&crc.Client)
   245  	crc.Authorizer = spt
   246  	crc.Sender = autorest.CreateSender(withRequestLogging())
   247  	client.containerRegistryClient = crc
   248  
   249  	csc := containerservice.NewContainerServicesClientWithBaseURI(endpoint, c.SubscriptionID)
   250  	setUserAgent(&csc.Client)
   251  	csc.Authorizer = spt
   252  	csc.Sender = autorest.CreateSender(withRequestLogging())
   253  	client.containerServicesClient = csc
   254  
   255  	dkc := disk.NewDisksClientWithBaseURI(endpoint, c.SubscriptionID)
   256  	setUserAgent(&dkc.Client)
   257  	dkc.Authorizer = spt
   258  	dkc.Sender = autorest.CreateSender(withRequestLogging())
   259  	client.diskClient = dkc
   260  
   261  	ehc := eventhub.NewEventHubsClientWithBaseURI(endpoint, c.SubscriptionID)
   262  	setUserAgent(&ehc.Client)
   263  	ehc.Authorizer = spt
   264  	ehc.Sender = autorest.CreateSender(withRequestLogging())
   265  	client.eventHubClient = ehc
   266  
   267  	chcgc := eventhub.NewConsumerGroupsClientWithBaseURI(endpoint, c.SubscriptionID)
   268  	setUserAgent(&chcgc.Client)
   269  	chcgc.Authorizer = spt
   270  	chcgc.Sender = autorest.CreateSender(withRequestLogging())
   271  	client.eventHubConsumerGroupClient = chcgc
   272  
   273  	ehnc := eventhub.NewNamespacesClientWithBaseURI(endpoint, c.SubscriptionID)
   274  	setUserAgent(&ehnc.Client)
   275  	ehnc.Authorizer = spt
   276  	ehnc.Sender = autorest.CreateSender(withRequestLogging())
   277  	client.eventHubNamespacesClient = ehnc
   278  
   279  	ifc := network.NewInterfacesClientWithBaseURI(endpoint, c.SubscriptionID)
   280  	setUserAgent(&ifc.Client)
   281  	ifc.Authorizer = spt
   282  	ifc.Sender = autorest.CreateSender(withRequestLogging())
   283  	client.ifaceClient = ifc
   284  
   285  	erc := network.NewExpressRouteCircuitsClientWithBaseURI(endpoint, c.SubscriptionID)
   286  	setUserAgent(&erc.Client)
   287  	erc.Authorizer = spt
   288  	erc.Sender = autorest.CreateSender(withRequestLogging())
   289  	client.expressRouteCircuitClient = erc
   290  
   291  	lbc := network.NewLoadBalancersClientWithBaseURI(endpoint, c.SubscriptionID)
   292  	setUserAgent(&lbc.Client)
   293  	lbc.Authorizer = spt
   294  	lbc.Sender = autorest.CreateSender(withRequestLogging())
   295  	client.loadBalancerClient = lbc
   296  
   297  	lgc := network.NewLocalNetworkGatewaysClientWithBaseURI(endpoint, c.SubscriptionID)
   298  	setUserAgent(&lgc.Client)
   299  	lgc.Authorizer = spt
   300  	lgc.Sender = autorest.CreateSender(withRequestLogging())
   301  	client.localNetConnClient = lgc
   302  
   303  	pipc := network.NewPublicIPAddressesClientWithBaseURI(endpoint, c.SubscriptionID)
   304  	setUserAgent(&pipc.Client)
   305  	pipc.Authorizer = spt
   306  	pipc.Sender = autorest.CreateSender(withRequestLogging())
   307  	client.publicIPClient = pipc
   308  
   309  	sgc := network.NewSecurityGroupsClientWithBaseURI(endpoint, c.SubscriptionID)
   310  	setUserAgent(&sgc.Client)
   311  	sgc.Authorizer = spt
   312  	sgc.Sender = autorest.CreateSender(withRequestLogging())
   313  	client.secGroupClient = sgc
   314  
   315  	src := network.NewSecurityRulesClientWithBaseURI(endpoint, c.SubscriptionID)
   316  	setUserAgent(&src.Client)
   317  	src.Authorizer = spt
   318  	src.Sender = autorest.CreateSender(withRequestLogging())
   319  	client.secRuleClient = src
   320  
   321  	snc := network.NewSubnetsClientWithBaseURI(endpoint, c.SubscriptionID)
   322  	setUserAgent(&snc.Client)
   323  	snc.Authorizer = spt
   324  	snc.Sender = autorest.CreateSender(withRequestLogging())
   325  	client.subnetClient = snc
   326  
   327  	vgcc := network.NewVirtualNetworkGatewayConnectionsClientWithBaseURI(endpoint, c.SubscriptionID)
   328  	setUserAgent(&vgcc.Client)
   329  	vgcc.Authorizer = spt
   330  	vgcc.Sender = autorest.CreateSender(withRequestLogging())
   331  	client.vnetGatewayConnectionsClient = vgcc
   332  
   333  	vgc := network.NewVirtualNetworkGatewaysClientWithBaseURI(endpoint, c.SubscriptionID)
   334  	setUserAgent(&vgc.Client)
   335  	vgc.Authorizer = spt
   336  	vgc.Sender = autorest.CreateSender(withRequestLogging())
   337  	client.vnetGatewayClient = vgc
   338  
   339  	vnc := network.NewVirtualNetworksClientWithBaseURI(endpoint, c.SubscriptionID)
   340  	setUserAgent(&vnc.Client)
   341  	vnc.Authorizer = spt
   342  	vnc.Sender = autorest.CreateSender(withRequestLogging())
   343  	client.vnetClient = vnc
   344  
   345  	vnpc := network.NewVirtualNetworkPeeringsClientWithBaseURI(endpoint, c.SubscriptionID)
   346  	setUserAgent(&vnpc.Client)
   347  	vnpc.Authorizer = spt
   348  	vnpc.Sender = autorest.CreateSender(withRequestLogging())
   349  	client.vnetPeeringsClient = vnpc
   350  
   351  	rtc := network.NewRouteTablesClientWithBaseURI(endpoint, c.SubscriptionID)
   352  	setUserAgent(&rtc.Client)
   353  	rtc.Authorizer = spt
   354  	rtc.Sender = autorest.CreateSender(withRequestLogging())
   355  	client.routeTablesClient = rtc
   356  
   357  	rc := network.NewRoutesClientWithBaseURI(endpoint, c.SubscriptionID)
   358  	setUserAgent(&rc.Client)
   359  	rc.Authorizer = spt
   360  	rc.Sender = autorest.CreateSender(withRequestLogging())
   361  	client.routesClient = rc
   362  
   363  	rgc := resources.NewGroupsClientWithBaseURI(endpoint, c.SubscriptionID)
   364  	setUserAgent(&rgc.Client)
   365  	rgc.Authorizer = spt
   366  	rgc.Sender = autorest.CreateSender(withRequestLogging())
   367  	client.resourceGroupClient = rgc
   368  
   369  	pc := resources.NewProvidersClientWithBaseURI(endpoint, c.SubscriptionID)
   370  	setUserAgent(&pc.Client)
   371  	pc.Authorizer = spt
   372  	pc.Sender = autorest.CreateSender(withRequestLogging())
   373  	client.providers = pc
   374  
   375  	tc := resources.NewTagsClientWithBaseURI(endpoint, c.SubscriptionID)
   376  	setUserAgent(&tc.Client)
   377  	tc.Authorizer = spt
   378  	tc.Sender = autorest.CreateSender(withRequestLogging())
   379  	client.tagsClient = tc
   380  
   381  	rf := resources.NewGroupClientWithBaseURI(endpoint, c.SubscriptionID)
   382  	setUserAgent(&rf.Client)
   383  	rf.Authorizer = spt
   384  	rf.Sender = autorest.CreateSender(withRequestLogging())
   385  	client.resourceFindClient = rf
   386  
   387  	jc := scheduler.NewJobsClientWithBaseURI(endpoint, c.SubscriptionID)
   388  	setUserAgent(&jc.Client)
   389  	jc.Authorizer = spt
   390  	jc.Sender = autorest.CreateSender(withRequestLogging())
   391  	client.jobsClient = jc
   392  
   393  	jcc := scheduler.NewJobCollectionsClientWithBaseURI(endpoint, c.SubscriptionID)
   394  	setUserAgent(&jcc.Client)
   395  	jcc.Authorizer = spt
   396  	jcc.Sender = autorest.CreateSender(withRequestLogging())
   397  	client.jobsCollectionsClient = jcc
   398  
   399  	ssc := storage.NewAccountsClientWithBaseURI(endpoint, c.SubscriptionID)
   400  	setUserAgent(&ssc.Client)
   401  	ssc.Authorizer = spt
   402  	ssc.Sender = autorest.CreateSender(withRequestLogging())
   403  	client.storageServiceClient = ssc
   404  
   405  	suc := storage.NewUsageOperationsClientWithBaseURI(endpoint, c.SubscriptionID)
   406  	setUserAgent(&suc.Client)
   407  	suc.Authorizer = spt
   408  	suc.Sender = autorest.CreateSender(withRequestLogging())
   409  	client.storageUsageClient = suc
   410  
   411  	cpc := cdn.NewProfilesClientWithBaseURI(endpoint, c.SubscriptionID)
   412  	setUserAgent(&cpc.Client)
   413  	cpc.Authorizer = spt
   414  	cpc.Sender = autorest.CreateSender(withRequestLogging())
   415  	client.cdnProfilesClient = cpc
   416  
   417  	cec := cdn.NewEndpointsClientWithBaseURI(endpoint, c.SubscriptionID)
   418  	setUserAgent(&cec.Client)
   419  	cec.Authorizer = spt
   420  	cec.Sender = autorest.CreateSender(withRequestLogging())
   421  	client.cdnEndpointsClient = cec
   422  
   423  	dc := resources.NewDeploymentsClientWithBaseURI(endpoint, c.SubscriptionID)
   424  	setUserAgent(&dc.Client)
   425  	dc.Authorizer = spt
   426  	dc.Sender = autorest.CreateSender(withRequestLogging())
   427  	client.deploymentsClient = dc
   428  
   429  	tmpc := trafficmanager.NewProfilesClientWithBaseURI(endpoint, c.SubscriptionID)
   430  	setUserAgent(&tmpc.Client)
   431  	tmpc.Authorizer = spt
   432  	tmpc.Sender = autorest.CreateSender(withRequestLogging())
   433  	client.trafficManagerProfilesClient = tmpc
   434  
   435  	tmec := trafficmanager.NewEndpointsClientWithBaseURI(endpoint, c.SubscriptionID)
   436  	setUserAgent(&tmec.Client)
   437  	tmec.Authorizer = spt
   438  	tmec.Sender = autorest.CreateSender(withRequestLogging())
   439  	client.trafficManagerEndpointsClient = tmec
   440  
   441  	rdc := redis.NewGroupClientWithBaseURI(endpoint, c.SubscriptionID)
   442  	setUserAgent(&rdc.Client)
   443  	rdc.Authorizer = spt
   444  	rdc.Sender = autorest.CreateSender(withRequestLogging())
   445  	client.redisClient = rdc
   446  
   447  	sbnc := servicebus.NewNamespacesClientWithBaseURI(endpoint, c.SubscriptionID)
   448  	setUserAgent(&sbnc.Client)
   449  	sbnc.Authorizer = spt
   450  	sbnc.Sender = autorest.CreateSender(withRequestLogging())
   451  	client.serviceBusNamespacesClient = sbnc
   452  
   453  	sbtc := servicebus.NewTopicsClientWithBaseURI(endpoint, c.SubscriptionID)
   454  	setUserAgent(&sbtc.Client)
   455  	sbtc.Authorizer = spt
   456  	sbtc.Sender = autorest.CreateSender(withRequestLogging())
   457  	client.serviceBusTopicsClient = sbtc
   458  
   459  	sbsc := servicebus.NewSubscriptionsClientWithBaseURI(endpoint, c.SubscriptionID)
   460  	setUserAgent(&sbsc.Client)
   461  	sbsc.Authorizer = spt
   462  	sbsc.Sender = autorest.CreateSender(withRequestLogging())
   463  	client.serviceBusSubscriptionsClient = sbsc
   464  
   465  	kvc := keyvault.NewVaultsClientWithBaseURI(endpoint, c.SubscriptionID)
   466  	setUserAgent(&kvc.Client)
   467  	kvc.Authorizer = spt
   468  	kvc.Sender = autorest.CreateSender(withRequestLogging())
   469  	client.keyVaultClient = kvc
   470  
   471  	sqlepc := sql.NewElasticPoolsClientWithBaseURI(endpoint, c.SubscriptionID)
   472  	setUserAgent(&sqlepc.Client)
   473  	sqlepc.Authorizer = spt
   474  	sqlepc.Sender = autorest.CreateSender(withRequestLogging())
   475  	client.sqlElasticPoolsClient = sqlepc
   476  
   477  	return &client, nil
   478  }
   479  
   480  func (armClient *ArmClient) getKeyForStorageAccount(resourceGroupName, storageAccountName string) (string, bool, error) {
   481  	accountKeys, err := armClient.storageServiceClient.ListKeys(resourceGroupName, storageAccountName)
   482  	if accountKeys.StatusCode == http.StatusNotFound {
   483  		return "", false, nil
   484  	}
   485  	if err != nil {
   486  		// We assume this is a transient error rather than a 404 (which is caught above),  so assume the
   487  		// account still exists.
   488  		return "", true, fmt.Errorf("Error retrieving keys for storage account %q: %s", storageAccountName, err)
   489  	}
   490  
   491  	if accountKeys.Keys == nil {
   492  		return "", false, fmt.Errorf("Nil key returned for storage account %q", storageAccountName)
   493  	}
   494  
   495  	keys := *accountKeys.Keys
   496  	return *keys[0].Value, true, nil
   497  }
   498  
   499  func (armClient *ArmClient) getBlobStorageClientForStorageAccount(resourceGroupName, storageAccountName string) (*mainStorage.BlobStorageClient, bool, error) {
   500  	key, accountExists, err := armClient.getKeyForStorageAccount(resourceGroupName, storageAccountName)
   501  	if err != nil {
   502  		return nil, accountExists, err
   503  	}
   504  	if accountExists == false {
   505  		return nil, false, nil
   506  	}
   507  
   508  	storageClient, err := mainStorage.NewClient(storageAccountName, key, armClient.environment.StorageEndpointSuffix,
   509  		mainStorage.DefaultAPIVersion, true)
   510  	if err != nil {
   511  		return nil, true, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
   512  	}
   513  
   514  	blobClient := storageClient.GetBlobService()
   515  	return &blobClient, true, nil
   516  }
   517  
   518  func (armClient *ArmClient) getFileServiceClientForStorageAccount(resourceGroupName, storageAccountName string) (*mainStorage.FileServiceClient, bool, error) {
   519  	key, accountExists, err := armClient.getKeyForStorageAccount(resourceGroupName, storageAccountName)
   520  	if err != nil {
   521  		return nil, accountExists, err
   522  	}
   523  	if accountExists == false {
   524  		return nil, false, nil
   525  	}
   526  
   527  	storageClient, err := mainStorage.NewClient(storageAccountName, key, armClient.environment.StorageEndpointSuffix,
   528  		mainStorage.DefaultAPIVersion, true)
   529  	if err != nil {
   530  		return nil, true, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
   531  	}
   532  
   533  	fileClient := storageClient.GetFileService()
   534  	return &fileClient, true, nil
   535  }
   536  
   537  func (armClient *ArmClient) getTableServiceClientForStorageAccount(resourceGroupName, storageAccountName string) (*mainStorage.TableServiceClient, bool, error) {
   538  	key, accountExists, err := armClient.getKeyForStorageAccount(resourceGroupName, storageAccountName)
   539  	if err != nil {
   540  		return nil, accountExists, err
   541  	}
   542  	if accountExists == false {
   543  		return nil, false, nil
   544  	}
   545  
   546  	storageClient, err := mainStorage.NewClient(storageAccountName, key, armClient.environment.StorageEndpointSuffix,
   547  		mainStorage.DefaultAPIVersion, true)
   548  	if err != nil {
   549  		return nil, true, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
   550  	}
   551  
   552  	tableClient := storageClient.GetTableService()
   553  	return &tableClient, true, nil
   554  }
   555  
   556  func (armClient *ArmClient) getQueueServiceClientForStorageAccount(resourceGroupName, storageAccountName string) (*mainStorage.QueueServiceClient, bool, error) {
   557  	key, accountExists, err := armClient.getKeyForStorageAccount(resourceGroupName, storageAccountName)
   558  	if err != nil {
   559  		return nil, accountExists, err
   560  	}
   561  	if accountExists == false {
   562  		return nil, false, nil
   563  	}
   564  
   565  	storageClient, err := mainStorage.NewClient(storageAccountName, key, armClient.environment.StorageEndpointSuffix,
   566  		mainStorage.DefaultAPIVersion, true)
   567  	if err != nil {
   568  		return nil, true, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
   569  	}
   570  
   571  	queueClient := storageClient.GetQueueService()
   572  	return &queueClient, true, nil
   573  }