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