Created
March 27, 2017 23:40
-
-
Save devigned/b894bd29e6e066926ecca01db2a0b4af to your computer and use it in GitHub Desktop.
Domain name patch example
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package main | |
import ( | |
"fmt" | |
"io" | |
"net/http" | |
"os" | |
"sync" | |
"github.com/Azure/azure-sdk-for-go/arm/graphrbac" | |
"github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions" | |
"github.com/Azure/go-autorest/autorest" | |
"github.com/Azure/go-autorest/autorest/azure" | |
) | |
const ( | |
clientID = "04b07795-8ddb-461a-bbee-02f9e1bf7b46" // This is the client ID for the Azure CLI. It was chosen for its public well-known status. | |
// APIVersion is the version of the Graphrbac | |
APIVersion = "1.6" | |
// DefaultBaseURI is the default URI used for the service Graphrbac | |
DefaultBaseURI = "https://graph.windows.net" | |
) | |
// These globals configure the sample's execution environment. | |
// They should never be written to throughout the rest of the sample. | |
var ( | |
environment = azure.PublicCloud | |
commonTokenID = environment.ActiveDirectoryEndpoint + "/common" | |
endpoint = environment.ResourceManagerEndpoint | |
graphEndpoint = environment.GraphEndpoint | |
) | |
// Clients expose REST functionality. | |
var ( | |
autorestClient = autorest.NewClientWithUserAgent("authExample") | |
subscriptionClient = subscriptions.NewClient() | |
tenantClient = subscriptions.NewTenantsClient() | |
) | |
func main() { | |
var oAuthConfig *azure.OAuthConfig | |
var err error | |
oAuthConfig, err = environment.OAuthConfigForTenant(commonTokenID) | |
if err != nil { | |
panic(err) | |
} | |
var authToken *azure.Token | |
if authToken, err = authenticateUser(oAuthConfig, os.Stdout); err != nil { | |
panic(err) | |
} | |
spt, err := azure.NewServicePrincipalTokenFromManualToken(*oAuthConfig, clientID, endpoint, *authToken) | |
tenantClient.Authorizer = spt | |
err = processTenants(tenantClient, func(t subscriptions.TenantIDDescription) error { | |
fmt.Printf("Tenant ID: %s\n", *t.TenantID) | |
tenantOAuthConfig, err := azure.PublicCloud.OAuthConfigForTenant(*t.TenantID) | |
if err != nil { | |
return err | |
} | |
tenantToken, err := azure.NewServicePrincipalTokenFromManualToken(*tenantOAuthConfig, clientID, endpoint, *authToken) | |
if err != nil { | |
return err | |
} | |
graphClient := NewObjectsClient(*t.TenantID) | |
graphSpt, err := azure.NewServicePrincipalTokenFromManualToken(*oAuthConfig, clientID, graphEndpoint, *authToken) | |
graphClient.Authorizer = graphSpt | |
if err = graphSpt.Refresh(); err != nil { | |
return err | |
} | |
result, _ := graphClient.GetDomain() | |
fmt.Println("Tenant Name: ", (*result.Value)[0].Name) | |
subscriptionClient.Authorizer = tenantToken | |
if err = tenantToken.Refresh(); err != nil { | |
return err | |
} | |
err = processSubscriptions(subscriptionClient, func(s subscriptions.Subscription) error { | |
_, err := fmt.Printf("\t%s\n", *s.SubscriptionID) | |
return err | |
}) | |
return err | |
}) | |
if err != nil { | |
return | |
} | |
fmt.Println("Done.") | |
} | |
func authenticateUser(oAuthConfig *azure.OAuthConfig, output io.Writer) (*azure.Token, error) { | |
var err error | |
var deviceCode *azure.DeviceCode | |
if deviceCode, err = azure.InitiateDeviceAuth(&autorestClient, *oAuthConfig, clientID, endpoint); err != nil { | |
return nil, err | |
} | |
_, err = fmt.Fprintln(output, *deviceCode.Message) | |
if err != nil { | |
return nil, err | |
} | |
token, err := azure.WaitForUserCompletion(&autorestClient, deviceCode) | |
if err != nil { | |
return nil, err | |
} | |
return token, nil | |
} | |
func processTenants(client subscriptions.TenantsClient, action func(subscriptions.TenantIDDescription) error) error { | |
var result subscriptions.TenantListResult | |
getNext := client.List | |
var getNextUpdater sync.Once | |
for { | |
var err error | |
result, err = getNext() | |
if err != nil { | |
return err | |
} else if result.Value == nil { | |
return nil | |
} | |
for _, tenant := range *result.Value { | |
if err := action(tenant); err != nil { | |
return err | |
} | |
} | |
if result.NextLink == nil { | |
break | |
} | |
getNextUpdater.Do(func() { | |
getNext = func() (subscriptions.TenantListResult, error) { | |
return client.ListNextResults(result) | |
} | |
}) | |
} | |
return nil | |
} | |
func processSubscriptions(client subscriptions.Client, action func(subscriptions.Subscription) error) error { | |
var result subscriptions.SubscriptionListResult | |
getNext := client.List | |
var getNextUpdater sync.Once | |
for { | |
var err error | |
result, err = getNext() | |
if err != nil { | |
return err | |
} else if result.Value == nil { | |
return nil | |
} | |
for _, subscription := range *result.Value { | |
action(subscription) | |
} | |
if result.NextLink == nil { | |
break | |
} | |
getNextUpdater.Do(func() { | |
getNext = func() (subscriptions.SubscriptionListResult, error) { | |
return client.ListNextResults(result) | |
} | |
}) | |
} | |
return nil | |
} | |
// DomainResponse is the List Disks operation response. | |
type DomainResponse struct { | |
autorest.Response `json:"-"` | |
Value *[]Domain `json:"value,omitempty"` | |
NextLink *string `json:"nextLink,omitempty"` | |
} | |
type Domain struct { | |
Name string `json:"name,omitempty"` | |
} | |
// ObjectsClient is the the Graph RBAC Management Client | |
type MyObjectsClient struct { | |
graphrbac.ManagementClient | |
} | |
// NewObjectsClient creates an instance of the ObjectsClient client. | |
func NewObjectsClient(tenantID string) MyObjectsClient { | |
return MyObjectsClient(graphrbac.NewObjectsClientWithBaseURI(DefaultBaseURI, tenantID)) | |
} | |
func NewObjectsClientWithBaseURI(baseURI string, tenantID string) MyObjectsClient { | |
return MyObjectsClient{graphrbac.NewWithBaseURI(baseURI, tenantID)} | |
} | |
func (client MyObjectsClient) GetDomain() (result DomainResponse, err error) { | |
req, err := client.GetDomainPreparer() | |
if err != nil { | |
return result, autorest.NewErrorWithError(err, "graphrbac.ObjectsClient", "GetDomain", nil, "Failure preparing request") | |
} | |
resp, err := client.GetDomainSender(req) | |
if err != nil { | |
result.Response = autorest.Response{Response: resp} | |
return result, autorest.NewErrorWithError(err, "graphrbac.ObjectsClient", "GetDomain", resp, "Failure sending request") | |
} | |
result, err = client.GetDomainResponder(resp) | |
if err != nil { | |
err = autorest.NewErrorWithError(err, "graphrbac.ObjectsClient", "GetDomain", resp, "Failure responding to request") | |
} | |
return | |
} | |
func (client MyObjectsClient) GetDomainPreparer() (*http.Request, error) { | |
pathParameters := map[string]interface{}{ | |
"tenantID": autorest.Encode("path", client.TenantID), | |
} | |
queryParameters := map[string]interface{}{ | |
"api-version": client.APIVersion, | |
} | |
preparer := autorest.CreatePreparer( | |
autorest.AsGet(), | |
autorest.WithBaseURL(client.BaseURI), | |
autorest.WithPathParameters("/{tenantID}/domains", pathParameters), | |
autorest.WithQueryParameters(queryParameters)) | |
return preparer.Prepare(&http.Request{}) | |
} | |
// GetDomainSender fasfas | |
func (client MyObjectsClient) GetDomainSender(req *http.Request) (*http.Response, error) { | |
return autorest.SendWithSender(client, req) | |
} | |
// GetDomainResponder fasdf | |
func (client MyObjectsClient) GetDomainResponder(resp *http.Response) (result DomainResponse, err error) { | |
err = autorest.Respond( | |
resp, | |
client.ByInspecting(), | |
azure.WithErrorUnlessStatusCode(http.StatusOK), | |
autorest.ByUnmarshallingJSON(&result), | |
autorest.ByClosing()) | |
return | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment