client.go

Documentation: github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2020-02-01/managementgroups

     1  // Deprecated: Please note, this package has been deprecated. A replacement package is available [github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managementgroups/armmanagementgroups](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/managementgroups/armmanagementgroups). We strongly encourage you to upgrade to continue receiving updates. See [Migration Guide](https://aka.ms/azsdk/golang/t2/migration) for guidance on upgrading. Refer to our [deprecation policy](https://azure.github.io/azure-sdk/policies_support.html) for more details.
     2  //
     3  // Package managementgroups implements the Azure ARM Managementgroups service API version 2020-02-01.
     4  //
     5  // The Azure Management Groups API enables consolidation of multiple
     6  // subscriptions/resources into an organizational hierarchy and centrally
     7  // manage access control, policies, alerting and reporting for those resources.
     8  //
     9  package managementgroups
    10  
    11  // Copyright (c) Microsoft Corporation. All rights reserved.
    12  // Licensed under the MIT License. See License.txt in the project root for license information.
    13  //
    14  // Code generated by Microsoft (R) AutoRest Code Generator.
    15  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
    16  
    17  import (
    18  	"context"
    19  	"github.com/Azure/go-autorest/autorest"
    20  	"github.com/Azure/go-autorest/autorest/azure"
    21  	"github.com/Azure/go-autorest/tracing"
    22  	"net/http"
    23  )
    24  
    25  const (
    26  	// DefaultBaseURI is the default URI used for the service Managementgroups
    27  	DefaultBaseURI = "https://management.azure.com"
    28  )
    29  
    30  // BaseClient is the base client for Managementgroups.
    31  type BaseClient struct {
    32  	autorest.Client
    33  	BaseURI string
    34  }
    35  
    36  // New creates an instance of the BaseClient client.
    37  func New() BaseClient {
    38  	return NewWithBaseURI(DefaultBaseURI)
    39  }
    40  
    41  // NewWithBaseURI creates an instance of the BaseClient client using a custom endpoint.  Use this when interacting with
    42  // an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    43  func NewWithBaseURI(baseURI string) BaseClient {
    44  	return BaseClient{
    45  		Client:  autorest.NewClientWithUserAgent(UserAgent()),
    46  		BaseURI: baseURI,
    47  	}
    48  }
    49  
    50  // CheckNameAvailability checks if the specified management group name is valid and unique
    51  // Parameters:
    52  // checkNameAvailabilityRequest - management group name availability check parameters.
    53  func (client BaseClient) CheckNameAvailability(ctx context.Context, checkNameAvailabilityRequest CheckNameAvailabilityRequest) (result CheckNameAvailabilityResult, err error) {
    54  	if tracing.IsEnabled() {
    55  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CheckNameAvailability")
    56  		defer func() {
    57  			sc := -1
    58  			if result.Response.Response != nil {
    59  				sc = result.Response.Response.StatusCode
    60  			}
    61  			tracing.EndSpan(ctx, sc, err)
    62  		}()
    63  	}
    64  	req, err := client.CheckNameAvailabilityPreparer(ctx, checkNameAvailabilityRequest)
    65  	if err != nil {
    66  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "CheckNameAvailability", nil, "Failure preparing request")
    67  		return
    68  	}
    69  
    70  	resp, err := client.CheckNameAvailabilitySender(req)
    71  	if err != nil {
    72  		result.Response = autorest.Response{Response: resp}
    73  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "CheckNameAvailability", resp, "Failure sending request")
    74  		return
    75  	}
    76  
    77  	result, err = client.CheckNameAvailabilityResponder(resp)
    78  	if err != nil {
    79  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "CheckNameAvailability", resp, "Failure responding to request")
    80  		return
    81  	}
    82  
    83  	return
    84  }
    85  
    86  // CheckNameAvailabilityPreparer prepares the CheckNameAvailability request.
    87  func (client BaseClient) CheckNameAvailabilityPreparer(ctx context.Context, checkNameAvailabilityRequest CheckNameAvailabilityRequest) (*http.Request, error) {
    88  	const APIVersion = "2020-02-01"
    89  	queryParameters := map[string]interface{}{
    90  		"api-version": APIVersion,
    91  	}
    92  
    93  	preparer := autorest.CreatePreparer(
    94  		autorest.AsContentType("application/json; charset=utf-8"),
    95  		autorest.AsPost(),
    96  		autorest.WithBaseURL(client.BaseURI),
    97  		autorest.WithPath("/providers/Microsoft.Management/checkNameAvailability"),
    98  		autorest.WithJSON(checkNameAvailabilityRequest),
    99  		autorest.WithQueryParameters(queryParameters))
   100  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   101  }
   102  
   103  // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the
   104  // http.Response Body if it receives an error.
   105  func (client BaseClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) {
   106  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   107  }
   108  
   109  // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always
   110  // closes the http.Response Body.
   111  func (client BaseClient) CheckNameAvailabilityResponder(resp *http.Response) (result CheckNameAvailabilityResult, err error) {
   112  	err = autorest.Respond(
   113  		resp,
   114  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   115  		autorest.ByUnmarshallingJSON(&result),
   116  		autorest.ByClosing())
   117  	result.Response = autorest.Response{Response: resp}
   118  	return
   119  }
   120  
   121  // StartTenantBackfill starts backfilling subscriptions for the Tenant.
   122  func (client BaseClient) StartTenantBackfill(ctx context.Context) (result TenantBackfillStatusResult, err error) {
   123  	if tracing.IsEnabled() {
   124  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.StartTenantBackfill")
   125  		defer func() {
   126  			sc := -1
   127  			if result.Response.Response != nil {
   128  				sc = result.Response.Response.StatusCode
   129  			}
   130  			tracing.EndSpan(ctx, sc, err)
   131  		}()
   132  	}
   133  	req, err := client.StartTenantBackfillPreparer(ctx)
   134  	if err != nil {
   135  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "StartTenantBackfill", nil, "Failure preparing request")
   136  		return
   137  	}
   138  
   139  	resp, err := client.StartTenantBackfillSender(req)
   140  	if err != nil {
   141  		result.Response = autorest.Response{Response: resp}
   142  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "StartTenantBackfill", resp, "Failure sending request")
   143  		return
   144  	}
   145  
   146  	result, err = client.StartTenantBackfillResponder(resp)
   147  	if err != nil {
   148  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "StartTenantBackfill", resp, "Failure responding to request")
   149  		return
   150  	}
   151  
   152  	return
   153  }
   154  
   155  // StartTenantBackfillPreparer prepares the StartTenantBackfill request.
   156  func (client BaseClient) StartTenantBackfillPreparer(ctx context.Context) (*http.Request, error) {
   157  	const APIVersion = "2020-02-01"
   158  	queryParameters := map[string]interface{}{
   159  		"api-version": APIVersion,
   160  	}
   161  
   162  	preparer := autorest.CreatePreparer(
   163  		autorest.AsPost(),
   164  		autorest.WithBaseURL(client.BaseURI),
   165  		autorest.WithPath("/providers/Microsoft.Management/startTenantBackfill"),
   166  		autorest.WithQueryParameters(queryParameters))
   167  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   168  }
   169  
   170  // StartTenantBackfillSender sends the StartTenantBackfill request. The method will close the
   171  // http.Response Body if it receives an error.
   172  func (client BaseClient) StartTenantBackfillSender(req *http.Request) (*http.Response, error) {
   173  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   174  }
   175  
   176  // StartTenantBackfillResponder handles the response to the StartTenantBackfill request. The method always
   177  // closes the http.Response Body.
   178  func (client BaseClient) StartTenantBackfillResponder(resp *http.Response) (result TenantBackfillStatusResult, err error) {
   179  	err = autorest.Respond(
   180  		resp,
   181  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   182  		autorest.ByUnmarshallingJSON(&result),
   183  		autorest.ByClosing())
   184  	result.Response = autorest.Response{Response: resp}
   185  	return
   186  }
   187  
   188  // TenantBackfillStatus gets tenant backfill status
   189  func (client BaseClient) TenantBackfillStatus(ctx context.Context) (result TenantBackfillStatusResult, err error) {
   190  	if tracing.IsEnabled() {
   191  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.TenantBackfillStatus")
   192  		defer func() {
   193  			sc := -1
   194  			if result.Response.Response != nil {
   195  				sc = result.Response.Response.StatusCode
   196  			}
   197  			tracing.EndSpan(ctx, sc, err)
   198  		}()
   199  	}
   200  	req, err := client.TenantBackfillStatusPreparer(ctx)
   201  	if err != nil {
   202  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "TenantBackfillStatus", nil, "Failure preparing request")
   203  		return
   204  	}
   205  
   206  	resp, err := client.TenantBackfillStatusSender(req)
   207  	if err != nil {
   208  		result.Response = autorest.Response{Response: resp}
   209  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "TenantBackfillStatus", resp, "Failure sending request")
   210  		return
   211  	}
   212  
   213  	result, err = client.TenantBackfillStatusResponder(resp)
   214  	if err != nil {
   215  		err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "TenantBackfillStatus", resp, "Failure responding to request")
   216  		return
   217  	}
   218  
   219  	return
   220  }
   221  
   222  // TenantBackfillStatusPreparer prepares the TenantBackfillStatus request.
   223  func (client BaseClient) TenantBackfillStatusPreparer(ctx context.Context) (*http.Request, error) {
   224  	const APIVersion = "2020-02-01"
   225  	queryParameters := map[string]interface{}{
   226  		"api-version": APIVersion,
   227  	}
   228  
   229  	preparer := autorest.CreatePreparer(
   230  		autorest.AsPost(),
   231  		autorest.WithBaseURL(client.BaseURI),
   232  		autorest.WithPath("/providers/Microsoft.Management/tenantBackfillStatus"),
   233  		autorest.WithQueryParameters(queryParameters))
   234  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   235  }
   236  
   237  // TenantBackfillStatusSender sends the TenantBackfillStatus request. The method will close the
   238  // http.Response Body if it receives an error.
   239  func (client BaseClient) TenantBackfillStatusSender(req *http.Request) (*http.Response, error) {
   240  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   241  }
   242  
   243  // TenantBackfillStatusResponder handles the response to the TenantBackfillStatus request. The method always
   244  // closes the http.Response Body.
   245  func (client BaseClient) TenantBackfillStatusResponder(resp *http.Response) (result TenantBackfillStatusResult, err error) {
   246  	err = autorest.Respond(
   247  		resp,
   248  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   249  		autorest.ByUnmarshallingJSON(&result),
   250  		autorest.ByClosing())
   251  	result.Response = autorest.Response{Response: resp}
   252  	return
   253  }
   254
View as plain text