Skip to content

Instantly share code, notes, and snippets.

@devigned
Created March 27, 2017 23:40
Show Gist options
  • Save devigned/b894bd29e6e066926ecca01db2a0b4af to your computer and use it in GitHub Desktop.
Save devigned/b894bd29e6e066926ecca01db2a0b4af to your computer and use it in GitHub Desktop.
Domain name patch example
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