1package devices 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// IotHubResourceClient is the use this API to manage the IoT hubs in your Azure subscription. 19type IotHubResourceClient struct { 20 BaseClient 21} 22 23// NewIotHubResourceClient creates an instance of the IotHubResourceClient client. 24func NewIotHubResourceClient(subscriptionID string) IotHubResourceClient { 25 return NewIotHubResourceClientWithBaseURI(DefaultBaseURI, subscriptionID) 26} 27 28// NewIotHubResourceClientWithBaseURI creates an instance of the IotHubResourceClient client using a custom endpoint. 29// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 30func NewIotHubResourceClientWithBaseURI(baseURI string, subscriptionID string) IotHubResourceClient { 31 return IotHubResourceClient{NewWithBaseURI(baseURI, subscriptionID)} 32} 33 34// CheckNameAvailability check if an IoT hub name is available. 35// Parameters: 36// operationInputs - set the name parameter in the OperationInputs structure to the name of the IoT hub to 37// check. 38func (client IotHubResourceClient) CheckNameAvailability(ctx context.Context, operationInputs OperationInputs) (result IotHubNameAvailabilityInfo, err error) { 39 if tracing.IsEnabled() { 40 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CheckNameAvailability") 41 defer func() { 42 sc := -1 43 if result.Response.Response != nil { 44 sc = result.Response.Response.StatusCode 45 } 46 tracing.EndSpan(ctx, sc, err) 47 }() 48 } 49 if err := validation.Validate([]validation.Validation{ 50 {TargetValue: operationInputs, 51 Constraints: []validation.Constraint{{Target: "operationInputs.Name", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 52 return result, validation.NewError("devices.IotHubResourceClient", "CheckNameAvailability", err.Error()) 53 } 54 55 req, err := client.CheckNameAvailabilityPreparer(ctx, operationInputs) 56 if err != nil { 57 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", nil, "Failure preparing request") 58 return 59 } 60 61 resp, err := client.CheckNameAvailabilitySender(req) 62 if err != nil { 63 result.Response = autorest.Response{Response: resp} 64 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", resp, "Failure sending request") 65 return 66 } 67 68 result, err = client.CheckNameAvailabilityResponder(resp) 69 if err != nil { 70 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", resp, "Failure responding to request") 71 return 72 } 73 74 return 75} 76 77// CheckNameAvailabilityPreparer prepares the CheckNameAvailability request. 78func (client IotHubResourceClient) CheckNameAvailabilityPreparer(ctx context.Context, operationInputs OperationInputs) (*http.Request, error) { 79 pathParameters := map[string]interface{}{ 80 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 81 } 82 83 const APIVersion = "2020-03-01" 84 queryParameters := map[string]interface{}{ 85 "api-version": APIVersion, 86 } 87 88 preparer := autorest.CreatePreparer( 89 autorest.AsContentType("application/json; charset=utf-8"), 90 autorest.AsPost(), 91 autorest.WithBaseURL(client.BaseURI), 92 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/checkNameAvailability", pathParameters), 93 autorest.WithJSON(operationInputs), 94 autorest.WithQueryParameters(queryParameters)) 95 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 96} 97 98// CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the 99// http.Response Body if it receives an error. 100func (client IotHubResourceClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { 101 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 102} 103 104// CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always 105// closes the http.Response Body. 106func (client IotHubResourceClient) CheckNameAvailabilityResponder(resp *http.Response) (result IotHubNameAvailabilityInfo, err error) { 107 err = autorest.Respond( 108 resp, 109 azure.WithErrorUnlessStatusCode(http.StatusOK), 110 autorest.ByUnmarshallingJSON(&result), 111 autorest.ByClosing()) 112 result.Response = autorest.Response{Response: resp} 113 return 114} 115 116// CreateEventHubConsumerGroup add a consumer group to an Event Hub-compatible endpoint in an IoT hub. 117// Parameters: 118// resourceGroupName - the name of the resource group that contains the IoT hub. 119// resourceName - the name of the IoT hub. 120// eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub. 121// name - the name of the consumer group to add. 122func (client IotHubResourceClient) CreateEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result EventHubConsumerGroupInfo, err error) { 123 if tracing.IsEnabled() { 124 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CreateEventHubConsumerGroup") 125 defer func() { 126 sc := -1 127 if result.Response.Response != nil { 128 sc = result.Response.Response.StatusCode 129 } 130 tracing.EndSpan(ctx, sc, err) 131 }() 132 } 133 req, err := client.CreateEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name) 134 if err != nil { 135 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", nil, "Failure preparing request") 136 return 137 } 138 139 resp, err := client.CreateEventHubConsumerGroupSender(req) 140 if err != nil { 141 result.Response = autorest.Response{Response: resp} 142 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", resp, "Failure sending request") 143 return 144 } 145 146 result, err = client.CreateEventHubConsumerGroupResponder(resp) 147 if err != nil { 148 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", resp, "Failure responding to request") 149 return 150 } 151 152 return 153} 154 155// CreateEventHubConsumerGroupPreparer prepares the CreateEventHubConsumerGroup request. 156func (client IotHubResourceClient) CreateEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) { 157 pathParameters := map[string]interface{}{ 158 "eventHubEndpointName": autorest.Encode("path", eventHubEndpointName), 159 "name": autorest.Encode("path", name), 160 "resourceGroupName": autorest.Encode("path", resourceGroupName), 161 "resourceName": autorest.Encode("path", resourceName), 162 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 163 } 164 165 const APIVersion = "2020-03-01" 166 queryParameters := map[string]interface{}{ 167 "api-version": APIVersion, 168 } 169 170 preparer := autorest.CreatePreparer( 171 autorest.AsPut(), 172 autorest.WithBaseURL(client.BaseURI), 173 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters), 174 autorest.WithQueryParameters(queryParameters)) 175 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 176} 177 178// CreateEventHubConsumerGroupSender sends the CreateEventHubConsumerGroup request. The method will close the 179// http.Response Body if it receives an error. 180func (client IotHubResourceClient) CreateEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) { 181 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 182} 183 184// CreateEventHubConsumerGroupResponder handles the response to the CreateEventHubConsumerGroup request. The method always 185// closes the http.Response Body. 186func (client IotHubResourceClient) CreateEventHubConsumerGroupResponder(resp *http.Response) (result EventHubConsumerGroupInfo, err error) { 187 err = autorest.Respond( 188 resp, 189 azure.WithErrorUnlessStatusCode(http.StatusOK), 190 autorest.ByUnmarshallingJSON(&result), 191 autorest.ByClosing()) 192 result.Response = autorest.Response{Response: resp} 193 return 194} 195 196// CreateOrUpdate create or update the metadata of an Iot hub. The usual pattern to modify a property is to retrieve 197// the IoT hub metadata and security metadata, and then combine them with the modified values in a new body to update 198// the IoT hub. 199// Parameters: 200// resourceGroupName - the name of the resource group that contains the IoT hub. 201// resourceName - the name of the IoT hub. 202// iotHubDescription - the IoT hub metadata and security metadata. 203// ifMatch - eTag of the IoT Hub. Do not specify for creating a brand new IoT Hub. Required to update an 204// existing IoT Hub. 205func (client IotHubResourceClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, iotHubDescription IotHubDescription, ifMatch string) (result IotHubResourceCreateOrUpdateFuture, err error) { 206 if tracing.IsEnabled() { 207 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CreateOrUpdate") 208 defer func() { 209 sc := -1 210 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 211 sc = result.FutureAPI.Response().StatusCode 212 } 213 tracing.EndSpan(ctx, sc, err) 214 }() 215 } 216 if err := validation.Validate([]validation.Validation{ 217 {TargetValue: iotHubDescription, 218 Constraints: []validation.Constraint{{Target: "iotHubDescription.Properties", Name: validation.Null, Rule: false, 219 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing", Name: validation.Null, Rule: false, 220 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute", Name: validation.Null, Rule: false, 221 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute.Source", Name: validation.Null, Rule: true, Chain: nil}, 222 {Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.Null, Rule: true, 223 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.MaxItems, Rule: 1, Chain: nil}, 224 {Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.MinItems, Rule: 1, Chain: nil}, 225 }}, 226 {Target: "iotHubDescription.Properties.Routing.FallbackRoute.IsEnabled", Name: validation.Null, Rule: true, Chain: nil}, 227 }}, 228 }}, 229 {Target: "iotHubDescription.Properties.CloudToDevice", Name: validation.Null, Rule: false, 230 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.Null, Rule: false, 231 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil}, 232 {Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}, 233 }}, 234 {Target: "iotHubDescription.Properties.CloudToDevice.Feedback", Name: validation.Null, Rule: false, 235 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.Null, Rule: false, 236 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil}, 237 {Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}, 238 }}, 239 }}, 240 }}, 241 }}, 242 {Target: "iotHubDescription.Sku", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 243 return result, validation.NewError("devices.IotHubResourceClient", "CreateOrUpdate", err.Error()) 244 } 245 246 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, resourceName, iotHubDescription, ifMatch) 247 if err != nil { 248 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateOrUpdate", nil, "Failure preparing request") 249 return 250 } 251 252 result, err = client.CreateOrUpdateSender(req) 253 if err != nil { 254 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateOrUpdate", nil, "Failure sending request") 255 return 256 } 257 258 return 259} 260 261// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 262func (client IotHubResourceClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, iotHubDescription IotHubDescription, ifMatch string) (*http.Request, error) { 263 pathParameters := map[string]interface{}{ 264 "resourceGroupName": autorest.Encode("path", resourceGroupName), 265 "resourceName": autorest.Encode("path", resourceName), 266 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 267 } 268 269 const APIVersion = "2020-03-01" 270 queryParameters := map[string]interface{}{ 271 "api-version": APIVersion, 272 } 273 274 preparer := autorest.CreatePreparer( 275 autorest.AsContentType("application/json; charset=utf-8"), 276 autorest.AsPut(), 277 autorest.WithBaseURL(client.BaseURI), 278 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters), 279 autorest.WithJSON(iotHubDescription), 280 autorest.WithQueryParameters(queryParameters)) 281 if len(ifMatch) > 0 { 282 preparer = autorest.DecoratePreparer(preparer, 283 autorest.WithHeader("If-Match", autorest.String(ifMatch))) 284 } 285 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 286} 287 288// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 289// http.Response Body if it receives an error. 290func (client IotHubResourceClient) CreateOrUpdateSender(req *http.Request) (future IotHubResourceCreateOrUpdateFuture, err error) { 291 var resp *http.Response 292 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 293 if err != nil { 294 return 295 } 296 var azf azure.Future 297 azf, err = azure.NewFutureFromResponse(resp) 298 future.FutureAPI = &azf 299 future.Result = future.result 300 return 301} 302 303// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 304// closes the http.Response Body. 305func (client IotHubResourceClient) CreateOrUpdateResponder(resp *http.Response) (result IotHubDescription, err error) { 306 err = autorest.Respond( 307 resp, 308 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 309 autorest.ByUnmarshallingJSON(&result), 310 autorest.ByClosing()) 311 result.Response = autorest.Response{Response: resp} 312 return 313} 314 315// Delete delete an IoT hub. 316// Parameters: 317// resourceGroupName - the name of the resource group that contains the IoT hub. 318// resourceName - the name of the IoT hub. 319func (client IotHubResourceClient) Delete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubResourceDeleteFuture, err error) { 320 if tracing.IsEnabled() { 321 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Delete") 322 defer func() { 323 sc := -1 324 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 325 sc = result.FutureAPI.Response().StatusCode 326 } 327 tracing.EndSpan(ctx, sc, err) 328 }() 329 } 330 req, err := client.DeletePreparer(ctx, resourceGroupName, resourceName) 331 if err != nil { 332 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Delete", nil, "Failure preparing request") 333 return 334 } 335 336 result, err = client.DeleteSender(req) 337 if err != nil { 338 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Delete", nil, "Failure sending request") 339 return 340 } 341 342 return 343} 344 345// DeletePreparer prepares the Delete request. 346func (client IotHubResourceClient) DeletePreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 347 pathParameters := map[string]interface{}{ 348 "resourceGroupName": autorest.Encode("path", resourceGroupName), 349 "resourceName": autorest.Encode("path", resourceName), 350 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 351 } 352 353 const APIVersion = "2020-03-01" 354 queryParameters := map[string]interface{}{ 355 "api-version": APIVersion, 356 } 357 358 preparer := autorest.CreatePreparer( 359 autorest.AsDelete(), 360 autorest.WithBaseURL(client.BaseURI), 361 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters), 362 autorest.WithQueryParameters(queryParameters)) 363 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 364} 365 366// DeleteSender sends the Delete request. The method will close the 367// http.Response Body if it receives an error. 368func (client IotHubResourceClient) DeleteSender(req *http.Request) (future IotHubResourceDeleteFuture, err error) { 369 var resp *http.Response 370 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 371 if err != nil { 372 return 373 } 374 var azf azure.Future 375 azf, err = azure.NewFutureFromResponse(resp) 376 future.FutureAPI = &azf 377 future.Result = future.result 378 return 379} 380 381// DeleteResponder handles the response to the Delete request. The method always 382// closes the http.Response Body. 383func (client IotHubResourceClient) DeleteResponder(resp *http.Response) (result SetObject, err error) { 384 err = autorest.Respond( 385 resp, 386 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent, http.StatusNotFound), 387 autorest.ByUnmarshallingJSON(&result), 388 autorest.ByClosing()) 389 result.Response = autorest.Response{Response: resp} 390 return 391} 392 393// DeleteEventHubConsumerGroup delete a consumer group from an Event Hub-compatible endpoint in an IoT hub. 394// Parameters: 395// resourceGroupName - the name of the resource group that contains the IoT hub. 396// resourceName - the name of the IoT hub. 397// eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub. 398// name - the name of the consumer group to delete. 399func (client IotHubResourceClient) DeleteEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result autorest.Response, err error) { 400 if tracing.IsEnabled() { 401 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.DeleteEventHubConsumerGroup") 402 defer func() { 403 sc := -1 404 if result.Response != nil { 405 sc = result.Response.StatusCode 406 } 407 tracing.EndSpan(ctx, sc, err) 408 }() 409 } 410 req, err := client.DeleteEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name) 411 if err != nil { 412 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", nil, "Failure preparing request") 413 return 414 } 415 416 resp, err := client.DeleteEventHubConsumerGroupSender(req) 417 if err != nil { 418 result.Response = resp 419 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", resp, "Failure sending request") 420 return 421 } 422 423 result, err = client.DeleteEventHubConsumerGroupResponder(resp) 424 if err != nil { 425 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", resp, "Failure responding to request") 426 return 427 } 428 429 return 430} 431 432// DeleteEventHubConsumerGroupPreparer prepares the DeleteEventHubConsumerGroup request. 433func (client IotHubResourceClient) DeleteEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) { 434 pathParameters := map[string]interface{}{ 435 "eventHubEndpointName": autorest.Encode("path", eventHubEndpointName), 436 "name": autorest.Encode("path", name), 437 "resourceGroupName": autorest.Encode("path", resourceGroupName), 438 "resourceName": autorest.Encode("path", resourceName), 439 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 440 } 441 442 const APIVersion = "2020-03-01" 443 queryParameters := map[string]interface{}{ 444 "api-version": APIVersion, 445 } 446 447 preparer := autorest.CreatePreparer( 448 autorest.AsDelete(), 449 autorest.WithBaseURL(client.BaseURI), 450 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters), 451 autorest.WithQueryParameters(queryParameters)) 452 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 453} 454 455// DeleteEventHubConsumerGroupSender sends the DeleteEventHubConsumerGroup request. The method will close the 456// http.Response Body if it receives an error. 457func (client IotHubResourceClient) DeleteEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) { 458 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 459} 460 461// DeleteEventHubConsumerGroupResponder handles the response to the DeleteEventHubConsumerGroup request. The method always 462// closes the http.Response Body. 463func (client IotHubResourceClient) DeleteEventHubConsumerGroupResponder(resp *http.Response) (result autorest.Response, err error) { 464 err = autorest.Respond( 465 resp, 466 azure.WithErrorUnlessStatusCode(http.StatusOK), 467 autorest.ByClosing()) 468 result.Response = resp 469 return 470} 471 472// ExportDevices exports all the device identities in the IoT hub identity registry to an Azure Storage blob container. 473// For more information, see: 474// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities. 475// Parameters: 476// resourceGroupName - the name of the resource group that contains the IoT hub. 477// resourceName - the name of the IoT hub. 478// exportDevicesParameters - the parameters that specify the export devices operation. 479func (client IotHubResourceClient) ExportDevices(ctx context.Context, resourceGroupName string, resourceName string, exportDevicesParameters ExportDevicesRequest) (result JobResponse, err error) { 480 if tracing.IsEnabled() { 481 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ExportDevices") 482 defer func() { 483 sc := -1 484 if result.Response.Response != nil { 485 sc = result.Response.Response.StatusCode 486 } 487 tracing.EndSpan(ctx, sc, err) 488 }() 489 } 490 if err := validation.Validate([]validation.Validation{ 491 {TargetValue: exportDevicesParameters, 492 Constraints: []validation.Constraint{{Target: "exportDevicesParameters.ExportBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil}, 493 {Target: "exportDevicesParameters.ExcludeKeys", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 494 return result, validation.NewError("devices.IotHubResourceClient", "ExportDevices", err.Error()) 495 } 496 497 req, err := client.ExportDevicesPreparer(ctx, resourceGroupName, resourceName, exportDevicesParameters) 498 if err != nil { 499 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", nil, "Failure preparing request") 500 return 501 } 502 503 resp, err := client.ExportDevicesSender(req) 504 if err != nil { 505 result.Response = autorest.Response{Response: resp} 506 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", resp, "Failure sending request") 507 return 508 } 509 510 result, err = client.ExportDevicesResponder(resp) 511 if err != nil { 512 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", resp, "Failure responding to request") 513 return 514 } 515 516 return 517} 518 519// ExportDevicesPreparer prepares the ExportDevices request. 520func (client IotHubResourceClient) ExportDevicesPreparer(ctx context.Context, resourceGroupName string, resourceName string, exportDevicesParameters ExportDevicesRequest) (*http.Request, error) { 521 pathParameters := map[string]interface{}{ 522 "resourceGroupName": autorest.Encode("path", resourceGroupName), 523 "resourceName": autorest.Encode("path", resourceName), 524 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 525 } 526 527 const APIVersion = "2020-03-01" 528 queryParameters := map[string]interface{}{ 529 "api-version": APIVersion, 530 } 531 532 preparer := autorest.CreatePreparer( 533 autorest.AsContentType("application/json; charset=utf-8"), 534 autorest.AsPost(), 535 autorest.WithBaseURL(client.BaseURI), 536 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/exportDevices", pathParameters), 537 autorest.WithJSON(exportDevicesParameters), 538 autorest.WithQueryParameters(queryParameters)) 539 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 540} 541 542// ExportDevicesSender sends the ExportDevices request. The method will close the 543// http.Response Body if it receives an error. 544func (client IotHubResourceClient) ExportDevicesSender(req *http.Request) (*http.Response, error) { 545 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 546} 547 548// ExportDevicesResponder handles the response to the ExportDevices request. The method always 549// closes the http.Response Body. 550func (client IotHubResourceClient) ExportDevicesResponder(resp *http.Response) (result JobResponse, err error) { 551 err = autorest.Respond( 552 resp, 553 azure.WithErrorUnlessStatusCode(http.StatusOK), 554 autorest.ByUnmarshallingJSON(&result), 555 autorest.ByClosing()) 556 result.Response = autorest.Response{Response: resp} 557 return 558} 559 560// Get get the non-security related metadata of an IoT hub. 561// Parameters: 562// resourceGroupName - the name of the resource group that contains the IoT hub. 563// resourceName - the name of the IoT hub. 564func (client IotHubResourceClient) Get(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubDescription, err error) { 565 if tracing.IsEnabled() { 566 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Get") 567 defer func() { 568 sc := -1 569 if result.Response.Response != nil { 570 sc = result.Response.Response.StatusCode 571 } 572 tracing.EndSpan(ctx, sc, err) 573 }() 574 } 575 req, err := client.GetPreparer(ctx, resourceGroupName, resourceName) 576 if err != nil { 577 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", nil, "Failure preparing request") 578 return 579 } 580 581 resp, err := client.GetSender(req) 582 if err != nil { 583 result.Response = autorest.Response{Response: resp} 584 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", resp, "Failure sending request") 585 return 586 } 587 588 result, err = client.GetResponder(resp) 589 if err != nil { 590 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", resp, "Failure responding to request") 591 return 592 } 593 594 return 595} 596 597// GetPreparer prepares the Get request. 598func (client IotHubResourceClient) GetPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 599 pathParameters := map[string]interface{}{ 600 "resourceGroupName": autorest.Encode("path", resourceGroupName), 601 "resourceName": autorest.Encode("path", resourceName), 602 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 603 } 604 605 const APIVersion = "2020-03-01" 606 queryParameters := map[string]interface{}{ 607 "api-version": APIVersion, 608 } 609 610 preparer := autorest.CreatePreparer( 611 autorest.AsGet(), 612 autorest.WithBaseURL(client.BaseURI), 613 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters), 614 autorest.WithQueryParameters(queryParameters)) 615 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 616} 617 618// GetSender sends the Get request. The method will close the 619// http.Response Body if it receives an error. 620func (client IotHubResourceClient) GetSender(req *http.Request) (*http.Response, error) { 621 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 622} 623 624// GetResponder handles the response to the Get request. The method always 625// closes the http.Response Body. 626func (client IotHubResourceClient) GetResponder(resp *http.Response) (result IotHubDescription, err error) { 627 err = autorest.Respond( 628 resp, 629 azure.WithErrorUnlessStatusCode(http.StatusOK), 630 autorest.ByUnmarshallingJSON(&result), 631 autorest.ByClosing()) 632 result.Response = autorest.Response{Response: resp} 633 return 634} 635 636// GetEndpointHealth get the health for routing endpoints. 637func (client IotHubResourceClient) GetEndpointHealth(ctx context.Context, resourceGroupName string, iotHubName string) (result EndpointHealthDataListResultPage, err error) { 638 if tracing.IsEnabled() { 639 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetEndpointHealth") 640 defer func() { 641 sc := -1 642 if result.ehdlr.Response.Response != nil { 643 sc = result.ehdlr.Response.Response.StatusCode 644 } 645 tracing.EndSpan(ctx, sc, err) 646 }() 647 } 648 result.fn = client.getEndpointHealthNextResults 649 req, err := client.GetEndpointHealthPreparer(ctx, resourceGroupName, iotHubName) 650 if err != nil { 651 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEndpointHealth", nil, "Failure preparing request") 652 return 653 } 654 655 resp, err := client.GetEndpointHealthSender(req) 656 if err != nil { 657 result.ehdlr.Response = autorest.Response{Response: resp} 658 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEndpointHealth", resp, "Failure sending request") 659 return 660 } 661 662 result.ehdlr, err = client.GetEndpointHealthResponder(resp) 663 if err != nil { 664 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEndpointHealth", resp, "Failure responding to request") 665 return 666 } 667 if result.ehdlr.hasNextLink() && result.ehdlr.IsEmpty() { 668 err = result.NextWithContext(ctx) 669 return 670 } 671 672 return 673} 674 675// GetEndpointHealthPreparer prepares the GetEndpointHealth request. 676func (client IotHubResourceClient) GetEndpointHealthPreparer(ctx context.Context, resourceGroupName string, iotHubName string) (*http.Request, error) { 677 pathParameters := map[string]interface{}{ 678 "iotHubName": autorest.Encode("path", iotHubName), 679 "resourceGroupName": autorest.Encode("path", resourceGroupName), 680 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 681 } 682 683 const APIVersion = "2020-03-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.Devices/IotHubs/{iotHubName}/routingEndpointsHealth", pathParameters), 692 autorest.WithQueryParameters(queryParameters)) 693 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 694} 695 696// GetEndpointHealthSender sends the GetEndpointHealth request. The method will close the 697// http.Response Body if it receives an error. 698func (client IotHubResourceClient) GetEndpointHealthSender(req *http.Request) (*http.Response, error) { 699 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 700} 701 702// GetEndpointHealthResponder handles the response to the GetEndpointHealth request. The method always 703// closes the http.Response Body. 704func (client IotHubResourceClient) GetEndpointHealthResponder(resp *http.Response) (result EndpointHealthDataListResult, 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// getEndpointHealthNextResults retrieves the next set of results, if any. 715func (client IotHubResourceClient) getEndpointHealthNextResults(ctx context.Context, lastResults EndpointHealthDataListResult) (result EndpointHealthDataListResult, err error) { 716 req, err := lastResults.endpointHealthDataListResultPreparer(ctx) 717 if err != nil { 718 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getEndpointHealthNextResults", nil, "Failure preparing next results request") 719 } 720 if req == nil { 721 return 722 } 723 resp, err := client.GetEndpointHealthSender(req) 724 if err != nil { 725 result.Response = autorest.Response{Response: resp} 726 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getEndpointHealthNextResults", resp, "Failure sending next results request") 727 } 728 result, err = client.GetEndpointHealthResponder(resp) 729 if err != nil { 730 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getEndpointHealthNextResults", resp, "Failure responding to next results request") 731 } 732 return 733} 734 735// GetEndpointHealthComplete enumerates all values, automatically crossing page boundaries as required. 736func (client IotHubResourceClient) GetEndpointHealthComplete(ctx context.Context, resourceGroupName string, iotHubName string) (result EndpointHealthDataListResultIterator, err error) { 737 if tracing.IsEnabled() { 738 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetEndpointHealth") 739 defer func() { 740 sc := -1 741 if result.Response().Response.Response != nil { 742 sc = result.page.Response().Response.Response.StatusCode 743 } 744 tracing.EndSpan(ctx, sc, err) 745 }() 746 } 747 result.page, err = client.GetEndpointHealth(ctx, resourceGroupName, iotHubName) 748 return 749} 750 751// GetEventHubConsumerGroup get a consumer group from the Event Hub-compatible device-to-cloud endpoint for an IoT hub. 752// Parameters: 753// resourceGroupName - the name of the resource group that contains the IoT hub. 754// resourceName - the name of the IoT hub. 755// eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub. 756// name - the name of the consumer group to retrieve. 757func (client IotHubResourceClient) GetEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result EventHubConsumerGroupInfo, err error) { 758 if tracing.IsEnabled() { 759 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetEventHubConsumerGroup") 760 defer func() { 761 sc := -1 762 if result.Response.Response != nil { 763 sc = result.Response.Response.StatusCode 764 } 765 tracing.EndSpan(ctx, sc, err) 766 }() 767 } 768 req, err := client.GetEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name) 769 if err != nil { 770 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", nil, "Failure preparing request") 771 return 772 } 773 774 resp, err := client.GetEventHubConsumerGroupSender(req) 775 if err != nil { 776 result.Response = autorest.Response{Response: resp} 777 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", resp, "Failure sending request") 778 return 779 } 780 781 result, err = client.GetEventHubConsumerGroupResponder(resp) 782 if err != nil { 783 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", resp, "Failure responding to request") 784 return 785 } 786 787 return 788} 789 790// GetEventHubConsumerGroupPreparer prepares the GetEventHubConsumerGroup request. 791func (client IotHubResourceClient) GetEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) { 792 pathParameters := map[string]interface{}{ 793 "eventHubEndpointName": autorest.Encode("path", eventHubEndpointName), 794 "name": autorest.Encode("path", name), 795 "resourceGroupName": autorest.Encode("path", resourceGroupName), 796 "resourceName": autorest.Encode("path", resourceName), 797 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 798 } 799 800 const APIVersion = "2020-03-01" 801 queryParameters := map[string]interface{}{ 802 "api-version": APIVersion, 803 } 804 805 preparer := autorest.CreatePreparer( 806 autorest.AsGet(), 807 autorest.WithBaseURL(client.BaseURI), 808 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters), 809 autorest.WithQueryParameters(queryParameters)) 810 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 811} 812 813// GetEventHubConsumerGroupSender sends the GetEventHubConsumerGroup request. The method will close the 814// http.Response Body if it receives an error. 815func (client IotHubResourceClient) GetEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) { 816 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 817} 818 819// GetEventHubConsumerGroupResponder handles the response to the GetEventHubConsumerGroup request. The method always 820// closes the http.Response Body. 821func (client IotHubResourceClient) GetEventHubConsumerGroupResponder(resp *http.Response) (result EventHubConsumerGroupInfo, err error) { 822 err = autorest.Respond( 823 resp, 824 azure.WithErrorUnlessStatusCode(http.StatusOK), 825 autorest.ByUnmarshallingJSON(&result), 826 autorest.ByClosing()) 827 result.Response = autorest.Response{Response: resp} 828 return 829} 830 831// GetJob get the details of a job from an IoT hub. For more information, see: 832// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry. 833// Parameters: 834// resourceGroupName - the name of the resource group that contains the IoT hub. 835// resourceName - the name of the IoT hub. 836// jobID - the job identifier. 837func (client IotHubResourceClient) GetJob(ctx context.Context, resourceGroupName string, resourceName string, jobID string) (result JobResponse, err error) { 838 if tracing.IsEnabled() { 839 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetJob") 840 defer func() { 841 sc := -1 842 if result.Response.Response != nil { 843 sc = result.Response.Response.StatusCode 844 } 845 tracing.EndSpan(ctx, sc, err) 846 }() 847 } 848 req, err := client.GetJobPreparer(ctx, resourceGroupName, resourceName, jobID) 849 if err != nil { 850 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", nil, "Failure preparing request") 851 return 852 } 853 854 resp, err := client.GetJobSender(req) 855 if err != nil { 856 result.Response = autorest.Response{Response: resp} 857 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", resp, "Failure sending request") 858 return 859 } 860 861 result, err = client.GetJobResponder(resp) 862 if err != nil { 863 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", resp, "Failure responding to request") 864 return 865 } 866 867 return 868} 869 870// GetJobPreparer prepares the GetJob request. 871func (client IotHubResourceClient) GetJobPreparer(ctx context.Context, resourceGroupName string, resourceName string, jobID string) (*http.Request, error) { 872 pathParameters := map[string]interface{}{ 873 "jobId": autorest.Encode("path", jobID), 874 "resourceGroupName": autorest.Encode("path", resourceGroupName), 875 "resourceName": autorest.Encode("path", resourceName), 876 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 877 } 878 879 const APIVersion = "2020-03-01" 880 queryParameters := map[string]interface{}{ 881 "api-version": APIVersion, 882 } 883 884 preparer := autorest.CreatePreparer( 885 autorest.AsGet(), 886 autorest.WithBaseURL(client.BaseURI), 887 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/jobs/{jobId}", pathParameters), 888 autorest.WithQueryParameters(queryParameters)) 889 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 890} 891 892// GetJobSender sends the GetJob request. The method will close the 893// http.Response Body if it receives an error. 894func (client IotHubResourceClient) GetJobSender(req *http.Request) (*http.Response, error) { 895 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 896} 897 898// GetJobResponder handles the response to the GetJob request. The method always 899// closes the http.Response Body. 900func (client IotHubResourceClient) GetJobResponder(resp *http.Response) (result JobResponse, err error) { 901 err = autorest.Respond( 902 resp, 903 azure.WithErrorUnlessStatusCode(http.StatusOK), 904 autorest.ByUnmarshallingJSON(&result), 905 autorest.ByClosing()) 906 result.Response = autorest.Response{Response: resp} 907 return 908} 909 910// GetKeysForKeyName get a shared access policy by name from an IoT hub. For more information, see: 911// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-security. 912// Parameters: 913// resourceGroupName - the name of the resource group that contains the IoT hub. 914// resourceName - the name of the IoT hub. 915// keyName - the name of the shared access policy. 916func (client IotHubResourceClient) GetKeysForKeyName(ctx context.Context, resourceGroupName string, resourceName string, keyName string) (result SharedAccessSignatureAuthorizationRule, err error) { 917 if tracing.IsEnabled() { 918 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetKeysForKeyName") 919 defer func() { 920 sc := -1 921 if result.Response.Response != nil { 922 sc = result.Response.Response.StatusCode 923 } 924 tracing.EndSpan(ctx, sc, err) 925 }() 926 } 927 req, err := client.GetKeysForKeyNamePreparer(ctx, resourceGroupName, resourceName, keyName) 928 if err != nil { 929 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", nil, "Failure preparing request") 930 return 931 } 932 933 resp, err := client.GetKeysForKeyNameSender(req) 934 if err != nil { 935 result.Response = autorest.Response{Response: resp} 936 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", resp, "Failure sending request") 937 return 938 } 939 940 result, err = client.GetKeysForKeyNameResponder(resp) 941 if err != nil { 942 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", resp, "Failure responding to request") 943 return 944 } 945 946 return 947} 948 949// GetKeysForKeyNamePreparer prepares the GetKeysForKeyName request. 950func (client IotHubResourceClient) GetKeysForKeyNamePreparer(ctx context.Context, resourceGroupName string, resourceName string, keyName string) (*http.Request, error) { 951 pathParameters := map[string]interface{}{ 952 "keyName": autorest.Encode("path", keyName), 953 "resourceGroupName": autorest.Encode("path", resourceGroupName), 954 "resourceName": autorest.Encode("path", resourceName), 955 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 956 } 957 958 const APIVersion = "2020-03-01" 959 queryParameters := map[string]interface{}{ 960 "api-version": APIVersion, 961 } 962 963 preparer := autorest.CreatePreparer( 964 autorest.AsPost(), 965 autorest.WithBaseURL(client.BaseURI), 966 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/IotHubKeys/{keyName}/listkeys", pathParameters), 967 autorest.WithQueryParameters(queryParameters)) 968 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 969} 970 971// GetKeysForKeyNameSender sends the GetKeysForKeyName request. The method will close the 972// http.Response Body if it receives an error. 973func (client IotHubResourceClient) GetKeysForKeyNameSender(req *http.Request) (*http.Response, error) { 974 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 975} 976 977// GetKeysForKeyNameResponder handles the response to the GetKeysForKeyName request. The method always 978// closes the http.Response Body. 979func (client IotHubResourceClient) GetKeysForKeyNameResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRule, err error) { 980 err = autorest.Respond( 981 resp, 982 azure.WithErrorUnlessStatusCode(http.StatusOK), 983 autorest.ByUnmarshallingJSON(&result), 984 autorest.ByClosing()) 985 result.Response = autorest.Response{Response: resp} 986 return 987} 988 989// GetQuotaMetrics get the quota metrics for an IoT hub. 990// Parameters: 991// resourceGroupName - the name of the resource group that contains the IoT hub. 992// resourceName - the name of the IoT hub. 993func (client IotHubResourceClient) GetQuotaMetrics(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubQuotaMetricInfoListResultPage, err error) { 994 if tracing.IsEnabled() { 995 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetQuotaMetrics") 996 defer func() { 997 sc := -1 998 if result.ihqmilr.Response.Response != nil { 999 sc = result.ihqmilr.Response.Response.StatusCode 1000 } 1001 tracing.EndSpan(ctx, sc, err) 1002 }() 1003 } 1004 result.fn = client.getQuotaMetricsNextResults 1005 req, err := client.GetQuotaMetricsPreparer(ctx, resourceGroupName, resourceName) 1006 if err != nil { 1007 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", nil, "Failure preparing request") 1008 return 1009 } 1010 1011 resp, err := client.GetQuotaMetricsSender(req) 1012 if err != nil { 1013 result.ihqmilr.Response = autorest.Response{Response: resp} 1014 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", resp, "Failure sending request") 1015 return 1016 } 1017 1018 result.ihqmilr, err = client.GetQuotaMetricsResponder(resp) 1019 if err != nil { 1020 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", resp, "Failure responding to request") 1021 return 1022 } 1023 if result.ihqmilr.hasNextLink() && result.ihqmilr.IsEmpty() { 1024 err = result.NextWithContext(ctx) 1025 return 1026 } 1027 1028 return 1029} 1030 1031// GetQuotaMetricsPreparer prepares the GetQuotaMetrics request. 1032func (client IotHubResourceClient) GetQuotaMetricsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1033 pathParameters := map[string]interface{}{ 1034 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1035 "resourceName": autorest.Encode("path", resourceName), 1036 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1037 } 1038 1039 const APIVersion = "2020-03-01" 1040 queryParameters := map[string]interface{}{ 1041 "api-version": APIVersion, 1042 } 1043 1044 preparer := autorest.CreatePreparer( 1045 autorest.AsGet(), 1046 autorest.WithBaseURL(client.BaseURI), 1047 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/quotaMetrics", pathParameters), 1048 autorest.WithQueryParameters(queryParameters)) 1049 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1050} 1051 1052// GetQuotaMetricsSender sends the GetQuotaMetrics request. The method will close the 1053// http.Response Body if it receives an error. 1054func (client IotHubResourceClient) GetQuotaMetricsSender(req *http.Request) (*http.Response, error) { 1055 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1056} 1057 1058// GetQuotaMetricsResponder handles the response to the GetQuotaMetrics request. The method always 1059// closes the http.Response Body. 1060func (client IotHubResourceClient) GetQuotaMetricsResponder(resp *http.Response) (result IotHubQuotaMetricInfoListResult, err error) { 1061 err = autorest.Respond( 1062 resp, 1063 azure.WithErrorUnlessStatusCode(http.StatusOK), 1064 autorest.ByUnmarshallingJSON(&result), 1065 autorest.ByClosing()) 1066 result.Response = autorest.Response{Response: resp} 1067 return 1068} 1069 1070// getQuotaMetricsNextResults retrieves the next set of results, if any. 1071func (client IotHubResourceClient) getQuotaMetricsNextResults(ctx context.Context, lastResults IotHubQuotaMetricInfoListResult) (result IotHubQuotaMetricInfoListResult, err error) { 1072 req, err := lastResults.iotHubQuotaMetricInfoListResultPreparer(ctx) 1073 if err != nil { 1074 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", nil, "Failure preparing next results request") 1075 } 1076 if req == nil { 1077 return 1078 } 1079 resp, err := client.GetQuotaMetricsSender(req) 1080 if err != nil { 1081 result.Response = autorest.Response{Response: resp} 1082 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", resp, "Failure sending next results request") 1083 } 1084 result, err = client.GetQuotaMetricsResponder(resp) 1085 if err != nil { 1086 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", resp, "Failure responding to next results request") 1087 } 1088 return 1089} 1090 1091// GetQuotaMetricsComplete enumerates all values, automatically crossing page boundaries as required. 1092func (client IotHubResourceClient) GetQuotaMetricsComplete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubQuotaMetricInfoListResultIterator, err error) { 1093 if tracing.IsEnabled() { 1094 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetQuotaMetrics") 1095 defer func() { 1096 sc := -1 1097 if result.Response().Response.Response != nil { 1098 sc = result.page.Response().Response.Response.StatusCode 1099 } 1100 tracing.EndSpan(ctx, sc, err) 1101 }() 1102 } 1103 result.page, err = client.GetQuotaMetrics(ctx, resourceGroupName, resourceName) 1104 return 1105} 1106 1107// GetStats get the statistics from an IoT hub. 1108// Parameters: 1109// resourceGroupName - the name of the resource group that contains the IoT hub. 1110// resourceName - the name of the IoT hub. 1111func (client IotHubResourceClient) GetStats(ctx context.Context, resourceGroupName string, resourceName string) (result RegistryStatistics, err error) { 1112 if tracing.IsEnabled() { 1113 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetStats") 1114 defer func() { 1115 sc := -1 1116 if result.Response.Response != nil { 1117 sc = result.Response.Response.StatusCode 1118 } 1119 tracing.EndSpan(ctx, sc, err) 1120 }() 1121 } 1122 req, err := client.GetStatsPreparer(ctx, resourceGroupName, resourceName) 1123 if err != nil { 1124 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", nil, "Failure preparing request") 1125 return 1126 } 1127 1128 resp, err := client.GetStatsSender(req) 1129 if err != nil { 1130 result.Response = autorest.Response{Response: resp} 1131 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", resp, "Failure sending request") 1132 return 1133 } 1134 1135 result, err = client.GetStatsResponder(resp) 1136 if err != nil { 1137 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", resp, "Failure responding to request") 1138 return 1139 } 1140 1141 return 1142} 1143 1144// GetStatsPreparer prepares the GetStats request. 1145func (client IotHubResourceClient) GetStatsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1146 pathParameters := map[string]interface{}{ 1147 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1148 "resourceName": autorest.Encode("path", resourceName), 1149 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1150 } 1151 1152 const APIVersion = "2020-03-01" 1153 queryParameters := map[string]interface{}{ 1154 "api-version": APIVersion, 1155 } 1156 1157 preparer := autorest.CreatePreparer( 1158 autorest.AsGet(), 1159 autorest.WithBaseURL(client.BaseURI), 1160 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/IotHubStats", pathParameters), 1161 autorest.WithQueryParameters(queryParameters)) 1162 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1163} 1164 1165// GetStatsSender sends the GetStats request. The method will close the 1166// http.Response Body if it receives an error. 1167func (client IotHubResourceClient) GetStatsSender(req *http.Request) (*http.Response, error) { 1168 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1169} 1170 1171// GetStatsResponder handles the response to the GetStats request. The method always 1172// closes the http.Response Body. 1173func (client IotHubResourceClient) GetStatsResponder(resp *http.Response) (result RegistryStatistics, err error) { 1174 err = autorest.Respond( 1175 resp, 1176 azure.WithErrorUnlessStatusCode(http.StatusOK), 1177 autorest.ByUnmarshallingJSON(&result), 1178 autorest.ByClosing()) 1179 result.Response = autorest.Response{Response: resp} 1180 return 1181} 1182 1183// GetValidSkus get the list of valid SKUs for an IoT hub. 1184// Parameters: 1185// resourceGroupName - the name of the resource group that contains the IoT hub. 1186// resourceName - the name of the IoT hub. 1187func (client IotHubResourceClient) GetValidSkus(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubSkuDescriptionListResultPage, err error) { 1188 if tracing.IsEnabled() { 1189 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetValidSkus") 1190 defer func() { 1191 sc := -1 1192 if result.ihsdlr.Response.Response != nil { 1193 sc = result.ihsdlr.Response.Response.StatusCode 1194 } 1195 tracing.EndSpan(ctx, sc, err) 1196 }() 1197 } 1198 result.fn = client.getValidSkusNextResults 1199 req, err := client.GetValidSkusPreparer(ctx, resourceGroupName, resourceName) 1200 if err != nil { 1201 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", nil, "Failure preparing request") 1202 return 1203 } 1204 1205 resp, err := client.GetValidSkusSender(req) 1206 if err != nil { 1207 result.ihsdlr.Response = autorest.Response{Response: resp} 1208 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", resp, "Failure sending request") 1209 return 1210 } 1211 1212 result.ihsdlr, err = client.GetValidSkusResponder(resp) 1213 if err != nil { 1214 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", resp, "Failure responding to request") 1215 return 1216 } 1217 if result.ihsdlr.hasNextLink() && result.ihsdlr.IsEmpty() { 1218 err = result.NextWithContext(ctx) 1219 return 1220 } 1221 1222 return 1223} 1224 1225// GetValidSkusPreparer prepares the GetValidSkus request. 1226func (client IotHubResourceClient) GetValidSkusPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1227 pathParameters := map[string]interface{}{ 1228 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1229 "resourceName": autorest.Encode("path", resourceName), 1230 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1231 } 1232 1233 const APIVersion = "2020-03-01" 1234 queryParameters := map[string]interface{}{ 1235 "api-version": APIVersion, 1236 } 1237 1238 preparer := autorest.CreatePreparer( 1239 autorest.AsGet(), 1240 autorest.WithBaseURL(client.BaseURI), 1241 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/skus", pathParameters), 1242 autorest.WithQueryParameters(queryParameters)) 1243 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1244} 1245 1246// GetValidSkusSender sends the GetValidSkus request. The method will close the 1247// http.Response Body if it receives an error. 1248func (client IotHubResourceClient) GetValidSkusSender(req *http.Request) (*http.Response, error) { 1249 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1250} 1251 1252// GetValidSkusResponder handles the response to the GetValidSkus request. The method always 1253// closes the http.Response Body. 1254func (client IotHubResourceClient) GetValidSkusResponder(resp *http.Response) (result IotHubSkuDescriptionListResult, err error) { 1255 err = autorest.Respond( 1256 resp, 1257 azure.WithErrorUnlessStatusCode(http.StatusOK), 1258 autorest.ByUnmarshallingJSON(&result), 1259 autorest.ByClosing()) 1260 result.Response = autorest.Response{Response: resp} 1261 return 1262} 1263 1264// getValidSkusNextResults retrieves the next set of results, if any. 1265func (client IotHubResourceClient) getValidSkusNextResults(ctx context.Context, lastResults IotHubSkuDescriptionListResult) (result IotHubSkuDescriptionListResult, err error) { 1266 req, err := lastResults.iotHubSkuDescriptionListResultPreparer(ctx) 1267 if err != nil { 1268 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", nil, "Failure preparing next results request") 1269 } 1270 if req == nil { 1271 return 1272 } 1273 resp, err := client.GetValidSkusSender(req) 1274 if err != nil { 1275 result.Response = autorest.Response{Response: resp} 1276 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", resp, "Failure sending next results request") 1277 } 1278 result, err = client.GetValidSkusResponder(resp) 1279 if err != nil { 1280 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", resp, "Failure responding to next results request") 1281 } 1282 return 1283} 1284 1285// GetValidSkusComplete enumerates all values, automatically crossing page boundaries as required. 1286func (client IotHubResourceClient) GetValidSkusComplete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubSkuDescriptionListResultIterator, err error) { 1287 if tracing.IsEnabled() { 1288 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetValidSkus") 1289 defer func() { 1290 sc := -1 1291 if result.Response().Response.Response != nil { 1292 sc = result.page.Response().Response.Response.StatusCode 1293 } 1294 tracing.EndSpan(ctx, sc, err) 1295 }() 1296 } 1297 result.page, err = client.GetValidSkus(ctx, resourceGroupName, resourceName) 1298 return 1299} 1300 1301// ImportDevices import, update, or delete device identities in the IoT hub identity registry from a blob. For more 1302// information, see: 1303// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities. 1304// Parameters: 1305// resourceGroupName - the name of the resource group that contains the IoT hub. 1306// resourceName - the name of the IoT hub. 1307// importDevicesParameters - the parameters that specify the import devices operation. 1308func (client IotHubResourceClient) ImportDevices(ctx context.Context, resourceGroupName string, resourceName string, importDevicesParameters ImportDevicesRequest) (result JobResponse, err error) { 1309 if tracing.IsEnabled() { 1310 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ImportDevices") 1311 defer func() { 1312 sc := -1 1313 if result.Response.Response != nil { 1314 sc = result.Response.Response.StatusCode 1315 } 1316 tracing.EndSpan(ctx, sc, err) 1317 }() 1318 } 1319 if err := validation.Validate([]validation.Validation{ 1320 {TargetValue: importDevicesParameters, 1321 Constraints: []validation.Constraint{{Target: "importDevicesParameters.InputBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil}, 1322 {Target: "importDevicesParameters.OutputBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 1323 return result, validation.NewError("devices.IotHubResourceClient", "ImportDevices", err.Error()) 1324 } 1325 1326 req, err := client.ImportDevicesPreparer(ctx, resourceGroupName, resourceName, importDevicesParameters) 1327 if err != nil { 1328 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", nil, "Failure preparing request") 1329 return 1330 } 1331 1332 resp, err := client.ImportDevicesSender(req) 1333 if err != nil { 1334 result.Response = autorest.Response{Response: resp} 1335 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", resp, "Failure sending request") 1336 return 1337 } 1338 1339 result, err = client.ImportDevicesResponder(resp) 1340 if err != nil { 1341 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", resp, "Failure responding to request") 1342 return 1343 } 1344 1345 return 1346} 1347 1348// ImportDevicesPreparer prepares the ImportDevices request. 1349func (client IotHubResourceClient) ImportDevicesPreparer(ctx context.Context, resourceGroupName string, resourceName string, importDevicesParameters ImportDevicesRequest) (*http.Request, error) { 1350 pathParameters := map[string]interface{}{ 1351 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1352 "resourceName": autorest.Encode("path", resourceName), 1353 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1354 } 1355 1356 const APIVersion = "2020-03-01" 1357 queryParameters := map[string]interface{}{ 1358 "api-version": APIVersion, 1359 } 1360 1361 preparer := autorest.CreatePreparer( 1362 autorest.AsContentType("application/json; charset=utf-8"), 1363 autorest.AsPost(), 1364 autorest.WithBaseURL(client.BaseURI), 1365 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/importDevices", pathParameters), 1366 autorest.WithJSON(importDevicesParameters), 1367 autorest.WithQueryParameters(queryParameters)) 1368 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1369} 1370 1371// ImportDevicesSender sends the ImportDevices request. The method will close the 1372// http.Response Body if it receives an error. 1373func (client IotHubResourceClient) ImportDevicesSender(req *http.Request) (*http.Response, error) { 1374 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1375} 1376 1377// ImportDevicesResponder handles the response to the ImportDevices request. The method always 1378// closes the http.Response Body. 1379func (client IotHubResourceClient) ImportDevicesResponder(resp *http.Response) (result JobResponse, err error) { 1380 err = autorest.Respond( 1381 resp, 1382 azure.WithErrorUnlessStatusCode(http.StatusOK), 1383 autorest.ByUnmarshallingJSON(&result), 1384 autorest.ByClosing()) 1385 result.Response = autorest.Response{Response: resp} 1386 return 1387} 1388 1389// ListByResourceGroup get all the IoT hubs in a resource group. 1390// Parameters: 1391// resourceGroupName - the name of the resource group that contains the IoT hub. 1392func (client IotHubResourceClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result IotHubDescriptionListResultPage, err error) { 1393 if tracing.IsEnabled() { 1394 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListByResourceGroup") 1395 defer func() { 1396 sc := -1 1397 if result.ihdlr.Response.Response != nil { 1398 sc = result.ihdlr.Response.Response.StatusCode 1399 } 1400 tracing.EndSpan(ctx, sc, err) 1401 }() 1402 } 1403 result.fn = client.listByResourceGroupNextResults 1404 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 1405 if err != nil { 1406 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", nil, "Failure preparing request") 1407 return 1408 } 1409 1410 resp, err := client.ListByResourceGroupSender(req) 1411 if err != nil { 1412 result.ihdlr.Response = autorest.Response{Response: resp} 1413 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", resp, "Failure sending request") 1414 return 1415 } 1416 1417 result.ihdlr, err = client.ListByResourceGroupResponder(resp) 1418 if err != nil { 1419 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", resp, "Failure responding to request") 1420 return 1421 } 1422 if result.ihdlr.hasNextLink() && result.ihdlr.IsEmpty() { 1423 err = result.NextWithContext(ctx) 1424 return 1425 } 1426 1427 return 1428} 1429 1430// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 1431func (client IotHubResourceClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 1432 pathParameters := map[string]interface{}{ 1433 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1434 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1435 } 1436 1437 const APIVersion = "2020-03-01" 1438 queryParameters := map[string]interface{}{ 1439 "api-version": APIVersion, 1440 } 1441 1442 preparer := autorest.CreatePreparer( 1443 autorest.AsGet(), 1444 autorest.WithBaseURL(client.BaseURI), 1445 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs", pathParameters), 1446 autorest.WithQueryParameters(queryParameters)) 1447 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1448} 1449 1450// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 1451// http.Response Body if it receives an error. 1452func (client IotHubResourceClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 1453 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1454} 1455 1456// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 1457// closes the http.Response Body. 1458func (client IotHubResourceClient) ListByResourceGroupResponder(resp *http.Response) (result IotHubDescriptionListResult, err error) { 1459 err = autorest.Respond( 1460 resp, 1461 azure.WithErrorUnlessStatusCode(http.StatusOK), 1462 autorest.ByUnmarshallingJSON(&result), 1463 autorest.ByClosing()) 1464 result.Response = autorest.Response{Response: resp} 1465 return 1466} 1467 1468// listByResourceGroupNextResults retrieves the next set of results, if any. 1469func (client IotHubResourceClient) listByResourceGroupNextResults(ctx context.Context, lastResults IotHubDescriptionListResult) (result IotHubDescriptionListResult, err error) { 1470 req, err := lastResults.iotHubDescriptionListResultPreparer(ctx) 1471 if err != nil { 1472 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 1473 } 1474 if req == nil { 1475 return 1476 } 1477 resp, err := client.ListByResourceGroupSender(req) 1478 if err != nil { 1479 result.Response = autorest.Response{Response: resp} 1480 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 1481 } 1482 result, err = client.ListByResourceGroupResponder(resp) 1483 if err != nil { 1484 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 1485 } 1486 return 1487} 1488 1489// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 1490func (client IotHubResourceClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result IotHubDescriptionListResultIterator, err error) { 1491 if tracing.IsEnabled() { 1492 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListByResourceGroup") 1493 defer func() { 1494 sc := -1 1495 if result.Response().Response.Response != nil { 1496 sc = result.page.Response().Response.Response.StatusCode 1497 } 1498 tracing.EndSpan(ctx, sc, err) 1499 }() 1500 } 1501 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 1502 return 1503} 1504 1505// ListBySubscription get all the IoT hubs in a subscription. 1506func (client IotHubResourceClient) ListBySubscription(ctx context.Context) (result IotHubDescriptionListResultPage, err error) { 1507 if tracing.IsEnabled() { 1508 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListBySubscription") 1509 defer func() { 1510 sc := -1 1511 if result.ihdlr.Response.Response != nil { 1512 sc = result.ihdlr.Response.Response.StatusCode 1513 } 1514 tracing.EndSpan(ctx, sc, err) 1515 }() 1516 } 1517 result.fn = client.listBySubscriptionNextResults 1518 req, err := client.ListBySubscriptionPreparer(ctx) 1519 if err != nil { 1520 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", nil, "Failure preparing request") 1521 return 1522 } 1523 1524 resp, err := client.ListBySubscriptionSender(req) 1525 if err != nil { 1526 result.ihdlr.Response = autorest.Response{Response: resp} 1527 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", resp, "Failure sending request") 1528 return 1529 } 1530 1531 result.ihdlr, err = client.ListBySubscriptionResponder(resp) 1532 if err != nil { 1533 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", resp, "Failure responding to request") 1534 return 1535 } 1536 if result.ihdlr.hasNextLink() && result.ihdlr.IsEmpty() { 1537 err = result.NextWithContext(ctx) 1538 return 1539 } 1540 1541 return 1542} 1543 1544// ListBySubscriptionPreparer prepares the ListBySubscription request. 1545func (client IotHubResourceClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) { 1546 pathParameters := map[string]interface{}{ 1547 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1548 } 1549 1550 const APIVersion = "2020-03-01" 1551 queryParameters := map[string]interface{}{ 1552 "api-version": APIVersion, 1553 } 1554 1555 preparer := autorest.CreatePreparer( 1556 autorest.AsGet(), 1557 autorest.WithBaseURL(client.BaseURI), 1558 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/IotHubs", pathParameters), 1559 autorest.WithQueryParameters(queryParameters)) 1560 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1561} 1562 1563// ListBySubscriptionSender sends the ListBySubscription request. The method will close the 1564// http.Response Body if it receives an error. 1565func (client IotHubResourceClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { 1566 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1567} 1568 1569// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always 1570// closes the http.Response Body. 1571func (client IotHubResourceClient) ListBySubscriptionResponder(resp *http.Response) (result IotHubDescriptionListResult, err error) { 1572 err = autorest.Respond( 1573 resp, 1574 azure.WithErrorUnlessStatusCode(http.StatusOK), 1575 autorest.ByUnmarshallingJSON(&result), 1576 autorest.ByClosing()) 1577 result.Response = autorest.Response{Response: resp} 1578 return 1579} 1580 1581// listBySubscriptionNextResults retrieves the next set of results, if any. 1582func (client IotHubResourceClient) listBySubscriptionNextResults(ctx context.Context, lastResults IotHubDescriptionListResult) (result IotHubDescriptionListResult, err error) { 1583 req, err := lastResults.iotHubDescriptionListResultPreparer(ctx) 1584 if err != nil { 1585 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request") 1586 } 1587 if req == nil { 1588 return 1589 } 1590 resp, err := client.ListBySubscriptionSender(req) 1591 if err != nil { 1592 result.Response = autorest.Response{Response: resp} 1593 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", resp, "Failure sending next results request") 1594 } 1595 result, err = client.ListBySubscriptionResponder(resp) 1596 if err != nil { 1597 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request") 1598 } 1599 return 1600} 1601 1602// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required. 1603func (client IotHubResourceClient) ListBySubscriptionComplete(ctx context.Context) (result IotHubDescriptionListResultIterator, err error) { 1604 if tracing.IsEnabled() { 1605 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListBySubscription") 1606 defer func() { 1607 sc := -1 1608 if result.Response().Response.Response != nil { 1609 sc = result.page.Response().Response.Response.StatusCode 1610 } 1611 tracing.EndSpan(ctx, sc, err) 1612 }() 1613 } 1614 result.page, err = client.ListBySubscription(ctx) 1615 return 1616} 1617 1618// ListEventHubConsumerGroups get a list of the consumer groups in the Event Hub-compatible device-to-cloud endpoint in 1619// an IoT hub. 1620// Parameters: 1621// resourceGroupName - the name of the resource group that contains the IoT hub. 1622// resourceName - the name of the IoT hub. 1623// eventHubEndpointName - the name of the Event Hub-compatible endpoint. 1624func (client IotHubResourceClient) ListEventHubConsumerGroups(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (result EventHubConsumerGroupsListResultPage, err error) { 1625 if tracing.IsEnabled() { 1626 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListEventHubConsumerGroups") 1627 defer func() { 1628 sc := -1 1629 if result.ehcglr.Response.Response != nil { 1630 sc = result.ehcglr.Response.Response.StatusCode 1631 } 1632 tracing.EndSpan(ctx, sc, err) 1633 }() 1634 } 1635 result.fn = client.listEventHubConsumerGroupsNextResults 1636 req, err := client.ListEventHubConsumerGroupsPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName) 1637 if err != nil { 1638 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", nil, "Failure preparing request") 1639 return 1640 } 1641 1642 resp, err := client.ListEventHubConsumerGroupsSender(req) 1643 if err != nil { 1644 result.ehcglr.Response = autorest.Response{Response: resp} 1645 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", resp, "Failure sending request") 1646 return 1647 } 1648 1649 result.ehcglr, err = client.ListEventHubConsumerGroupsResponder(resp) 1650 if err != nil { 1651 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", resp, "Failure responding to request") 1652 return 1653 } 1654 if result.ehcglr.hasNextLink() && result.ehcglr.IsEmpty() { 1655 err = result.NextWithContext(ctx) 1656 return 1657 } 1658 1659 return 1660} 1661 1662// ListEventHubConsumerGroupsPreparer prepares the ListEventHubConsumerGroups request. 1663func (client IotHubResourceClient) ListEventHubConsumerGroupsPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (*http.Request, error) { 1664 pathParameters := map[string]interface{}{ 1665 "eventHubEndpointName": autorest.Encode("path", eventHubEndpointName), 1666 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1667 "resourceName": autorest.Encode("path", resourceName), 1668 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1669 } 1670 1671 const APIVersion = "2020-03-01" 1672 queryParameters := map[string]interface{}{ 1673 "api-version": APIVersion, 1674 } 1675 1676 preparer := autorest.CreatePreparer( 1677 autorest.AsGet(), 1678 autorest.WithBaseURL(client.BaseURI), 1679 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups", pathParameters), 1680 autorest.WithQueryParameters(queryParameters)) 1681 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1682} 1683 1684// ListEventHubConsumerGroupsSender sends the ListEventHubConsumerGroups request. The method will close the 1685// http.Response Body if it receives an error. 1686func (client IotHubResourceClient) ListEventHubConsumerGroupsSender(req *http.Request) (*http.Response, error) { 1687 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1688} 1689 1690// ListEventHubConsumerGroupsResponder handles the response to the ListEventHubConsumerGroups request. The method always 1691// closes the http.Response Body. 1692func (client IotHubResourceClient) ListEventHubConsumerGroupsResponder(resp *http.Response) (result EventHubConsumerGroupsListResult, err error) { 1693 err = autorest.Respond( 1694 resp, 1695 azure.WithErrorUnlessStatusCode(http.StatusOK), 1696 autorest.ByUnmarshallingJSON(&result), 1697 autorest.ByClosing()) 1698 result.Response = autorest.Response{Response: resp} 1699 return 1700} 1701 1702// listEventHubConsumerGroupsNextResults retrieves the next set of results, if any. 1703func (client IotHubResourceClient) listEventHubConsumerGroupsNextResults(ctx context.Context, lastResults EventHubConsumerGroupsListResult) (result EventHubConsumerGroupsListResult, err error) { 1704 req, err := lastResults.eventHubConsumerGroupsListResultPreparer(ctx) 1705 if err != nil { 1706 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", nil, "Failure preparing next results request") 1707 } 1708 if req == nil { 1709 return 1710 } 1711 resp, err := client.ListEventHubConsumerGroupsSender(req) 1712 if err != nil { 1713 result.Response = autorest.Response{Response: resp} 1714 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", resp, "Failure sending next results request") 1715 } 1716 result, err = client.ListEventHubConsumerGroupsResponder(resp) 1717 if err != nil { 1718 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", resp, "Failure responding to next results request") 1719 } 1720 return 1721} 1722 1723// ListEventHubConsumerGroupsComplete enumerates all values, automatically crossing page boundaries as required. 1724func (client IotHubResourceClient) ListEventHubConsumerGroupsComplete(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (result EventHubConsumerGroupsListResultIterator, err error) { 1725 if tracing.IsEnabled() { 1726 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListEventHubConsumerGroups") 1727 defer func() { 1728 sc := -1 1729 if result.Response().Response.Response != nil { 1730 sc = result.page.Response().Response.Response.StatusCode 1731 } 1732 tracing.EndSpan(ctx, sc, err) 1733 }() 1734 } 1735 result.page, err = client.ListEventHubConsumerGroups(ctx, resourceGroupName, resourceName, eventHubEndpointName) 1736 return 1737} 1738 1739// ListJobs get a list of all the jobs in an IoT hub. For more information, see: 1740// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry. 1741// Parameters: 1742// resourceGroupName - the name of the resource group that contains the IoT hub. 1743// resourceName - the name of the IoT hub. 1744func (client IotHubResourceClient) ListJobs(ctx context.Context, resourceGroupName string, resourceName string) (result JobResponseListResultPage, err error) { 1745 if tracing.IsEnabled() { 1746 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListJobs") 1747 defer func() { 1748 sc := -1 1749 if result.jrlr.Response.Response != nil { 1750 sc = result.jrlr.Response.Response.StatusCode 1751 } 1752 tracing.EndSpan(ctx, sc, err) 1753 }() 1754 } 1755 result.fn = client.listJobsNextResults 1756 req, err := client.ListJobsPreparer(ctx, resourceGroupName, resourceName) 1757 if err != nil { 1758 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", nil, "Failure preparing request") 1759 return 1760 } 1761 1762 resp, err := client.ListJobsSender(req) 1763 if err != nil { 1764 result.jrlr.Response = autorest.Response{Response: resp} 1765 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", resp, "Failure sending request") 1766 return 1767 } 1768 1769 result.jrlr, err = client.ListJobsResponder(resp) 1770 if err != nil { 1771 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", resp, "Failure responding to request") 1772 return 1773 } 1774 if result.jrlr.hasNextLink() && result.jrlr.IsEmpty() { 1775 err = result.NextWithContext(ctx) 1776 return 1777 } 1778 1779 return 1780} 1781 1782// ListJobsPreparer prepares the ListJobs request. 1783func (client IotHubResourceClient) ListJobsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1784 pathParameters := map[string]interface{}{ 1785 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1786 "resourceName": autorest.Encode("path", resourceName), 1787 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1788 } 1789 1790 const APIVersion = "2020-03-01" 1791 queryParameters := map[string]interface{}{ 1792 "api-version": APIVersion, 1793 } 1794 1795 preparer := autorest.CreatePreparer( 1796 autorest.AsGet(), 1797 autorest.WithBaseURL(client.BaseURI), 1798 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/jobs", pathParameters), 1799 autorest.WithQueryParameters(queryParameters)) 1800 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1801} 1802 1803// ListJobsSender sends the ListJobs request. The method will close the 1804// http.Response Body if it receives an error. 1805func (client IotHubResourceClient) ListJobsSender(req *http.Request) (*http.Response, error) { 1806 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1807} 1808 1809// ListJobsResponder handles the response to the ListJobs request. The method always 1810// closes the http.Response Body. 1811func (client IotHubResourceClient) ListJobsResponder(resp *http.Response) (result JobResponseListResult, err error) { 1812 err = autorest.Respond( 1813 resp, 1814 azure.WithErrorUnlessStatusCode(http.StatusOK), 1815 autorest.ByUnmarshallingJSON(&result), 1816 autorest.ByClosing()) 1817 result.Response = autorest.Response{Response: resp} 1818 return 1819} 1820 1821// listJobsNextResults retrieves the next set of results, if any. 1822func (client IotHubResourceClient) listJobsNextResults(ctx context.Context, lastResults JobResponseListResult) (result JobResponseListResult, err error) { 1823 req, err := lastResults.jobResponseListResultPreparer(ctx) 1824 if err != nil { 1825 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", nil, "Failure preparing next results request") 1826 } 1827 if req == nil { 1828 return 1829 } 1830 resp, err := client.ListJobsSender(req) 1831 if err != nil { 1832 result.Response = autorest.Response{Response: resp} 1833 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", resp, "Failure sending next results request") 1834 } 1835 result, err = client.ListJobsResponder(resp) 1836 if err != nil { 1837 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", resp, "Failure responding to next results request") 1838 } 1839 return 1840} 1841 1842// ListJobsComplete enumerates all values, automatically crossing page boundaries as required. 1843func (client IotHubResourceClient) ListJobsComplete(ctx context.Context, resourceGroupName string, resourceName string) (result JobResponseListResultIterator, err error) { 1844 if tracing.IsEnabled() { 1845 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListJobs") 1846 defer func() { 1847 sc := -1 1848 if result.Response().Response.Response != nil { 1849 sc = result.page.Response().Response.Response.StatusCode 1850 } 1851 tracing.EndSpan(ctx, sc, err) 1852 }() 1853 } 1854 result.page, err = client.ListJobs(ctx, resourceGroupName, resourceName) 1855 return 1856} 1857 1858// ListKeys get the security metadata for an IoT hub. For more information, see: 1859// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-security. 1860// Parameters: 1861// resourceGroupName - the name of the resource group that contains the IoT hub. 1862// resourceName - the name of the IoT hub. 1863func (client IotHubResourceClient) ListKeys(ctx context.Context, resourceGroupName string, resourceName string) (result SharedAccessSignatureAuthorizationRuleListResultPage, err error) { 1864 if tracing.IsEnabled() { 1865 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListKeys") 1866 defer func() { 1867 sc := -1 1868 if result.sasarlr.Response.Response != nil { 1869 sc = result.sasarlr.Response.Response.StatusCode 1870 } 1871 tracing.EndSpan(ctx, sc, err) 1872 }() 1873 } 1874 result.fn = client.listKeysNextResults 1875 req, err := client.ListKeysPreparer(ctx, resourceGroupName, resourceName) 1876 if err != nil { 1877 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", nil, "Failure preparing request") 1878 return 1879 } 1880 1881 resp, err := client.ListKeysSender(req) 1882 if err != nil { 1883 result.sasarlr.Response = autorest.Response{Response: resp} 1884 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", resp, "Failure sending request") 1885 return 1886 } 1887 1888 result.sasarlr, err = client.ListKeysResponder(resp) 1889 if err != nil { 1890 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", resp, "Failure responding to request") 1891 return 1892 } 1893 if result.sasarlr.hasNextLink() && result.sasarlr.IsEmpty() { 1894 err = result.NextWithContext(ctx) 1895 return 1896 } 1897 1898 return 1899} 1900 1901// ListKeysPreparer prepares the ListKeys request. 1902func (client IotHubResourceClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1903 pathParameters := map[string]interface{}{ 1904 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1905 "resourceName": autorest.Encode("path", resourceName), 1906 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1907 } 1908 1909 const APIVersion = "2020-03-01" 1910 queryParameters := map[string]interface{}{ 1911 "api-version": APIVersion, 1912 } 1913 1914 preparer := autorest.CreatePreparer( 1915 autorest.AsPost(), 1916 autorest.WithBaseURL(client.BaseURI), 1917 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/listkeys", pathParameters), 1918 autorest.WithQueryParameters(queryParameters)) 1919 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1920} 1921 1922// ListKeysSender sends the ListKeys request. The method will close the 1923// http.Response Body if it receives an error. 1924func (client IotHubResourceClient) ListKeysSender(req *http.Request) (*http.Response, error) { 1925 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1926} 1927 1928// ListKeysResponder handles the response to the ListKeys request. The method always 1929// closes the http.Response Body. 1930func (client IotHubResourceClient) ListKeysResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRuleListResult, err error) { 1931 err = autorest.Respond( 1932 resp, 1933 azure.WithErrorUnlessStatusCode(http.StatusOK), 1934 autorest.ByUnmarshallingJSON(&result), 1935 autorest.ByClosing()) 1936 result.Response = autorest.Response{Response: resp} 1937 return 1938} 1939 1940// listKeysNextResults retrieves the next set of results, if any. 1941func (client IotHubResourceClient) listKeysNextResults(ctx context.Context, lastResults SharedAccessSignatureAuthorizationRuleListResult) (result SharedAccessSignatureAuthorizationRuleListResult, err error) { 1942 req, err := lastResults.sharedAccessSignatureAuthorizationRuleListResultPreparer(ctx) 1943 if err != nil { 1944 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", nil, "Failure preparing next results request") 1945 } 1946 if req == nil { 1947 return 1948 } 1949 resp, err := client.ListKeysSender(req) 1950 if err != nil { 1951 result.Response = autorest.Response{Response: resp} 1952 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", resp, "Failure sending next results request") 1953 } 1954 result, err = client.ListKeysResponder(resp) 1955 if err != nil { 1956 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", resp, "Failure responding to next results request") 1957 } 1958 return 1959} 1960 1961// ListKeysComplete enumerates all values, automatically crossing page boundaries as required. 1962func (client IotHubResourceClient) ListKeysComplete(ctx context.Context, resourceGroupName string, resourceName string) (result SharedAccessSignatureAuthorizationRuleListResultIterator, err error) { 1963 if tracing.IsEnabled() { 1964 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListKeys") 1965 defer func() { 1966 sc := -1 1967 if result.Response().Response.Response != nil { 1968 sc = result.page.Response().Response.Response.StatusCode 1969 } 1970 tracing.EndSpan(ctx, sc, err) 1971 }() 1972 } 1973 result.page, err = client.ListKeys(ctx, resourceGroupName, resourceName) 1974 return 1975} 1976 1977// TestAllRoutes test all routes configured in this Iot Hub 1978// Parameters: 1979// input - input for testing all routes 1980// iotHubName - iotHub to be tested 1981// resourceGroupName - resource group which Iot Hub belongs to 1982func (client IotHubResourceClient) TestAllRoutes(ctx context.Context, input TestAllRoutesInput, iotHubName string, resourceGroupName string) (result TestAllRoutesResult, err error) { 1983 if tracing.IsEnabled() { 1984 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.TestAllRoutes") 1985 defer func() { 1986 sc := -1 1987 if result.Response.Response != nil { 1988 sc = result.Response.Response.StatusCode 1989 } 1990 tracing.EndSpan(ctx, sc, err) 1991 }() 1992 } 1993 req, err := client.TestAllRoutesPreparer(ctx, input, iotHubName, resourceGroupName) 1994 if err != nil { 1995 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestAllRoutes", nil, "Failure preparing request") 1996 return 1997 } 1998 1999 resp, err := client.TestAllRoutesSender(req) 2000 if err != nil { 2001 result.Response = autorest.Response{Response: resp} 2002 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestAllRoutes", resp, "Failure sending request") 2003 return 2004 } 2005 2006 result, err = client.TestAllRoutesResponder(resp) 2007 if err != nil { 2008 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestAllRoutes", resp, "Failure responding to request") 2009 return 2010 } 2011 2012 return 2013} 2014 2015// TestAllRoutesPreparer prepares the TestAllRoutes request. 2016func (client IotHubResourceClient) TestAllRoutesPreparer(ctx context.Context, input TestAllRoutesInput, iotHubName string, resourceGroupName string) (*http.Request, error) { 2017 pathParameters := map[string]interface{}{ 2018 "iotHubName": autorest.Encode("path", iotHubName), 2019 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2020 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2021 } 2022 2023 const APIVersion = "2020-03-01" 2024 queryParameters := map[string]interface{}{ 2025 "api-version": APIVersion, 2026 } 2027 2028 preparer := autorest.CreatePreparer( 2029 autorest.AsContentType("application/json; charset=utf-8"), 2030 autorest.AsPost(), 2031 autorest.WithBaseURL(client.BaseURI), 2032 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{iotHubName}/routing/routes/$testall", pathParameters), 2033 autorest.WithJSON(input), 2034 autorest.WithQueryParameters(queryParameters)) 2035 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2036} 2037 2038// TestAllRoutesSender sends the TestAllRoutes request. The method will close the 2039// http.Response Body if it receives an error. 2040func (client IotHubResourceClient) TestAllRoutesSender(req *http.Request) (*http.Response, error) { 2041 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2042} 2043 2044// TestAllRoutesResponder handles the response to the TestAllRoutes request. The method always 2045// closes the http.Response Body. 2046func (client IotHubResourceClient) TestAllRoutesResponder(resp *http.Response) (result TestAllRoutesResult, err error) { 2047 err = autorest.Respond( 2048 resp, 2049 azure.WithErrorUnlessStatusCode(http.StatusOK), 2050 autorest.ByUnmarshallingJSON(&result), 2051 autorest.ByClosing()) 2052 result.Response = autorest.Response{Response: resp} 2053 return 2054} 2055 2056// TestRoute test the new route for this Iot Hub 2057// Parameters: 2058// input - route that needs to be tested 2059// iotHubName - iotHub to be tested 2060// resourceGroupName - resource group which Iot Hub belongs to 2061func (client IotHubResourceClient) TestRoute(ctx context.Context, input TestRouteInput, iotHubName string, resourceGroupName string) (result TestRouteResult, err error) { 2062 if tracing.IsEnabled() { 2063 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.TestRoute") 2064 defer func() { 2065 sc := -1 2066 if result.Response.Response != nil { 2067 sc = result.Response.Response.StatusCode 2068 } 2069 tracing.EndSpan(ctx, sc, err) 2070 }() 2071 } 2072 if err := validation.Validate([]validation.Validation{ 2073 {TargetValue: input, 2074 Constraints: []validation.Constraint{{Target: "input.Route", Name: validation.Null, Rule: true, 2075 Chain: []validation.Constraint{{Target: "input.Route.Name", Name: validation.Null, Rule: true, 2076 Chain: []validation.Constraint{{Target: "input.Route.Name", Name: validation.Pattern, Rule: `^[A-Za-z0-9-._]{1,64}$`, Chain: nil}}}, 2077 {Target: "input.Route.EndpointNames", Name: validation.Null, Rule: true, 2078 Chain: []validation.Constraint{{Target: "input.Route.EndpointNames", Name: validation.MaxItems, Rule: 1, Chain: nil}, 2079 {Target: "input.Route.EndpointNames", Name: validation.MinItems, Rule: 1, Chain: nil}, 2080 }}, 2081 {Target: "input.Route.IsEnabled", Name: validation.Null, Rule: true, Chain: nil}, 2082 }}}}}); err != nil { 2083 return result, validation.NewError("devices.IotHubResourceClient", "TestRoute", err.Error()) 2084 } 2085 2086 req, err := client.TestRoutePreparer(ctx, input, iotHubName, resourceGroupName) 2087 if err != nil { 2088 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestRoute", nil, "Failure preparing request") 2089 return 2090 } 2091 2092 resp, err := client.TestRouteSender(req) 2093 if err != nil { 2094 result.Response = autorest.Response{Response: resp} 2095 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestRoute", resp, "Failure sending request") 2096 return 2097 } 2098 2099 result, err = client.TestRouteResponder(resp) 2100 if err != nil { 2101 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestRoute", resp, "Failure responding to request") 2102 return 2103 } 2104 2105 return 2106} 2107 2108// TestRoutePreparer prepares the TestRoute request. 2109func (client IotHubResourceClient) TestRoutePreparer(ctx context.Context, input TestRouteInput, iotHubName string, resourceGroupName string) (*http.Request, error) { 2110 pathParameters := map[string]interface{}{ 2111 "iotHubName": autorest.Encode("path", iotHubName), 2112 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2113 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2114 } 2115 2116 const APIVersion = "2020-03-01" 2117 queryParameters := map[string]interface{}{ 2118 "api-version": APIVersion, 2119 } 2120 2121 preparer := autorest.CreatePreparer( 2122 autorest.AsContentType("application/json; charset=utf-8"), 2123 autorest.AsPost(), 2124 autorest.WithBaseURL(client.BaseURI), 2125 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{iotHubName}/routing/routes/$testnew", pathParameters), 2126 autorest.WithJSON(input), 2127 autorest.WithQueryParameters(queryParameters)) 2128 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2129} 2130 2131// TestRouteSender sends the TestRoute request. The method will close the 2132// http.Response Body if it receives an error. 2133func (client IotHubResourceClient) TestRouteSender(req *http.Request) (*http.Response, error) { 2134 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2135} 2136 2137// TestRouteResponder handles the response to the TestRoute request. The method always 2138// closes the http.Response Body. 2139func (client IotHubResourceClient) TestRouteResponder(resp *http.Response) (result TestRouteResult, err error) { 2140 err = autorest.Respond( 2141 resp, 2142 azure.WithErrorUnlessStatusCode(http.StatusOK), 2143 autorest.ByUnmarshallingJSON(&result), 2144 autorest.ByClosing()) 2145 result.Response = autorest.Response{Response: resp} 2146 return 2147} 2148 2149// Update update an existing IoT Hub tags. to update other fields use the CreateOrUpdate method 2150// Parameters: 2151// resourceGroupName - resource group identifier. 2152// resourceName - name of iot hub to update. 2153// iotHubTags - updated tag information to set into the iot hub instance. 2154func (client IotHubResourceClient) Update(ctx context.Context, resourceGroupName string, resourceName string, iotHubTags TagsResource) (result IotHubResourceUpdateFuture, err error) { 2155 if tracing.IsEnabled() { 2156 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Update") 2157 defer func() { 2158 sc := -1 2159 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 2160 sc = result.FutureAPI.Response().StatusCode 2161 } 2162 tracing.EndSpan(ctx, sc, err) 2163 }() 2164 } 2165 req, err := client.UpdatePreparer(ctx, resourceGroupName, resourceName, iotHubTags) 2166 if err != nil { 2167 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Update", nil, "Failure preparing request") 2168 return 2169 } 2170 2171 result, err = client.UpdateSender(req) 2172 if err != nil { 2173 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Update", nil, "Failure sending request") 2174 return 2175 } 2176 2177 return 2178} 2179 2180// UpdatePreparer prepares the Update request. 2181func (client IotHubResourceClient) UpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, iotHubTags TagsResource) (*http.Request, error) { 2182 pathParameters := map[string]interface{}{ 2183 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2184 "resourceName": autorest.Encode("path", resourceName), 2185 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2186 } 2187 2188 const APIVersion = "2020-03-01" 2189 queryParameters := map[string]interface{}{ 2190 "api-version": APIVersion, 2191 } 2192 2193 preparer := autorest.CreatePreparer( 2194 autorest.AsContentType("application/json; charset=utf-8"), 2195 autorest.AsPatch(), 2196 autorest.WithBaseURL(client.BaseURI), 2197 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters), 2198 autorest.WithJSON(iotHubTags), 2199 autorest.WithQueryParameters(queryParameters)) 2200 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2201} 2202 2203// UpdateSender sends the Update request. The method will close the 2204// http.Response Body if it receives an error. 2205func (client IotHubResourceClient) UpdateSender(req *http.Request) (future IotHubResourceUpdateFuture, err error) { 2206 var resp *http.Response 2207 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2208 if err != nil { 2209 return 2210 } 2211 var azf azure.Future 2212 azf, err = azure.NewFutureFromResponse(resp) 2213 future.FutureAPI = &azf 2214 future.Result = future.result 2215 return 2216} 2217 2218// UpdateResponder handles the response to the Update request. The method always 2219// closes the http.Response Body. 2220func (client IotHubResourceClient) UpdateResponder(resp *http.Response) (result IotHubDescription, err error) { 2221 err = autorest.Respond( 2222 resp, 2223 azure.WithErrorUnlessStatusCode(http.StatusOK), 2224 autorest.ByUnmarshallingJSON(&result), 2225 autorest.ByClosing()) 2226 result.Response = autorest.Response{Response: resp} 2227 return 2228} 2229