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