// Refresh obtains a fresh token for the Service Principal. func (spt *ServicePrincipalToken) Refresh() error { p := map[string]interface{}{ "tenantID": spt.tenantID, "requestType": "token", } v := url.Values{} v.Set("client_id", spt.clientID) v.Set("grant_type", "client_credentials") v.Set("resource", spt.resource) err := spt.secret.SetAuthenticationValues(spt, &v) if err != nil { return err } req, err := autorest.Prepare(&http.Request{}, autorest.AsPost(), autorest.AsFormURLEncoded(), autorest.WithBaseURL(oauthURL), autorest.WithPathParameters(p), autorest.WithFormData(v)) if err != nil { return err } resp, err := autorest.SendWithSender(spt.sender, req) if err != nil { return autorest.NewErrorWithError(err, "azure.ServicePrincipalToken", "Refresh", resp.StatusCode, "Failure sending request for Service Principal %s", spt.clientID) } var newToken Token err = autorest.Respond(resp, autorest.WithErrorUnlessOK(), autorest.ByUnmarshallingJSON(&newToken), autorest.ByClosing()) if err != nil { return autorest.NewErrorWithError(err, "azure.ServicePrincipalToken", "Refresh", resp.StatusCode, "Failure handling response to Service Principal %s request", spt.clientID) } spt.Token = newToken return nil }
// Update updates the account type or tags for a storage account. It can also // be used to add a custom domain (note that custom domains cannot be added // via the Create operation). Only one custom domain is supported per storage // account. In order to replace a custom domain, the old value must be // cleared before a new value may be set. To clear a custom domain, simply // update the custom domain with empty string. Then call update again with // the new cutsom domain name. The update API can only be used to update one // of tags, accountType, or customDomain per call. To update multiple of // these properties, call the API multiple times with one change per call. // This call does not change the storage keys for the account. If you want to // change storage account keys, use the RegenerateKey operation. The location // and name of the storage account cannot be changed after creation. // // resourceGroupName is the name of the resource group within the user's // subscription. accountName is the name of the storage account within the // specified resource group. Storage account names must be between 3 and 24 // characters in length and use numbers and lower-case letters only. // parameters is the parameters to update on the account. Note that only one // property can be changed at a time using this API. func (client AccountsClient) Update(resourceGroupName string, accountName string, parameters AccountUpdateParameters) (result Account, ae error) { req, err := client.UpdatePreparer(resourceGroupName, accountName, parameters) if err != nil { return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "Update", autorest.UndefinedStatusCode, "Failure preparing request") } resp, err := client.UpdateSender(req) if err != nil { result.Response = autorest.Response{Response: resp} return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "Update", resp.StatusCode, "Failure sending request") } result, err = client.UpdateResponder(resp) if err != nil { ae = autorest.NewErrorWithError(err, "storage/AccountsClient", "Update", resp.StatusCode, "Failure responding to request") } return }
// RegenerateKey regenerates the access keys for the specified storage account. // // resourceGroupName is the name of the resource group within the user's // subscription. accountName is the name of the storage account within the // specified resource group. Storage account names must be between 3 and 24 // characters in length and use numbers and lower-case letters only. // regenerateKey is specifies name of the key which should be regenerated. // key1 or key2 for the default keys func (client AccountsClient) RegenerateKey(resourceGroupName string, accountName string, regenerateKey AccountRegenerateKeyParameters) (result AccountKeys, ae error) { req, err := client.RegenerateKeyPreparer(resourceGroupName, accountName, regenerateKey) if err != nil { return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "RegenerateKey", autorest.UndefinedStatusCode, "Failure preparing request") } resp, err := client.RegenerateKeySender(req) if err != nil { result.Response = autorest.Response{Response: resp} return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "RegenerateKey", resp.StatusCode, "Failure sending request") } result, err = client.RegenerateKeyResponder(resp) if err != nil { ae = autorest.NewErrorWithError(err, "storage/AccountsClient", "RegenerateKey", resp.StatusCode, "Failure responding to request") } return }
// CheckNameAvailability checks that account name is valid and is not in use. // // accountName is the name of the storage account within the specified // resource group. Storage account names must be between 3 and 24 characters // in length and use numbers and lower-case letters only. func (client AccountsClient) CheckNameAvailability(accountName AccountCheckNameAvailabilityParameters) (result CheckNameAvailabilityResult, ae error) { req, err := client.CheckNameAvailabilityPreparer(accountName) if err != nil { return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "CheckNameAvailability", autorest.UndefinedStatusCode, "Failure preparing request") } resp, err := client.CheckNameAvailabilitySender(req) if err != nil { result.Response = autorest.Response{Response: resp} return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "CheckNameAvailability", resp.StatusCode, "Failure sending request") } result, err = client.CheckNameAvailabilityResponder(resp) if err != nil { ae = autorest.NewErrorWithError(err, "storage/AccountsClient", "CheckNameAvailability", resp.StatusCode, "Failure responding to request") } return }
// ListKeys lists the access keys for the specified storage account. // // resourceGroupName is the name of the resource group. accountName is the // name of the storage account. func (client AccountsClient) ListKeys(resourceGroupName string, accountName string) (result AccountKeys, ae error) { req, err := client.ListKeysPreparer(resourceGroupName, accountName) if err != nil { return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "ListKeys", autorest.UndefinedStatusCode, "Failure preparing request") } resp, err := client.ListKeysSender(req) if err != nil { result.Response = autorest.Response{Response: resp} return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "ListKeys", resp.StatusCode, "Failure sending request") } result, err = client.ListKeysResponder(resp) if err != nil { ae = autorest.NewErrorWithError(err, "storage/AccountsClient", "ListKeys", resp.StatusCode, "Failure responding to request") } return }
// List lists all the storage accounts available under the subscription. Note // that storage keys are not returned; use the ListKeys operation for this. func (client AccountsClient) List() (result AccountListResult, ae error) { req, err := client.ListPreparer() if err != nil { return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "List", autorest.UndefinedStatusCode, "Failure preparing request") } resp, err := client.ListSender(req) if err != nil { result.Response = autorest.Response{Response: resp} return result, autorest.NewErrorWithError(err, "storage/AccountsClient", "List", resp.StatusCode, "Failure sending request") } result, err = client.ListResponder(resp) if err != nil { ae = autorest.NewErrorWithError(err, "storage/AccountsClient", "List", resp.StatusCode, "Failure responding to request") } return }
// WithAuthorization returns a PrepareDecorator that adds an HTTP Authorization header whose // value is "Bearer " followed by the AccessToken of the ServicePrincipalToken. // // By default, the token will automatically refresh if nearly expired (as determined by the // RefreshWithin interval). Use the AutoRefresh method to enable or disable automatically refreshing // tokens. func (spt *ServicePrincipalToken) WithAuthorization() autorest.PrepareDecorator { return func(p autorest.Preparer) autorest.Preparer { return autorest.PreparerFunc(func(r *http.Request) (*http.Request, error) { if spt.autoRefresh { err := spt.EnsureFresh() if err != nil { return r, autorest.NewErrorWithError(err, "azure.ServicePrincipalToken", "WithAuthorization", autorest.UndefinedStatusCode, "Failed to refresh Service Principal Token for request to %s", r.URL) } } return (autorest.WithBearerAuthorization(spt.AccessToken)(p)).Prepare(r) }) } }