1package containerregistry 2 3// Copyright (c) Microsoft and contributors. All rights reserved. 4// 5// Licensed under the Apache License, Version 2.0 (the "License"); 6// you may not use this file except in compliance with the License. 7// You may obtain a copy of the License at 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// 14// See the License for the specific language governing permissions and 15// limitations under the License. 16// 17// Code generated by Microsoft (R) AutoRest Code Generator. 18// Changes may cause incorrect behavior and will be lost if the code is regenerated. 19 20import ( 21 "context" 22 "github.com/Azure/go-autorest/autorest" 23 "github.com/Azure/go-autorest/autorest/azure" 24 "github.com/Azure/go-autorest/autorest/validation" 25 "github.com/Azure/go-autorest/tracing" 26 "net/http" 27) 28 29// RegistriesClient is the client for the Registries methods of the Containerregistry service. 30type RegistriesClient struct { 31 BaseClient 32} 33 34// NewRegistriesClient creates an instance of the RegistriesClient client. 35func NewRegistriesClient(subscriptionID string) RegistriesClient { 36 return NewRegistriesClientWithBaseURI(DefaultBaseURI, subscriptionID) 37} 38 39// NewRegistriesClientWithBaseURI creates an instance of the RegistriesClient client using a custom endpoint. Use this 40// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 41func NewRegistriesClientWithBaseURI(baseURI string, subscriptionID string) RegistriesClient { 42 return RegistriesClient{NewWithBaseURI(baseURI, subscriptionID)} 43} 44 45// CheckNameAvailability checks whether the container registry name is available for use. The name must contain only 46// alphanumeric characters, be globally unique, and between 5 and 50 characters in length. 47// Parameters: 48// registryNameCheckRequest - the object containing information for the availability request. 49func (client RegistriesClient) CheckNameAvailability(ctx context.Context, registryNameCheckRequest RegistryNameCheckRequest) (result RegistryNameStatus, err error) { 50 if tracing.IsEnabled() { 51 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.CheckNameAvailability") 52 defer func() { 53 sc := -1 54 if result.Response.Response != nil { 55 sc = result.Response.Response.StatusCode 56 } 57 tracing.EndSpan(ctx, sc, err) 58 }() 59 } 60 if err := validation.Validate([]validation.Validation{ 61 {TargetValue: registryNameCheckRequest, 62 Constraints: []validation.Constraint{{Target: "registryNameCheckRequest.Name", Name: validation.Null, Rule: true, 63 Chain: []validation.Constraint{{Target: "registryNameCheckRequest.Name", Name: validation.MaxLength, Rule: 50, Chain: nil}, 64 {Target: "registryNameCheckRequest.Name", Name: validation.MinLength, Rule: 5, Chain: nil}, 65 {Target: "registryNameCheckRequest.Name", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}, 66 }}, 67 {Target: "registryNameCheckRequest.Type", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 68 return result, validation.NewError("containerregistry.RegistriesClient", "CheckNameAvailability", err.Error()) 69 } 70 71 req, err := client.CheckNameAvailabilityPreparer(ctx, registryNameCheckRequest) 72 if err != nil { 73 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "CheckNameAvailability", nil, "Failure preparing request") 74 return 75 } 76 77 resp, err := client.CheckNameAvailabilitySender(req) 78 if err != nil { 79 result.Response = autorest.Response{Response: resp} 80 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "CheckNameAvailability", resp, "Failure sending request") 81 return 82 } 83 84 result, err = client.CheckNameAvailabilityResponder(resp) 85 if err != nil { 86 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "CheckNameAvailability", resp, "Failure responding to request") 87 return 88 } 89 90 return 91} 92 93// CheckNameAvailabilityPreparer prepares the CheckNameAvailability request. 94func (client RegistriesClient) CheckNameAvailabilityPreparer(ctx context.Context, registryNameCheckRequest RegistryNameCheckRequest) (*http.Request, error) { 95 pathParameters := map[string]interface{}{ 96 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 97 } 98 99 const APIVersion = "2020-11-01-preview" 100 queryParameters := map[string]interface{}{ 101 "api-version": APIVersion, 102 } 103 104 preparer := autorest.CreatePreparer( 105 autorest.AsContentType("application/json; charset=utf-8"), 106 autorest.AsPost(), 107 autorest.WithBaseURL(client.BaseURI), 108 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.ContainerRegistry/checkNameAvailability", pathParameters), 109 autorest.WithJSON(registryNameCheckRequest), 110 autorest.WithQueryParameters(queryParameters)) 111 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 112} 113 114// CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the 115// http.Response Body if it receives an error. 116func (client RegistriesClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { 117 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 118} 119 120// CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always 121// closes the http.Response Body. 122func (client RegistriesClient) CheckNameAvailabilityResponder(resp *http.Response) (result RegistryNameStatus, err error) { 123 err = autorest.Respond( 124 resp, 125 azure.WithErrorUnlessStatusCode(http.StatusOK), 126 autorest.ByUnmarshallingJSON(&result), 127 autorest.ByClosing()) 128 result.Response = autorest.Response{Response: resp} 129 return 130} 131 132// Create creates a container registry with the specified parameters. 133// Parameters: 134// resourceGroupName - the name of the resource group to which the container registry belongs. 135// registryName - the name of the container registry. 136// registry - the parameters for creating a container registry. 137func (client RegistriesClient) Create(ctx context.Context, resourceGroupName string, registryName string, registry Registry) (result RegistriesCreateFuture, err error) { 138 if tracing.IsEnabled() { 139 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.Create") 140 defer func() { 141 sc := -1 142 if result.Response() != nil { 143 sc = result.Response().StatusCode 144 } 145 tracing.EndSpan(ctx, sc, err) 146 }() 147 } 148 if err := validation.Validate([]validation.Validation{ 149 {TargetValue: resourceGroupName, 150 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 151 {TargetValue: registryName, 152 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 153 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 154 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}, 155 {TargetValue: registry, 156 Constraints: []validation.Constraint{{Target: "registry.Sku", Name: validation.Null, Rule: true, Chain: nil}, 157 {Target: "registry.RegistryProperties", Name: validation.Null, Rule: false, 158 Chain: []validation.Constraint{{Target: "registry.RegistryProperties.StorageAccount", Name: validation.Null, Rule: false, 159 Chain: []validation.Constraint{{Target: "registry.RegistryProperties.StorageAccount.ID", Name: validation.Null, Rule: true, Chain: nil}}}, 160 }}}}}); err != nil { 161 return result, validation.NewError("containerregistry.RegistriesClient", "Create", err.Error()) 162 } 163 164 req, err := client.CreatePreparer(ctx, resourceGroupName, registryName, registry) 165 if err != nil { 166 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Create", nil, "Failure preparing request") 167 return 168 } 169 170 result, err = client.CreateSender(req) 171 if err != nil { 172 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Create", nil, "Failure sending request") 173 return 174 } 175 176 return 177} 178 179// CreatePreparer prepares the Create request. 180func (client RegistriesClient) CreatePreparer(ctx context.Context, resourceGroupName string, registryName string, registry Registry) (*http.Request, error) { 181 pathParameters := map[string]interface{}{ 182 "registryName": autorest.Encode("path", registryName), 183 "resourceGroupName": autorest.Encode("path", resourceGroupName), 184 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 185 } 186 187 const APIVersion = "2020-11-01-preview" 188 queryParameters := map[string]interface{}{ 189 "api-version": APIVersion, 190 } 191 192 preparer := autorest.CreatePreparer( 193 autorest.AsContentType("application/json; charset=utf-8"), 194 autorest.AsPut(), 195 autorest.WithBaseURL(client.BaseURI), 196 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}", pathParameters), 197 autorest.WithJSON(registry), 198 autorest.WithQueryParameters(queryParameters)) 199 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 200} 201 202// CreateSender sends the Create request. The method will close the 203// http.Response Body if it receives an error. 204func (client RegistriesClient) CreateSender(req *http.Request) (future RegistriesCreateFuture, err error) { 205 var resp *http.Response 206 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 207 if err != nil { 208 return 209 } 210 var azf azure.Future 211 azf, err = azure.NewFutureFromResponse(resp) 212 future.FutureAPI = &azf 213 future.Result = func(client RegistriesClient) (r Registry, err error) { 214 var done bool 215 done, err = future.DoneWithContext(context.Background(), client) 216 if err != nil { 217 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesCreateFuture", "Result", future.Response(), "Polling failure") 218 return 219 } 220 if !done { 221 err = azure.NewAsyncOpIncompleteError("containerregistry.RegistriesCreateFuture") 222 return 223 } 224 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 225 if r.Response.Response, err = future.GetResult(sender); err == nil && r.Response.Response.StatusCode != http.StatusNoContent { 226 r, err = client.CreateResponder(r.Response.Response) 227 if err != nil { 228 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesCreateFuture", "Result", r.Response.Response, "Failure responding to request") 229 } 230 } 231 return 232 } 233 return 234} 235 236// CreateResponder handles the response to the Create request. The method always 237// closes the http.Response Body. 238func (client RegistriesClient) CreateResponder(resp *http.Response) (result Registry, err error) { 239 err = autorest.Respond( 240 resp, 241 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 242 autorest.ByUnmarshallingJSON(&result), 243 autorest.ByClosing()) 244 result.Response = autorest.Response{Response: resp} 245 return 246} 247 248// Delete deletes a container registry. 249// Parameters: 250// resourceGroupName - the name of the resource group to which the container registry belongs. 251// registryName - the name of the container registry. 252func (client RegistriesClient) Delete(ctx context.Context, resourceGroupName string, registryName string) (result RegistriesDeleteFuture, err error) { 253 if tracing.IsEnabled() { 254 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.Delete") 255 defer func() { 256 sc := -1 257 if result.Response() != nil { 258 sc = result.Response().StatusCode 259 } 260 tracing.EndSpan(ctx, sc, err) 261 }() 262 } 263 if err := validation.Validate([]validation.Validation{ 264 {TargetValue: resourceGroupName, 265 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 266 {TargetValue: registryName, 267 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 268 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 269 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 270 return result, validation.NewError("containerregistry.RegistriesClient", "Delete", err.Error()) 271 } 272 273 req, err := client.DeletePreparer(ctx, resourceGroupName, registryName) 274 if err != nil { 275 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Delete", nil, "Failure preparing request") 276 return 277 } 278 279 result, err = client.DeleteSender(req) 280 if err != nil { 281 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Delete", nil, "Failure sending request") 282 return 283 } 284 285 return 286} 287 288// DeletePreparer prepares the Delete request. 289func (client RegistriesClient) DeletePreparer(ctx context.Context, resourceGroupName string, registryName string) (*http.Request, error) { 290 pathParameters := map[string]interface{}{ 291 "registryName": autorest.Encode("path", registryName), 292 "resourceGroupName": autorest.Encode("path", resourceGroupName), 293 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 294 } 295 296 const APIVersion = "2020-11-01-preview" 297 queryParameters := map[string]interface{}{ 298 "api-version": APIVersion, 299 } 300 301 preparer := autorest.CreatePreparer( 302 autorest.AsDelete(), 303 autorest.WithBaseURL(client.BaseURI), 304 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}", pathParameters), 305 autorest.WithQueryParameters(queryParameters)) 306 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 307} 308 309// DeleteSender sends the Delete request. The method will close the 310// http.Response Body if it receives an error. 311func (client RegistriesClient) DeleteSender(req *http.Request) (future RegistriesDeleteFuture, err error) { 312 var resp *http.Response 313 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 314 if err != nil { 315 return 316 } 317 var azf azure.Future 318 azf, err = azure.NewFutureFromResponse(resp) 319 future.FutureAPI = &azf 320 future.Result = func(client RegistriesClient) (ar autorest.Response, err error) { 321 var done bool 322 done, err = future.DoneWithContext(context.Background(), client) 323 if err != nil { 324 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesDeleteFuture", "Result", future.Response(), "Polling failure") 325 return 326 } 327 if !done { 328 err = azure.NewAsyncOpIncompleteError("containerregistry.RegistriesDeleteFuture") 329 return 330 } 331 ar.Response = future.Response() 332 return 333 } 334 return 335} 336 337// DeleteResponder handles the response to the Delete request. The method always 338// closes the http.Response Body. 339func (client RegistriesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 340 err = autorest.Respond( 341 resp, 342 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 343 autorest.ByClosing()) 344 result.Response = resp 345 return 346} 347 348// GenerateCredentials generate keys for a token of a specified container registry. 349// Parameters: 350// resourceGroupName - the name of the resource group to which the container registry belongs. 351// registryName - the name of the container registry. 352// generateCredentialsParameters - the parameters for generating credentials. 353func (client RegistriesClient) GenerateCredentials(ctx context.Context, resourceGroupName string, registryName string, generateCredentialsParameters GenerateCredentialsParameters) (result RegistriesGenerateCredentialsFuture, err error) { 354 if tracing.IsEnabled() { 355 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.GenerateCredentials") 356 defer func() { 357 sc := -1 358 if result.Response() != nil { 359 sc = result.Response().StatusCode 360 } 361 tracing.EndSpan(ctx, sc, err) 362 }() 363 } 364 if err := validation.Validate([]validation.Validation{ 365 {TargetValue: resourceGroupName, 366 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 367 {TargetValue: registryName, 368 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 369 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 370 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 371 return result, validation.NewError("containerregistry.RegistriesClient", "GenerateCredentials", err.Error()) 372 } 373 374 req, err := client.GenerateCredentialsPreparer(ctx, resourceGroupName, registryName, generateCredentialsParameters) 375 if err != nil { 376 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "GenerateCredentials", nil, "Failure preparing request") 377 return 378 } 379 380 result, err = client.GenerateCredentialsSender(req) 381 if err != nil { 382 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "GenerateCredentials", nil, "Failure sending request") 383 return 384 } 385 386 return 387} 388 389// GenerateCredentialsPreparer prepares the GenerateCredentials request. 390func (client RegistriesClient) GenerateCredentialsPreparer(ctx context.Context, resourceGroupName string, registryName string, generateCredentialsParameters GenerateCredentialsParameters) (*http.Request, error) { 391 pathParameters := map[string]interface{}{ 392 "registryName": autorest.Encode("path", registryName), 393 "resourceGroupName": autorest.Encode("path", resourceGroupName), 394 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 395 } 396 397 const APIVersion = "2020-11-01-preview" 398 queryParameters := map[string]interface{}{ 399 "api-version": APIVersion, 400 } 401 402 preparer := autorest.CreatePreparer( 403 autorest.AsContentType("application/json; charset=utf-8"), 404 autorest.AsPost(), 405 autorest.WithBaseURL(client.BaseURI), 406 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/generateCredentials", pathParameters), 407 autorest.WithJSON(generateCredentialsParameters), 408 autorest.WithQueryParameters(queryParameters)) 409 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 410} 411 412// GenerateCredentialsSender sends the GenerateCredentials request. The method will close the 413// http.Response Body if it receives an error. 414func (client RegistriesClient) GenerateCredentialsSender(req *http.Request) (future RegistriesGenerateCredentialsFuture, err error) { 415 var resp *http.Response 416 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 417 if err != nil { 418 return 419 } 420 var azf azure.Future 421 azf, err = azure.NewFutureFromResponse(resp) 422 future.FutureAPI = &azf 423 future.Result = func(client RegistriesClient) (gcr GenerateCredentialsResult, err error) { 424 var done bool 425 done, err = future.DoneWithContext(context.Background(), client) 426 if err != nil { 427 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesGenerateCredentialsFuture", "Result", future.Response(), "Polling failure") 428 return 429 } 430 if !done { 431 err = azure.NewAsyncOpIncompleteError("containerregistry.RegistriesGenerateCredentialsFuture") 432 return 433 } 434 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 435 if gcr.Response.Response, err = future.GetResult(sender); err == nil && gcr.Response.Response.StatusCode != http.StatusNoContent { 436 gcr, err = client.GenerateCredentialsResponder(gcr.Response.Response) 437 if err != nil { 438 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesGenerateCredentialsFuture", "Result", gcr.Response.Response, "Failure responding to request") 439 } 440 } 441 return 442 } 443 return 444} 445 446// GenerateCredentialsResponder handles the response to the GenerateCredentials request. The method always 447// closes the http.Response Body. 448func (client RegistriesClient) GenerateCredentialsResponder(resp *http.Response) (result GenerateCredentialsResult, err error) { 449 err = autorest.Respond( 450 resp, 451 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 452 autorest.ByUnmarshallingJSON(&result), 453 autorest.ByClosing()) 454 result.Response = autorest.Response{Response: resp} 455 return 456} 457 458// Get gets the properties of the specified container registry. 459// Parameters: 460// resourceGroupName - the name of the resource group to which the container registry belongs. 461// registryName - the name of the container registry. 462func (client RegistriesClient) Get(ctx context.Context, resourceGroupName string, registryName string) (result Registry, err error) { 463 if tracing.IsEnabled() { 464 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.Get") 465 defer func() { 466 sc := -1 467 if result.Response.Response != nil { 468 sc = result.Response.Response.StatusCode 469 } 470 tracing.EndSpan(ctx, sc, err) 471 }() 472 } 473 if err := validation.Validate([]validation.Validation{ 474 {TargetValue: resourceGroupName, 475 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 476 {TargetValue: registryName, 477 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 478 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 479 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 480 return result, validation.NewError("containerregistry.RegistriesClient", "Get", err.Error()) 481 } 482 483 req, err := client.GetPreparer(ctx, resourceGroupName, registryName) 484 if err != nil { 485 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Get", nil, "Failure preparing request") 486 return 487 } 488 489 resp, err := client.GetSender(req) 490 if err != nil { 491 result.Response = autorest.Response{Response: resp} 492 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Get", resp, "Failure sending request") 493 return 494 } 495 496 result, err = client.GetResponder(resp) 497 if err != nil { 498 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Get", resp, "Failure responding to request") 499 return 500 } 501 502 return 503} 504 505// GetPreparer prepares the Get request. 506func (client RegistriesClient) GetPreparer(ctx context.Context, resourceGroupName string, registryName string) (*http.Request, error) { 507 pathParameters := map[string]interface{}{ 508 "registryName": autorest.Encode("path", registryName), 509 "resourceGroupName": autorest.Encode("path", resourceGroupName), 510 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 511 } 512 513 const APIVersion = "2020-11-01-preview" 514 queryParameters := map[string]interface{}{ 515 "api-version": APIVersion, 516 } 517 518 preparer := autorest.CreatePreparer( 519 autorest.AsGet(), 520 autorest.WithBaseURL(client.BaseURI), 521 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}", pathParameters), 522 autorest.WithQueryParameters(queryParameters)) 523 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 524} 525 526// GetSender sends the Get request. The method will close the 527// http.Response Body if it receives an error. 528func (client RegistriesClient) GetSender(req *http.Request) (*http.Response, error) { 529 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 530} 531 532// GetResponder handles the response to the Get request. The method always 533// closes the http.Response Body. 534func (client RegistriesClient) GetResponder(resp *http.Response) (result Registry, err error) { 535 err = autorest.Respond( 536 resp, 537 azure.WithErrorUnlessStatusCode(http.StatusOK), 538 autorest.ByUnmarshallingJSON(&result), 539 autorest.ByClosing()) 540 result.Response = autorest.Response{Response: resp} 541 return 542} 543 544// GetBuildSourceUploadURL get the upload location for the user to be able to upload the source. 545// Parameters: 546// resourceGroupName - the name of the resource group to which the container registry belongs. 547// registryName - the name of the container registry. 548func (client RegistriesClient) GetBuildSourceUploadURL(ctx context.Context, resourceGroupName string, registryName string) (result SourceUploadDefinition, err error) { 549 if tracing.IsEnabled() { 550 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.GetBuildSourceUploadURL") 551 defer func() { 552 sc := -1 553 if result.Response.Response != nil { 554 sc = result.Response.Response.StatusCode 555 } 556 tracing.EndSpan(ctx, sc, err) 557 }() 558 } 559 if err := validation.Validate([]validation.Validation{ 560 {TargetValue: resourceGroupName, 561 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 562 {TargetValue: registryName, 563 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 564 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 565 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 566 return result, validation.NewError("containerregistry.RegistriesClient", "GetBuildSourceUploadURL", err.Error()) 567 } 568 569 req, err := client.GetBuildSourceUploadURLPreparer(ctx, resourceGroupName, registryName) 570 if err != nil { 571 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "GetBuildSourceUploadURL", nil, "Failure preparing request") 572 return 573 } 574 575 resp, err := client.GetBuildSourceUploadURLSender(req) 576 if err != nil { 577 result.Response = autorest.Response{Response: resp} 578 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "GetBuildSourceUploadURL", resp, "Failure sending request") 579 return 580 } 581 582 result, err = client.GetBuildSourceUploadURLResponder(resp) 583 if err != nil { 584 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "GetBuildSourceUploadURL", resp, "Failure responding to request") 585 return 586 } 587 588 return 589} 590 591// GetBuildSourceUploadURLPreparer prepares the GetBuildSourceUploadURL request. 592func (client RegistriesClient) GetBuildSourceUploadURLPreparer(ctx context.Context, resourceGroupName string, registryName string) (*http.Request, error) { 593 pathParameters := map[string]interface{}{ 594 "registryName": autorest.Encode("path", registryName), 595 "resourceGroupName": autorest.Encode("path", resourceGroupName), 596 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 597 } 598 599 const APIVersion = "2019-06-01-preview" 600 queryParameters := map[string]interface{}{ 601 "api-version": APIVersion, 602 } 603 604 preparer := autorest.CreatePreparer( 605 autorest.AsPost(), 606 autorest.WithBaseURL(client.BaseURI), 607 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/listBuildSourceUploadUrl", pathParameters), 608 autorest.WithQueryParameters(queryParameters)) 609 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 610} 611 612// GetBuildSourceUploadURLSender sends the GetBuildSourceUploadURL request. The method will close the 613// http.Response Body if it receives an error. 614func (client RegistriesClient) GetBuildSourceUploadURLSender(req *http.Request) (*http.Response, error) { 615 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 616} 617 618// GetBuildSourceUploadURLResponder handles the response to the GetBuildSourceUploadURL request. The method always 619// closes the http.Response Body. 620func (client RegistriesClient) GetBuildSourceUploadURLResponder(resp *http.Response) (result SourceUploadDefinition, err error) { 621 err = autorest.Respond( 622 resp, 623 azure.WithErrorUnlessStatusCode(http.StatusOK), 624 autorest.ByUnmarshallingJSON(&result), 625 autorest.ByClosing()) 626 result.Response = autorest.Response{Response: resp} 627 return 628} 629 630// ImportImage copies an image to this container registry from the specified container registry. 631// Parameters: 632// resourceGroupName - the name of the resource group to which the container registry belongs. 633// registryName - the name of the container registry. 634// parameters - the parameters specifying the image to copy and the source container registry. 635func (client RegistriesClient) ImportImage(ctx context.Context, resourceGroupName string, registryName string, parameters ImportImageParameters) (result RegistriesImportImageFuture, err error) { 636 if tracing.IsEnabled() { 637 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.ImportImage") 638 defer func() { 639 sc := -1 640 if result.Response() != nil { 641 sc = result.Response().StatusCode 642 } 643 tracing.EndSpan(ctx, sc, err) 644 }() 645 } 646 if err := validation.Validate([]validation.Validation{ 647 {TargetValue: resourceGroupName, 648 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 649 {TargetValue: registryName, 650 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 651 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 652 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}, 653 {TargetValue: parameters, 654 Constraints: []validation.Constraint{{Target: "parameters.Source", Name: validation.Null, Rule: true, 655 Chain: []validation.Constraint{{Target: "parameters.Source.Credentials", Name: validation.Null, Rule: false, 656 Chain: []validation.Constraint{{Target: "parameters.Source.Credentials.Password", Name: validation.Null, Rule: true, Chain: nil}}}, 657 {Target: "parameters.Source.SourceImage", Name: validation.Null, Rule: true, Chain: nil}, 658 }}}}}); err != nil { 659 return result, validation.NewError("containerregistry.RegistriesClient", "ImportImage", err.Error()) 660 } 661 662 req, err := client.ImportImagePreparer(ctx, resourceGroupName, registryName, parameters) 663 if err != nil { 664 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ImportImage", nil, "Failure preparing request") 665 return 666 } 667 668 result, err = client.ImportImageSender(req) 669 if err != nil { 670 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ImportImage", nil, "Failure sending request") 671 return 672 } 673 674 return 675} 676 677// ImportImagePreparer prepares the ImportImage request. 678func (client RegistriesClient) ImportImagePreparer(ctx context.Context, resourceGroupName string, registryName string, parameters ImportImageParameters) (*http.Request, error) { 679 pathParameters := map[string]interface{}{ 680 "registryName": autorest.Encode("path", registryName), 681 "resourceGroupName": autorest.Encode("path", resourceGroupName), 682 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 683 } 684 685 const APIVersion = "2020-11-01-preview" 686 queryParameters := map[string]interface{}{ 687 "api-version": APIVersion, 688 } 689 690 preparer := autorest.CreatePreparer( 691 autorest.AsContentType("application/json; charset=utf-8"), 692 autorest.AsPost(), 693 autorest.WithBaseURL(client.BaseURI), 694 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/importImage", pathParameters), 695 autorest.WithJSON(parameters), 696 autorest.WithQueryParameters(queryParameters)) 697 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 698} 699 700// ImportImageSender sends the ImportImage request. The method will close the 701// http.Response Body if it receives an error. 702func (client RegistriesClient) ImportImageSender(req *http.Request) (future RegistriesImportImageFuture, err error) { 703 var resp *http.Response 704 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 705 if err != nil { 706 return 707 } 708 var azf azure.Future 709 azf, err = azure.NewFutureFromResponse(resp) 710 future.FutureAPI = &azf 711 future.Result = func(client RegistriesClient) (ar autorest.Response, err error) { 712 var done bool 713 done, err = future.DoneWithContext(context.Background(), client) 714 if err != nil { 715 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesImportImageFuture", "Result", future.Response(), "Polling failure") 716 return 717 } 718 if !done { 719 err = azure.NewAsyncOpIncompleteError("containerregistry.RegistriesImportImageFuture") 720 return 721 } 722 ar.Response = future.Response() 723 return 724 } 725 return 726} 727 728// ImportImageResponder handles the response to the ImportImage request. The method always 729// closes the http.Response Body. 730func (client RegistriesClient) ImportImageResponder(resp *http.Response) (result autorest.Response, err error) { 731 err = autorest.Respond( 732 resp, 733 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 734 autorest.ByClosing()) 735 result.Response = resp 736 return 737} 738 739// List lists all the container registries under the specified subscription. 740func (client RegistriesClient) List(ctx context.Context) (result RegistryListResultPage, err error) { 741 if tracing.IsEnabled() { 742 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.List") 743 defer func() { 744 sc := -1 745 if result.rlr.Response.Response != nil { 746 sc = result.rlr.Response.Response.StatusCode 747 } 748 tracing.EndSpan(ctx, sc, err) 749 }() 750 } 751 result.fn = client.listNextResults 752 req, err := client.ListPreparer(ctx) 753 if err != nil { 754 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "List", nil, "Failure preparing request") 755 return 756 } 757 758 resp, err := client.ListSender(req) 759 if err != nil { 760 result.rlr.Response = autorest.Response{Response: resp} 761 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "List", resp, "Failure sending request") 762 return 763 } 764 765 result.rlr, err = client.ListResponder(resp) 766 if err != nil { 767 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "List", resp, "Failure responding to request") 768 return 769 } 770 if result.rlr.hasNextLink() && result.rlr.IsEmpty() { 771 err = result.NextWithContext(ctx) 772 return 773 } 774 775 return 776} 777 778// ListPreparer prepares the List request. 779func (client RegistriesClient) ListPreparer(ctx context.Context) (*http.Request, error) { 780 pathParameters := map[string]interface{}{ 781 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 782 } 783 784 const APIVersion = "2020-11-01-preview" 785 queryParameters := map[string]interface{}{ 786 "api-version": APIVersion, 787 } 788 789 preparer := autorest.CreatePreparer( 790 autorest.AsGet(), 791 autorest.WithBaseURL(client.BaseURI), 792 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.ContainerRegistry/registries", pathParameters), 793 autorest.WithQueryParameters(queryParameters)) 794 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 795} 796 797// ListSender sends the List request. The method will close the 798// http.Response Body if it receives an error. 799func (client RegistriesClient) ListSender(req *http.Request) (*http.Response, error) { 800 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 801} 802 803// ListResponder handles the response to the List request. The method always 804// closes the http.Response Body. 805func (client RegistriesClient) ListResponder(resp *http.Response) (result RegistryListResult, err error) { 806 err = autorest.Respond( 807 resp, 808 azure.WithErrorUnlessStatusCode(http.StatusOK), 809 autorest.ByUnmarshallingJSON(&result), 810 autorest.ByClosing()) 811 result.Response = autorest.Response{Response: resp} 812 return 813} 814 815// listNextResults retrieves the next set of results, if any. 816func (client RegistriesClient) listNextResults(ctx context.Context, lastResults RegistryListResult) (result RegistryListResult, err error) { 817 req, err := lastResults.registryListResultPreparer(ctx) 818 if err != nil { 819 return result, autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listNextResults", nil, "Failure preparing next results request") 820 } 821 if req == nil { 822 return 823 } 824 resp, err := client.ListSender(req) 825 if err != nil { 826 result.Response = autorest.Response{Response: resp} 827 return result, autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listNextResults", resp, "Failure sending next results request") 828 } 829 result, err = client.ListResponder(resp) 830 if err != nil { 831 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listNextResults", resp, "Failure responding to next results request") 832 } 833 return 834} 835 836// ListComplete enumerates all values, automatically crossing page boundaries as required. 837func (client RegistriesClient) ListComplete(ctx context.Context) (result RegistryListResultIterator, err error) { 838 if tracing.IsEnabled() { 839 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.List") 840 defer func() { 841 sc := -1 842 if result.Response().Response.Response != nil { 843 sc = result.page.Response().Response.Response.StatusCode 844 } 845 tracing.EndSpan(ctx, sc, err) 846 }() 847 } 848 result.page, err = client.List(ctx) 849 return 850} 851 852// ListByResourceGroup lists all the container registries under the specified resource group. 853// Parameters: 854// resourceGroupName - the name of the resource group to which the container registry belongs. 855func (client RegistriesClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result RegistryListResultPage, err error) { 856 if tracing.IsEnabled() { 857 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.ListByResourceGroup") 858 defer func() { 859 sc := -1 860 if result.rlr.Response.Response != nil { 861 sc = result.rlr.Response.Response.StatusCode 862 } 863 tracing.EndSpan(ctx, sc, err) 864 }() 865 } 866 if err := validation.Validate([]validation.Validation{ 867 {TargetValue: resourceGroupName, 868 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { 869 return result, validation.NewError("containerregistry.RegistriesClient", "ListByResourceGroup", err.Error()) 870 } 871 872 result.fn = client.listByResourceGroupNextResults 873 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 874 if err != nil { 875 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListByResourceGroup", nil, "Failure preparing request") 876 return 877 } 878 879 resp, err := client.ListByResourceGroupSender(req) 880 if err != nil { 881 result.rlr.Response = autorest.Response{Response: resp} 882 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListByResourceGroup", resp, "Failure sending request") 883 return 884 } 885 886 result.rlr, err = client.ListByResourceGroupResponder(resp) 887 if err != nil { 888 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListByResourceGroup", resp, "Failure responding to request") 889 return 890 } 891 if result.rlr.hasNextLink() && result.rlr.IsEmpty() { 892 err = result.NextWithContext(ctx) 893 return 894 } 895 896 return 897} 898 899// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 900func (client RegistriesClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 901 pathParameters := map[string]interface{}{ 902 "resourceGroupName": autorest.Encode("path", resourceGroupName), 903 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 904 } 905 906 const APIVersion = "2020-11-01-preview" 907 queryParameters := map[string]interface{}{ 908 "api-version": APIVersion, 909 } 910 911 preparer := autorest.CreatePreparer( 912 autorest.AsGet(), 913 autorest.WithBaseURL(client.BaseURI), 914 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries", pathParameters), 915 autorest.WithQueryParameters(queryParameters)) 916 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 917} 918 919// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 920// http.Response Body if it receives an error. 921func (client RegistriesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 922 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 923} 924 925// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 926// closes the http.Response Body. 927func (client RegistriesClient) ListByResourceGroupResponder(resp *http.Response) (result RegistryListResult, err error) { 928 err = autorest.Respond( 929 resp, 930 azure.WithErrorUnlessStatusCode(http.StatusOK), 931 autorest.ByUnmarshallingJSON(&result), 932 autorest.ByClosing()) 933 result.Response = autorest.Response{Response: resp} 934 return 935} 936 937// listByResourceGroupNextResults retrieves the next set of results, if any. 938func (client RegistriesClient) listByResourceGroupNextResults(ctx context.Context, lastResults RegistryListResult) (result RegistryListResult, err error) { 939 req, err := lastResults.registryListResultPreparer(ctx) 940 if err != nil { 941 return result, autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 942 } 943 if req == nil { 944 return 945 } 946 resp, err := client.ListByResourceGroupSender(req) 947 if err != nil { 948 result.Response = autorest.Response{Response: resp} 949 return result, autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 950 } 951 result, err = client.ListByResourceGroupResponder(resp) 952 if err != nil { 953 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 954 } 955 return 956} 957 958// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 959func (client RegistriesClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result RegistryListResultIterator, err error) { 960 if tracing.IsEnabled() { 961 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.ListByResourceGroup") 962 defer func() { 963 sc := -1 964 if result.Response().Response.Response != nil { 965 sc = result.page.Response().Response.Response.StatusCode 966 } 967 tracing.EndSpan(ctx, sc, err) 968 }() 969 } 970 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 971 return 972} 973 974// ListCredentials lists the login credentials for the specified container registry. 975// Parameters: 976// resourceGroupName - the name of the resource group to which the container registry belongs. 977// registryName - the name of the container registry. 978func (client RegistriesClient) ListCredentials(ctx context.Context, resourceGroupName string, registryName string) (result RegistryListCredentialsResult, err error) { 979 if tracing.IsEnabled() { 980 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.ListCredentials") 981 defer func() { 982 sc := -1 983 if result.Response.Response != nil { 984 sc = result.Response.Response.StatusCode 985 } 986 tracing.EndSpan(ctx, sc, err) 987 }() 988 } 989 if err := validation.Validate([]validation.Validation{ 990 {TargetValue: resourceGroupName, 991 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 992 {TargetValue: registryName, 993 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 994 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 995 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 996 return result, validation.NewError("containerregistry.RegistriesClient", "ListCredentials", err.Error()) 997 } 998 999 req, err := client.ListCredentialsPreparer(ctx, resourceGroupName, registryName) 1000 if err != nil { 1001 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListCredentials", nil, "Failure preparing request") 1002 return 1003 } 1004 1005 resp, err := client.ListCredentialsSender(req) 1006 if err != nil { 1007 result.Response = autorest.Response{Response: resp} 1008 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListCredentials", resp, "Failure sending request") 1009 return 1010 } 1011 1012 result, err = client.ListCredentialsResponder(resp) 1013 if err != nil { 1014 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListCredentials", resp, "Failure responding to request") 1015 return 1016 } 1017 1018 return 1019} 1020 1021// ListCredentialsPreparer prepares the ListCredentials request. 1022func (client RegistriesClient) ListCredentialsPreparer(ctx context.Context, resourceGroupName string, registryName string) (*http.Request, error) { 1023 pathParameters := map[string]interface{}{ 1024 "registryName": autorest.Encode("path", registryName), 1025 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1026 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1027 } 1028 1029 const APIVersion = "2020-11-01-preview" 1030 queryParameters := map[string]interface{}{ 1031 "api-version": APIVersion, 1032 } 1033 1034 preparer := autorest.CreatePreparer( 1035 autorest.AsPost(), 1036 autorest.WithBaseURL(client.BaseURI), 1037 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/listCredentials", pathParameters), 1038 autorest.WithQueryParameters(queryParameters)) 1039 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1040} 1041 1042// ListCredentialsSender sends the ListCredentials request. The method will close the 1043// http.Response Body if it receives an error. 1044func (client RegistriesClient) ListCredentialsSender(req *http.Request) (*http.Response, error) { 1045 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1046} 1047 1048// ListCredentialsResponder handles the response to the ListCredentials request. The method always 1049// closes the http.Response Body. 1050func (client RegistriesClient) ListCredentialsResponder(resp *http.Response) (result RegistryListCredentialsResult, err error) { 1051 err = autorest.Respond( 1052 resp, 1053 azure.WithErrorUnlessStatusCode(http.StatusOK), 1054 autorest.ByUnmarshallingJSON(&result), 1055 autorest.ByClosing()) 1056 result.Response = autorest.Response{Response: resp} 1057 return 1058} 1059 1060// ListPrivateLinkResources lists the private link resources for a container registry. 1061// Parameters: 1062// resourceGroupName - the name of the resource group to which the container registry belongs. 1063// registryName - the name of the container registry. 1064func (client RegistriesClient) ListPrivateLinkResources(ctx context.Context, resourceGroupName string, registryName string) (result PrivateLinkResourceListResultPage, err error) { 1065 if tracing.IsEnabled() { 1066 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.ListPrivateLinkResources") 1067 defer func() { 1068 sc := -1 1069 if result.plrlr.Response.Response != nil { 1070 sc = result.plrlr.Response.Response.StatusCode 1071 } 1072 tracing.EndSpan(ctx, sc, err) 1073 }() 1074 } 1075 if err := validation.Validate([]validation.Validation{ 1076 {TargetValue: resourceGroupName, 1077 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1078 {TargetValue: registryName, 1079 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1080 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 1081 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 1082 return result, validation.NewError("containerregistry.RegistriesClient", "ListPrivateLinkResources", err.Error()) 1083 } 1084 1085 result.fn = client.listPrivateLinkResourcesNextResults 1086 req, err := client.ListPrivateLinkResourcesPreparer(ctx, resourceGroupName, registryName) 1087 if err != nil { 1088 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListPrivateLinkResources", nil, "Failure preparing request") 1089 return 1090 } 1091 1092 resp, err := client.ListPrivateLinkResourcesSender(req) 1093 if err != nil { 1094 result.plrlr.Response = autorest.Response{Response: resp} 1095 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListPrivateLinkResources", resp, "Failure sending request") 1096 return 1097 } 1098 1099 result.plrlr, err = client.ListPrivateLinkResourcesResponder(resp) 1100 if err != nil { 1101 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListPrivateLinkResources", resp, "Failure responding to request") 1102 return 1103 } 1104 if result.plrlr.hasNextLink() && result.plrlr.IsEmpty() { 1105 err = result.NextWithContext(ctx) 1106 return 1107 } 1108 1109 return 1110} 1111 1112// ListPrivateLinkResourcesPreparer prepares the ListPrivateLinkResources request. 1113func (client RegistriesClient) ListPrivateLinkResourcesPreparer(ctx context.Context, resourceGroupName string, registryName string) (*http.Request, error) { 1114 pathParameters := map[string]interface{}{ 1115 "registryName": autorest.Encode("path", registryName), 1116 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1117 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1118 } 1119 1120 const APIVersion = "2020-11-01-preview" 1121 queryParameters := map[string]interface{}{ 1122 "api-version": APIVersion, 1123 } 1124 1125 preparer := autorest.CreatePreparer( 1126 autorest.AsGet(), 1127 autorest.WithBaseURL(client.BaseURI), 1128 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/privateLinkResources", pathParameters), 1129 autorest.WithQueryParameters(queryParameters)) 1130 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1131} 1132 1133// ListPrivateLinkResourcesSender sends the ListPrivateLinkResources request. The method will close the 1134// http.Response Body if it receives an error. 1135func (client RegistriesClient) ListPrivateLinkResourcesSender(req *http.Request) (*http.Response, error) { 1136 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1137} 1138 1139// ListPrivateLinkResourcesResponder handles the response to the ListPrivateLinkResources request. The method always 1140// closes the http.Response Body. 1141func (client RegistriesClient) ListPrivateLinkResourcesResponder(resp *http.Response) (result PrivateLinkResourceListResult, err error) { 1142 err = autorest.Respond( 1143 resp, 1144 azure.WithErrorUnlessStatusCode(http.StatusOK), 1145 autorest.ByUnmarshallingJSON(&result), 1146 autorest.ByClosing()) 1147 result.Response = autorest.Response{Response: resp} 1148 return 1149} 1150 1151// listPrivateLinkResourcesNextResults retrieves the next set of results, if any. 1152func (client RegistriesClient) listPrivateLinkResourcesNextResults(ctx context.Context, lastResults PrivateLinkResourceListResult) (result PrivateLinkResourceListResult, err error) { 1153 req, err := lastResults.privateLinkResourceListResultPreparer(ctx) 1154 if err != nil { 1155 return result, autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listPrivateLinkResourcesNextResults", nil, "Failure preparing next results request") 1156 } 1157 if req == nil { 1158 return 1159 } 1160 resp, err := client.ListPrivateLinkResourcesSender(req) 1161 if err != nil { 1162 result.Response = autorest.Response{Response: resp} 1163 return result, autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listPrivateLinkResourcesNextResults", resp, "Failure sending next results request") 1164 } 1165 result, err = client.ListPrivateLinkResourcesResponder(resp) 1166 if err != nil { 1167 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "listPrivateLinkResourcesNextResults", resp, "Failure responding to next results request") 1168 } 1169 return 1170} 1171 1172// ListPrivateLinkResourcesComplete enumerates all values, automatically crossing page boundaries as required. 1173func (client RegistriesClient) ListPrivateLinkResourcesComplete(ctx context.Context, resourceGroupName string, registryName string) (result PrivateLinkResourceListResultIterator, err error) { 1174 if tracing.IsEnabled() { 1175 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.ListPrivateLinkResources") 1176 defer func() { 1177 sc := -1 1178 if result.Response().Response.Response != nil { 1179 sc = result.page.Response().Response.Response.StatusCode 1180 } 1181 tracing.EndSpan(ctx, sc, err) 1182 }() 1183 } 1184 result.page, err = client.ListPrivateLinkResources(ctx, resourceGroupName, registryName) 1185 return 1186} 1187 1188// ListUsages gets the quota usages for the specified container registry. 1189// Parameters: 1190// resourceGroupName - the name of the resource group to which the container registry belongs. 1191// registryName - the name of the container registry. 1192func (client RegistriesClient) ListUsages(ctx context.Context, resourceGroupName string, registryName string) (result RegistryUsageListResult, err error) { 1193 if tracing.IsEnabled() { 1194 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.ListUsages") 1195 defer func() { 1196 sc := -1 1197 if result.Response.Response != nil { 1198 sc = result.Response.Response.StatusCode 1199 } 1200 tracing.EndSpan(ctx, sc, err) 1201 }() 1202 } 1203 if err := validation.Validate([]validation.Validation{ 1204 {TargetValue: resourceGroupName, 1205 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1206 {TargetValue: registryName, 1207 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1208 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 1209 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 1210 return result, validation.NewError("containerregistry.RegistriesClient", "ListUsages", err.Error()) 1211 } 1212 1213 req, err := client.ListUsagesPreparer(ctx, resourceGroupName, registryName) 1214 if err != nil { 1215 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListUsages", nil, "Failure preparing request") 1216 return 1217 } 1218 1219 resp, err := client.ListUsagesSender(req) 1220 if err != nil { 1221 result.Response = autorest.Response{Response: resp} 1222 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListUsages", resp, "Failure sending request") 1223 return 1224 } 1225 1226 result, err = client.ListUsagesResponder(resp) 1227 if err != nil { 1228 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ListUsages", resp, "Failure responding to request") 1229 return 1230 } 1231 1232 return 1233} 1234 1235// ListUsagesPreparer prepares the ListUsages request. 1236func (client RegistriesClient) ListUsagesPreparer(ctx context.Context, resourceGroupName string, registryName string) (*http.Request, error) { 1237 pathParameters := map[string]interface{}{ 1238 "registryName": autorest.Encode("path", registryName), 1239 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1240 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1241 } 1242 1243 const APIVersion = "2020-11-01-preview" 1244 queryParameters := map[string]interface{}{ 1245 "api-version": APIVersion, 1246 } 1247 1248 preparer := autorest.CreatePreparer( 1249 autorest.AsGet(), 1250 autorest.WithBaseURL(client.BaseURI), 1251 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/listUsages", pathParameters), 1252 autorest.WithQueryParameters(queryParameters)) 1253 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1254} 1255 1256// ListUsagesSender sends the ListUsages request. The method will close the 1257// http.Response Body if it receives an error. 1258func (client RegistriesClient) ListUsagesSender(req *http.Request) (*http.Response, error) { 1259 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1260} 1261 1262// ListUsagesResponder handles the response to the ListUsages request. The method always 1263// closes the http.Response Body. 1264func (client RegistriesClient) ListUsagesResponder(resp *http.Response) (result RegistryUsageListResult, err error) { 1265 err = autorest.Respond( 1266 resp, 1267 azure.WithErrorUnlessStatusCode(http.StatusOK), 1268 autorest.ByUnmarshallingJSON(&result), 1269 autorest.ByClosing()) 1270 result.Response = autorest.Response{Response: resp} 1271 return 1272} 1273 1274// RegenerateCredential regenerates one of the login credentials for the specified container registry. 1275// Parameters: 1276// resourceGroupName - the name of the resource group to which the container registry belongs. 1277// registryName - the name of the container registry. 1278// regenerateCredentialParameters - specifies name of the password which should be regenerated -- password or 1279// password2. 1280func (client RegistriesClient) RegenerateCredential(ctx context.Context, resourceGroupName string, registryName string, regenerateCredentialParameters RegenerateCredentialParameters) (result RegistryListCredentialsResult, err error) { 1281 if tracing.IsEnabled() { 1282 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.RegenerateCredential") 1283 defer func() { 1284 sc := -1 1285 if result.Response.Response != nil { 1286 sc = result.Response.Response.StatusCode 1287 } 1288 tracing.EndSpan(ctx, sc, err) 1289 }() 1290 } 1291 if err := validation.Validate([]validation.Validation{ 1292 {TargetValue: resourceGroupName, 1293 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1294 {TargetValue: registryName, 1295 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1296 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 1297 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 1298 return result, validation.NewError("containerregistry.RegistriesClient", "RegenerateCredential", err.Error()) 1299 } 1300 1301 req, err := client.RegenerateCredentialPreparer(ctx, resourceGroupName, registryName, regenerateCredentialParameters) 1302 if err != nil { 1303 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "RegenerateCredential", nil, "Failure preparing request") 1304 return 1305 } 1306 1307 resp, err := client.RegenerateCredentialSender(req) 1308 if err != nil { 1309 result.Response = autorest.Response{Response: resp} 1310 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "RegenerateCredential", resp, "Failure sending request") 1311 return 1312 } 1313 1314 result, err = client.RegenerateCredentialResponder(resp) 1315 if err != nil { 1316 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "RegenerateCredential", resp, "Failure responding to request") 1317 return 1318 } 1319 1320 return 1321} 1322 1323// RegenerateCredentialPreparer prepares the RegenerateCredential request. 1324func (client RegistriesClient) RegenerateCredentialPreparer(ctx context.Context, resourceGroupName string, registryName string, regenerateCredentialParameters RegenerateCredentialParameters) (*http.Request, error) { 1325 pathParameters := map[string]interface{}{ 1326 "registryName": autorest.Encode("path", registryName), 1327 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1328 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1329 } 1330 1331 const APIVersion = "2020-11-01-preview" 1332 queryParameters := map[string]interface{}{ 1333 "api-version": APIVersion, 1334 } 1335 1336 preparer := autorest.CreatePreparer( 1337 autorest.AsContentType("application/json; charset=utf-8"), 1338 autorest.AsPost(), 1339 autorest.WithBaseURL(client.BaseURI), 1340 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/regenerateCredential", pathParameters), 1341 autorest.WithJSON(regenerateCredentialParameters), 1342 autorest.WithQueryParameters(queryParameters)) 1343 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1344} 1345 1346// RegenerateCredentialSender sends the RegenerateCredential request. The method will close the 1347// http.Response Body if it receives an error. 1348func (client RegistriesClient) RegenerateCredentialSender(req *http.Request) (*http.Response, error) { 1349 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1350} 1351 1352// RegenerateCredentialResponder handles the response to the RegenerateCredential request. The method always 1353// closes the http.Response Body. 1354func (client RegistriesClient) RegenerateCredentialResponder(resp *http.Response) (result RegistryListCredentialsResult, err error) { 1355 err = autorest.Respond( 1356 resp, 1357 azure.WithErrorUnlessStatusCode(http.StatusOK), 1358 autorest.ByUnmarshallingJSON(&result), 1359 autorest.ByClosing()) 1360 result.Response = autorest.Response{Response: resp} 1361 return 1362} 1363 1364// ScheduleRun schedules a new run based on the request parameters and add it to the run queue. 1365// Parameters: 1366// resourceGroupName - the name of the resource group to which the container registry belongs. 1367// registryName - the name of the container registry. 1368// runRequest - the parameters of a run that needs to scheduled. 1369func (client RegistriesClient) ScheduleRun(ctx context.Context, resourceGroupName string, registryName string, runRequest BasicRunRequest) (result RegistriesScheduleRunFuture, err error) { 1370 if tracing.IsEnabled() { 1371 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.ScheduleRun") 1372 defer func() { 1373 sc := -1 1374 if result.Response() != nil { 1375 sc = result.Response().StatusCode 1376 } 1377 tracing.EndSpan(ctx, sc, err) 1378 }() 1379 } 1380 if err := validation.Validate([]validation.Validation{ 1381 {TargetValue: resourceGroupName, 1382 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1383 {TargetValue: registryName, 1384 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1385 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 1386 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 1387 return result, validation.NewError("containerregistry.RegistriesClient", "ScheduleRun", err.Error()) 1388 } 1389 1390 req, err := client.ScheduleRunPreparer(ctx, resourceGroupName, registryName, runRequest) 1391 if err != nil { 1392 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ScheduleRun", nil, "Failure preparing request") 1393 return 1394 } 1395 1396 result, err = client.ScheduleRunSender(req) 1397 if err != nil { 1398 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "ScheduleRun", nil, "Failure sending request") 1399 return 1400 } 1401 1402 return 1403} 1404 1405// ScheduleRunPreparer prepares the ScheduleRun request. 1406func (client RegistriesClient) ScheduleRunPreparer(ctx context.Context, resourceGroupName string, registryName string, runRequest BasicRunRequest) (*http.Request, error) { 1407 pathParameters := map[string]interface{}{ 1408 "registryName": autorest.Encode("path", registryName), 1409 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1410 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1411 } 1412 1413 const APIVersion = "2019-06-01-preview" 1414 queryParameters := map[string]interface{}{ 1415 "api-version": APIVersion, 1416 } 1417 1418 preparer := autorest.CreatePreparer( 1419 autorest.AsContentType("application/json; charset=utf-8"), 1420 autorest.AsPost(), 1421 autorest.WithBaseURL(client.BaseURI), 1422 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/scheduleRun", pathParameters), 1423 autorest.WithJSON(runRequest), 1424 autorest.WithQueryParameters(queryParameters)) 1425 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1426} 1427 1428// ScheduleRunSender sends the ScheduleRun request. The method will close the 1429// http.Response Body if it receives an error. 1430func (client RegistriesClient) ScheduleRunSender(req *http.Request) (future RegistriesScheduleRunFuture, err error) { 1431 var resp *http.Response 1432 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1433 if err != nil { 1434 return 1435 } 1436 var azf azure.Future 1437 azf, err = azure.NewFutureFromResponse(resp) 1438 future.FutureAPI = &azf 1439 future.Result = func(client RegistriesClient) (r Run, err error) { 1440 var done bool 1441 done, err = future.DoneWithContext(context.Background(), client) 1442 if err != nil { 1443 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesScheduleRunFuture", "Result", future.Response(), "Polling failure") 1444 return 1445 } 1446 if !done { 1447 err = azure.NewAsyncOpIncompleteError("containerregistry.RegistriesScheduleRunFuture") 1448 return 1449 } 1450 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1451 if r.Response.Response, err = future.GetResult(sender); err == nil && r.Response.Response.StatusCode != http.StatusNoContent { 1452 r, err = client.ScheduleRunResponder(r.Response.Response) 1453 if err != nil { 1454 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesScheduleRunFuture", "Result", r.Response.Response, "Failure responding to request") 1455 } 1456 } 1457 return 1458 } 1459 return 1460} 1461 1462// ScheduleRunResponder handles the response to the ScheduleRun request. The method always 1463// closes the http.Response Body. 1464func (client RegistriesClient) ScheduleRunResponder(resp *http.Response) (result Run, err error) { 1465 err = autorest.Respond( 1466 resp, 1467 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1468 autorest.ByUnmarshallingJSON(&result), 1469 autorest.ByClosing()) 1470 result.Response = autorest.Response{Response: resp} 1471 return 1472} 1473 1474// Update updates a container registry with the specified parameters. 1475// Parameters: 1476// resourceGroupName - the name of the resource group to which the container registry belongs. 1477// registryName - the name of the container registry. 1478// registryUpdateParameters - the parameters for updating a container registry. 1479func (client RegistriesClient) Update(ctx context.Context, resourceGroupName string, registryName string, registryUpdateParameters RegistryUpdateParameters) (result RegistriesUpdateFuture, err error) { 1480 if tracing.IsEnabled() { 1481 ctx = tracing.StartSpan(ctx, fqdn+"/RegistriesClient.Update") 1482 defer func() { 1483 sc := -1 1484 if result.Response() != nil { 1485 sc = result.Response().StatusCode 1486 } 1487 tracing.EndSpan(ctx, sc, err) 1488 }() 1489 } 1490 if err := validation.Validate([]validation.Validation{ 1491 {TargetValue: resourceGroupName, 1492 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 1493 {TargetValue: registryName, 1494 Constraints: []validation.Constraint{{Target: "registryName", Name: validation.MaxLength, Rule: 50, Chain: nil}, 1495 {Target: "registryName", Name: validation.MinLength, Rule: 5, Chain: nil}, 1496 {Target: "registryName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]*$`, Chain: nil}}}}); err != nil { 1497 return result, validation.NewError("containerregistry.RegistriesClient", "Update", err.Error()) 1498 } 1499 1500 req, err := client.UpdatePreparer(ctx, resourceGroupName, registryName, registryUpdateParameters) 1501 if err != nil { 1502 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Update", nil, "Failure preparing request") 1503 return 1504 } 1505 1506 result, err = client.UpdateSender(req) 1507 if err != nil { 1508 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesClient", "Update", nil, "Failure sending request") 1509 return 1510 } 1511 1512 return 1513} 1514 1515// UpdatePreparer prepares the Update request. 1516func (client RegistriesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, registryName string, registryUpdateParameters RegistryUpdateParameters) (*http.Request, error) { 1517 pathParameters := map[string]interface{}{ 1518 "registryName": autorest.Encode("path", registryName), 1519 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1520 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1521 } 1522 1523 const APIVersion = "2020-11-01-preview" 1524 queryParameters := map[string]interface{}{ 1525 "api-version": APIVersion, 1526 } 1527 1528 preparer := autorest.CreatePreparer( 1529 autorest.AsContentType("application/json; charset=utf-8"), 1530 autorest.AsPatch(), 1531 autorest.WithBaseURL(client.BaseURI), 1532 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}", pathParameters), 1533 autorest.WithJSON(registryUpdateParameters), 1534 autorest.WithQueryParameters(queryParameters)) 1535 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1536} 1537 1538// UpdateSender sends the Update request. The method will close the 1539// http.Response Body if it receives an error. 1540func (client RegistriesClient) UpdateSender(req *http.Request) (future RegistriesUpdateFuture, err error) { 1541 var resp *http.Response 1542 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1543 if err != nil { 1544 return 1545 } 1546 var azf azure.Future 1547 azf, err = azure.NewFutureFromResponse(resp) 1548 future.FutureAPI = &azf 1549 future.Result = func(client RegistriesClient) (r Registry, err error) { 1550 var done bool 1551 done, err = future.DoneWithContext(context.Background(), client) 1552 if err != nil { 1553 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesUpdateFuture", "Result", future.Response(), "Polling failure") 1554 return 1555 } 1556 if !done { 1557 err = azure.NewAsyncOpIncompleteError("containerregistry.RegistriesUpdateFuture") 1558 return 1559 } 1560 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1561 if r.Response.Response, err = future.GetResult(sender); err == nil && r.Response.Response.StatusCode != http.StatusNoContent { 1562 r, err = client.UpdateResponder(r.Response.Response) 1563 if err != nil { 1564 err = autorest.NewErrorWithError(err, "containerregistry.RegistriesUpdateFuture", "Result", r.Response.Response, "Failure responding to request") 1565 } 1566 } 1567 return 1568 } 1569 return 1570} 1571 1572// UpdateResponder handles the response to the Update request. The method always 1573// closes the http.Response Body. 1574func (client RegistriesClient) UpdateResponder(resp *http.Response) (result Registry, err error) { 1575 err = autorest.Respond( 1576 resp, 1577 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 1578 autorest.ByUnmarshallingJSON(&result), 1579 autorest.ByClosing()) 1580 result.Response = autorest.Response{Response: resp} 1581 return 1582} 1583