func createStorageAccount(
group resources.ResourceGroup,
arm arm.Client) error {
ac := arm.StorageAccounts()
cna, err := ac.CheckNameAvailability(
storage.AccountCheckNameAvailabilityParameters{
Name: group.Name,
Type: to.StringPtr("Microsoft.Storage/storageAccounts")})
if err != nil {
return err
}
if to.Bool(cna.NameAvailable) {
name := *group.Name
props := storage.AccountPropertiesCreateParameters{AccountType: storage.StandardLRS}
_, err = ac.Create(name, name,
storage.AccountCreateParameters{
Location: group.Location,
Properties: &props,
})
if err != nil {
return fmt.Errorf("Failed to create storage account '%s' in location '%s': '%s'\n", name, *group.Location, err.Error())
}
}
return nil
}
func checkName(name string) {
c, err := helpers.LoadCredentials()
if err != nil {
log.Fatalf("Error: %v", err)
}
ac := storage.NewAccountsClient(c["subscriptionID"])
spt, err := helpers.NewServicePrincipalTokenFromCredentials(c, azure.AzureResourceManagerScope)
if err != nil {
log.Fatalf("Error: %v", err)
}
ac.Authorizer = spt
ac.Sender = autorest.CreateSender(
autorest.WithLogging(log.New(os.Stdout, "sdk-example: ", log.LstdFlags)))
ac.RequestInspector = withInspection()
ac.ResponseInspector = byInspecting()
cna, err := ac.CheckNameAvailability(
storage.AccountCheckNameAvailabilityParameters{
Name: to.StringPtr(name),
Type: to.StringPtr("Microsoft.Storage/storageAccounts")})
if err != nil {
log.Fatalf("Error: %v", err)
} else {
if to.Bool(cna.NameAvailable) {
fmt.Printf("The name '%s' is available\n", name)
} else {
fmt.Printf("The name '%s' is unavailable because %s\n", name, to.String(cna.Message))
}
}
}
func createAccount(resourceGroup, name string) {
c, err := helpers.LoadCredentials()
if err != nil {
log.Fatalf("Error: %v", err)
}
ac := storage.NewAccountsClient(c["subscriptionID"])
spt, err := helpers.NewServicePrincipalTokenFromCredentials(c, azure.AzureResourceManagerScope)
if err != nil {
log.Fatalf("Error: %v", err)
}
ac.Authorizer = spt
cna, err := ac.CheckNameAvailability(
storage.AccountCheckNameAvailabilityParameters{
Name: to.StringPtr(name),
Type: to.StringPtr("Microsoft.Storage/storageAccounts")})
if err != nil {
log.Fatalf("Error: %v", err)
return
}
if !to.Bool(cna.NameAvailable) {
fmt.Printf("%s is unavailable -- try again\n", name)
return
}
fmt.Printf("%s is available\n\n", name)
ac.Sender = autorest.CreateSender(withWatcher())
ac.PollingMode = autorest.PollUntilAttempts
ac.PollingAttempts = 5
cp := storage.AccountCreateParameters{}
cp.Location = to.StringPtr("westus")
cp.Properties = &storage.AccountPropertiesCreateParameters{AccountType: storage.StandardLRS}
sa, err := ac.Create(resourceGroup, name, cp)
if err != nil {
if sa.Response.StatusCode != http.StatusAccepted {
fmt.Printf("Creation of %s.%s failed with err -- %v\n", resourceGroup, name, err)
return
}
fmt.Printf("Create initiated for %s.%s -- poll %s to check status\n",
resourceGroup,
name,
sa.GetPollingLocation())
return
}
fmt.Printf("Successfully created %s.%s\n\n", resourceGroup, name)
ac.Sender = nil
r, err := ac.Delete(resourceGroup, name)
if err != nil {
fmt.Printf("Delete of %s.%s failed with status %s\n...%v\n", resourceGroup, name, r.Status, err)
return
}
fmt.Printf("Deletion of %s.%s succeeded -- %s\n", resourceGroup, name, r.Status)
}
func createStorageAccount(
client storage.AccountsClient,
accountType storage.AccountType,
resourceGroup string,
location string,
tags map[string]string,
accountNameGenerator func() string,
) (string, string, error) {
logger.Debugf("creating storage account (finding available name)")
const maxAttempts = 10
for remaining := maxAttempts; remaining > 0; remaining-- {
accountName := accountNameGenerator()
logger.Debugf("- checking storage account name %q", accountName)
result, err := client.CheckNameAvailability(
storage.AccountCheckNameAvailabilityParameters{
Name: to.StringPtr(accountName),
// Azure is a little inconsistent with when Type is
// required. It's required here.
Type: to.StringPtr("Microsoft.Storage/storageAccounts"),
},
)
if err != nil {
return "", "", errors.Annotate(err, "checking account name availability")
}
if !to.Bool(result.NameAvailable) {
logger.Debugf(
"%q is not available (%v): %v",
accountName, result.Reason, result.Message,
)
continue
}
createParams := storage.AccountCreateParameters{
Location: to.StringPtr(location),
Tags: toTagsPtr(tags),
Properties: &storage.AccountPropertiesCreateParameters{
AccountType: accountType,
},
}
logger.Debugf("- creating %q storage account %q", accountType, accountName)
// TODO(axw) account creation can fail if the account name is
// available, but contains profanity. We should retry a set
// number of times even if creating fails.
if _, err := client.Create(resourceGroup, accountName, createParams); err != nil {
return "", "", errors.Trace(err)
}
logger.Debugf("- listing storage account keys")
listKeysResult, err := client.ListKeys(resourceGroup, accountName)
if err != nil {
return "", "", errors.Annotate(err, "listing storage account keys")
}
return accountName, to.String(listKeysResult.Key1), nil
}
return "", "", errors.New("could not find available storage account name")
}
func main() {
name := "storage-account-name"
c, err := helpers.LoadCredentials()
if err != nil {
log.Fatalf("Error: %v", err)
}
sid := c["subscriptionID"]
tid := c["tenantID"]
cid := c["clientID"]
secret := c["clientSecret"]
spt, err := azure.NewServicePrincipalToken(cid, secret, tid, azure.AzureResourceManagerScope)
if err != nil {
log.Fatalf("Error: %v", err)
}
arm := arm.NewClient(sid, spt)
arm.RequestInspector = helpers.WithInspection()
arm.ResponseInspector = helpers.ByInspecting()
ac := arm.StorageAccounts()
cna, err := ac.CheckNameAvailability(
storage.AccountCheckNameAvailabilityParameters{
Name: to.StringPtr(name),
Type: to.StringPtr("Microsoft.Storage/storageAccounts")})
if err != nil {
log.Fatalf("Error: %v", err)
} else {
if to.Bool(cna.NameAvailable) {
fmt.Printf("The name '%s' is available\n", name)
} else {
fmt.Printf("The name '%s' is unavailable because %s\n", name, to.String(cna.Message))
}
}
}