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 = "2016-02-03" 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 = "2016-02-03" 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 to create or update. 202// iotHubDescription - the IoT hub metadata and security metadata. 203func (client IotHubResourceClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, iotHubDescription IotHubDescription) (result IotHubResourceCreateOrUpdateFuture, err error) { 204 if tracing.IsEnabled() { 205 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CreateOrUpdate") 206 defer func() { 207 sc := -1 208 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 209 sc = result.FutureAPI.Response().StatusCode 210 } 211 tracing.EndSpan(ctx, sc, err) 212 }() 213 } 214 if err := validation.Validate([]validation.Validation{ 215 {TargetValue: iotHubDescription, 216 Constraints: []validation.Constraint{{Target: "iotHubDescription.Subscriptionid", Name: validation.Null, Rule: true, Chain: nil}, 217 {Target: "iotHubDescription.Resourcegroup", Name: validation.Null, Rule: true, Chain: nil}, 218 {Target: "iotHubDescription.Properties", Name: validation.Null, Rule: false, 219 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice", Name: validation.Null, Rule: false, 220 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.Null, Rule: false, 221 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil}, 222 {Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}, 223 }}, 224 {Target: "iotHubDescription.Properties.CloudToDevice.Feedback", Name: validation.Null, Rule: false, 225 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.Null, Rule: false, 226 Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil}, 227 {Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}, 228 }}, 229 }}, 230 }}, 231 }}, 232 {Target: "iotHubDescription.Sku", Name: validation.Null, Rule: true, 233 Chain: []validation.Constraint{{Target: "iotHubDescription.Sku.Capacity", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { 234 return result, validation.NewError("devices.IotHubResourceClient", "CreateOrUpdate", err.Error()) 235 } 236 237 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, resourceName, iotHubDescription) 238 if err != nil { 239 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateOrUpdate", nil, "Failure preparing request") 240 return 241 } 242 243 result, err = client.CreateOrUpdateSender(req) 244 if err != nil { 245 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateOrUpdate", nil, "Failure sending request") 246 return 247 } 248 249 return 250} 251 252// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 253func (client IotHubResourceClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, iotHubDescription IotHubDescription) (*http.Request, error) { 254 pathParameters := map[string]interface{}{ 255 "resourceGroupName": autorest.Encode("path", resourceGroupName), 256 "resourceName": autorest.Encode("path", resourceName), 257 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 258 } 259 260 const APIVersion = "2016-02-03" 261 queryParameters := map[string]interface{}{ 262 "api-version": APIVersion, 263 } 264 265 preparer := autorest.CreatePreparer( 266 autorest.AsContentType("application/json; charset=utf-8"), 267 autorest.AsPut(), 268 autorest.WithBaseURL(client.BaseURI), 269 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters), 270 autorest.WithJSON(iotHubDescription), 271 autorest.WithQueryParameters(queryParameters)) 272 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 273} 274 275// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 276// http.Response Body if it receives an error. 277func (client IotHubResourceClient) CreateOrUpdateSender(req *http.Request) (future IotHubResourceCreateOrUpdateFuture, err error) { 278 var resp *http.Response 279 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 280 if err != nil { 281 return 282 } 283 var azf azure.Future 284 azf, err = azure.NewFutureFromResponse(resp) 285 future.FutureAPI = &azf 286 future.Result = future.result 287 return 288} 289 290// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 291// closes the http.Response Body. 292func (client IotHubResourceClient) CreateOrUpdateResponder(resp *http.Response) (result IotHubDescription, err error) { 293 err = autorest.Respond( 294 resp, 295 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 296 autorest.ByUnmarshallingJSON(&result), 297 autorest.ByClosing()) 298 result.Response = autorest.Response{Response: resp} 299 return 300} 301 302// Delete delete an IoT hub. 303// Parameters: 304// resourceGroupName - the name of the resource group that contains the IoT hub. 305// resourceName - the name of the IoT hub to delete. 306func (client IotHubResourceClient) Delete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubResourceDeleteFuture, err error) { 307 if tracing.IsEnabled() { 308 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Delete") 309 defer func() { 310 sc := -1 311 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 312 sc = result.FutureAPI.Response().StatusCode 313 } 314 tracing.EndSpan(ctx, sc, err) 315 }() 316 } 317 req, err := client.DeletePreparer(ctx, resourceGroupName, resourceName) 318 if err != nil { 319 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Delete", nil, "Failure preparing request") 320 return 321 } 322 323 result, err = client.DeleteSender(req) 324 if err != nil { 325 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Delete", nil, "Failure sending request") 326 return 327 } 328 329 return 330} 331 332// DeletePreparer prepares the Delete request. 333func (client IotHubResourceClient) DeletePreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 334 pathParameters := map[string]interface{}{ 335 "resourceGroupName": autorest.Encode("path", resourceGroupName), 336 "resourceName": autorest.Encode("path", resourceName), 337 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 338 } 339 340 const APIVersion = "2016-02-03" 341 queryParameters := map[string]interface{}{ 342 "api-version": APIVersion, 343 } 344 345 preparer := autorest.CreatePreparer( 346 autorest.AsDelete(), 347 autorest.WithBaseURL(client.BaseURI), 348 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters), 349 autorest.WithQueryParameters(queryParameters)) 350 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 351} 352 353// DeleteSender sends the Delete request. The method will close the 354// http.Response Body if it receives an error. 355func (client IotHubResourceClient) DeleteSender(req *http.Request) (future IotHubResourceDeleteFuture, err error) { 356 var resp *http.Response 357 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 358 if err != nil { 359 return 360 } 361 var azf azure.Future 362 azf, err = azure.NewFutureFromResponse(resp) 363 future.FutureAPI = &azf 364 future.Result = future.result 365 return 366} 367 368// DeleteResponder handles the response to the Delete request. The method always 369// closes the http.Response Body. 370func (client IotHubResourceClient) DeleteResponder(resp *http.Response) (result SetObject, err error) { 371 err = autorest.Respond( 372 resp, 373 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent, http.StatusNotFound), 374 autorest.ByUnmarshallingJSON(&result), 375 autorest.ByClosing()) 376 result.Response = autorest.Response{Response: resp} 377 return 378} 379 380// DeleteEventHubConsumerGroup delete a consumer group from an Event Hub-compatible endpoint in an IoT hub. 381// Parameters: 382// resourceGroupName - the name of the resource group that contains the IoT hub. 383// resourceName - the name of the IoT hub. 384// eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub. 385// name - the name of the consumer group to delete. 386func (client IotHubResourceClient) DeleteEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result autorest.Response, err error) { 387 if tracing.IsEnabled() { 388 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.DeleteEventHubConsumerGroup") 389 defer func() { 390 sc := -1 391 if result.Response != nil { 392 sc = result.Response.StatusCode 393 } 394 tracing.EndSpan(ctx, sc, err) 395 }() 396 } 397 req, err := client.DeleteEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name) 398 if err != nil { 399 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", nil, "Failure preparing request") 400 return 401 } 402 403 resp, err := client.DeleteEventHubConsumerGroupSender(req) 404 if err != nil { 405 result.Response = resp 406 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", resp, "Failure sending request") 407 return 408 } 409 410 result, err = client.DeleteEventHubConsumerGroupResponder(resp) 411 if err != nil { 412 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", resp, "Failure responding to request") 413 return 414 } 415 416 return 417} 418 419// DeleteEventHubConsumerGroupPreparer prepares the DeleteEventHubConsumerGroup request. 420func (client IotHubResourceClient) DeleteEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) { 421 pathParameters := map[string]interface{}{ 422 "eventHubEndpointName": autorest.Encode("path", eventHubEndpointName), 423 "name": autorest.Encode("path", name), 424 "resourceGroupName": autorest.Encode("path", resourceGroupName), 425 "resourceName": autorest.Encode("path", resourceName), 426 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 427 } 428 429 const APIVersion = "2016-02-03" 430 queryParameters := map[string]interface{}{ 431 "api-version": APIVersion, 432 } 433 434 preparer := autorest.CreatePreparer( 435 autorest.AsDelete(), 436 autorest.WithBaseURL(client.BaseURI), 437 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters), 438 autorest.WithQueryParameters(queryParameters)) 439 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 440} 441 442// DeleteEventHubConsumerGroupSender sends the DeleteEventHubConsumerGroup request. The method will close the 443// http.Response Body if it receives an error. 444func (client IotHubResourceClient) DeleteEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) { 445 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 446} 447 448// DeleteEventHubConsumerGroupResponder handles the response to the DeleteEventHubConsumerGroup request. The method always 449// closes the http.Response Body. 450func (client IotHubResourceClient) DeleteEventHubConsumerGroupResponder(resp *http.Response) (result autorest.Response, err error) { 451 err = autorest.Respond( 452 resp, 453 azure.WithErrorUnlessStatusCode(http.StatusOK), 454 autorest.ByClosing()) 455 result.Response = resp 456 return 457} 458 459// ExportDevices exports all the device identities in the IoT hub identity registry to an Azure Storage blob container. 460// For more information, see: 461// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities. 462// Parameters: 463// resourceGroupName - the name of the resource group that contains the IoT hub. 464// resourceName - the name of the IoT hub. 465// exportDevicesParameters - the parameters that specify the export devices operation. 466func (client IotHubResourceClient) ExportDevices(ctx context.Context, resourceGroupName string, resourceName string, exportDevicesParameters ExportDevicesRequest) (result JobResponse, err error) { 467 if tracing.IsEnabled() { 468 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ExportDevices") 469 defer func() { 470 sc := -1 471 if result.Response.Response != nil { 472 sc = result.Response.Response.StatusCode 473 } 474 tracing.EndSpan(ctx, sc, err) 475 }() 476 } 477 if err := validation.Validate([]validation.Validation{ 478 {TargetValue: exportDevicesParameters, 479 Constraints: []validation.Constraint{{Target: "exportDevicesParameters.ExportBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil}, 480 {Target: "exportDevicesParameters.ExcludeKeys", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 481 return result, validation.NewError("devices.IotHubResourceClient", "ExportDevices", err.Error()) 482 } 483 484 req, err := client.ExportDevicesPreparer(ctx, resourceGroupName, resourceName, exportDevicesParameters) 485 if err != nil { 486 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", nil, "Failure preparing request") 487 return 488 } 489 490 resp, err := client.ExportDevicesSender(req) 491 if err != nil { 492 result.Response = autorest.Response{Response: resp} 493 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", resp, "Failure sending request") 494 return 495 } 496 497 result, err = client.ExportDevicesResponder(resp) 498 if err != nil { 499 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", resp, "Failure responding to request") 500 return 501 } 502 503 return 504} 505 506// ExportDevicesPreparer prepares the ExportDevices request. 507func (client IotHubResourceClient) ExportDevicesPreparer(ctx context.Context, resourceGroupName string, resourceName string, exportDevicesParameters ExportDevicesRequest) (*http.Request, error) { 508 pathParameters := map[string]interface{}{ 509 "resourceGroupName": autorest.Encode("path", resourceGroupName), 510 "resourceName": autorest.Encode("path", resourceName), 511 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 512 } 513 514 const APIVersion = "2016-02-03" 515 queryParameters := map[string]interface{}{ 516 "api-version": APIVersion, 517 } 518 519 preparer := autorest.CreatePreparer( 520 autorest.AsContentType("application/json; charset=utf-8"), 521 autorest.AsPost(), 522 autorest.WithBaseURL(client.BaseURI), 523 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/exportDevices", pathParameters), 524 autorest.WithJSON(exportDevicesParameters), 525 autorest.WithQueryParameters(queryParameters)) 526 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 527} 528 529// ExportDevicesSender sends the ExportDevices request. The method will close the 530// http.Response Body if it receives an error. 531func (client IotHubResourceClient) ExportDevicesSender(req *http.Request) (*http.Response, error) { 532 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 533} 534 535// ExportDevicesResponder handles the response to the ExportDevices request. The method always 536// closes the http.Response Body. 537func (client IotHubResourceClient) ExportDevicesResponder(resp *http.Response) (result JobResponse, err error) { 538 err = autorest.Respond( 539 resp, 540 azure.WithErrorUnlessStatusCode(http.StatusOK), 541 autorest.ByUnmarshallingJSON(&result), 542 autorest.ByClosing()) 543 result.Response = autorest.Response{Response: resp} 544 return 545} 546 547// Get get the non-security related metadata of an IoT hub. 548// Parameters: 549// resourceGroupName - the name of the resource group that contains the IoT hub. 550// resourceName - the name of the IoT hub. 551func (client IotHubResourceClient) Get(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubDescription, err error) { 552 if tracing.IsEnabled() { 553 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Get") 554 defer func() { 555 sc := -1 556 if result.Response.Response != nil { 557 sc = result.Response.Response.StatusCode 558 } 559 tracing.EndSpan(ctx, sc, err) 560 }() 561 } 562 req, err := client.GetPreparer(ctx, resourceGroupName, resourceName) 563 if err != nil { 564 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", nil, "Failure preparing request") 565 return 566 } 567 568 resp, err := client.GetSender(req) 569 if err != nil { 570 result.Response = autorest.Response{Response: resp} 571 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", resp, "Failure sending request") 572 return 573 } 574 575 result, err = client.GetResponder(resp) 576 if err != nil { 577 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", resp, "Failure responding to request") 578 return 579 } 580 581 return 582} 583 584// GetPreparer prepares the Get request. 585func (client IotHubResourceClient) GetPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 586 pathParameters := map[string]interface{}{ 587 "resourceGroupName": autorest.Encode("path", resourceGroupName), 588 "resourceName": autorest.Encode("path", resourceName), 589 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 590 } 591 592 const APIVersion = "2016-02-03" 593 queryParameters := map[string]interface{}{ 594 "api-version": APIVersion, 595 } 596 597 preparer := autorest.CreatePreparer( 598 autorest.AsGet(), 599 autorest.WithBaseURL(client.BaseURI), 600 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters), 601 autorest.WithQueryParameters(queryParameters)) 602 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 603} 604 605// GetSender sends the Get request. The method will close the 606// http.Response Body if it receives an error. 607func (client IotHubResourceClient) GetSender(req *http.Request) (*http.Response, error) { 608 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 609} 610 611// GetResponder handles the response to the Get request. The method always 612// closes the http.Response Body. 613func (client IotHubResourceClient) GetResponder(resp *http.Response) (result IotHubDescription, err error) { 614 err = autorest.Respond( 615 resp, 616 azure.WithErrorUnlessStatusCode(http.StatusOK), 617 autorest.ByUnmarshallingJSON(&result), 618 autorest.ByClosing()) 619 result.Response = autorest.Response{Response: resp} 620 return 621} 622 623// GetEventHubConsumerGroup get a consumer group from the Event Hub-compatible device-to-cloud endpoint for an IoT hub. 624// Parameters: 625// resourceGroupName - the name of the resource group that contains the IoT hub. 626// resourceName - the name of the IoT hub. 627// eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub. 628// name - the name of the consumer group to retrieve. 629func (client IotHubResourceClient) GetEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result EventHubConsumerGroupInfo, err error) { 630 if tracing.IsEnabled() { 631 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetEventHubConsumerGroup") 632 defer func() { 633 sc := -1 634 if result.Response.Response != nil { 635 sc = result.Response.Response.StatusCode 636 } 637 tracing.EndSpan(ctx, sc, err) 638 }() 639 } 640 req, err := client.GetEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name) 641 if err != nil { 642 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", nil, "Failure preparing request") 643 return 644 } 645 646 resp, err := client.GetEventHubConsumerGroupSender(req) 647 if err != nil { 648 result.Response = autorest.Response{Response: resp} 649 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", resp, "Failure sending request") 650 return 651 } 652 653 result, err = client.GetEventHubConsumerGroupResponder(resp) 654 if err != nil { 655 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", resp, "Failure responding to request") 656 return 657 } 658 659 return 660} 661 662// GetEventHubConsumerGroupPreparer prepares the GetEventHubConsumerGroup request. 663func (client IotHubResourceClient) GetEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) { 664 pathParameters := map[string]interface{}{ 665 "eventHubEndpointName": autorest.Encode("path", eventHubEndpointName), 666 "name": autorest.Encode("path", name), 667 "resourceGroupName": autorest.Encode("path", resourceGroupName), 668 "resourceName": autorest.Encode("path", resourceName), 669 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 670 } 671 672 const APIVersion = "2016-02-03" 673 queryParameters := map[string]interface{}{ 674 "api-version": APIVersion, 675 } 676 677 preparer := autorest.CreatePreparer( 678 autorest.AsGet(), 679 autorest.WithBaseURL(client.BaseURI), 680 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters), 681 autorest.WithQueryParameters(queryParameters)) 682 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 683} 684 685// GetEventHubConsumerGroupSender sends the GetEventHubConsumerGroup request. The method will close the 686// http.Response Body if it receives an error. 687func (client IotHubResourceClient) GetEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) { 688 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 689} 690 691// GetEventHubConsumerGroupResponder handles the response to the GetEventHubConsumerGroup request. The method always 692// closes the http.Response Body. 693func (client IotHubResourceClient) GetEventHubConsumerGroupResponder(resp *http.Response) (result EventHubConsumerGroupInfo, err error) { 694 err = autorest.Respond( 695 resp, 696 azure.WithErrorUnlessStatusCode(http.StatusOK), 697 autorest.ByUnmarshallingJSON(&result), 698 autorest.ByClosing()) 699 result.Response = autorest.Response{Response: resp} 700 return 701} 702 703// GetJob get the details of a job from an IoT hub. For more information, see: 704// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry. 705// Parameters: 706// resourceGroupName - the name of the resource group that contains the IoT hub. 707// resourceName - the name of the IoT hub. 708// jobID - the job identifier. 709func (client IotHubResourceClient) GetJob(ctx context.Context, resourceGroupName string, resourceName string, jobID string) (result JobResponse, err error) { 710 if tracing.IsEnabled() { 711 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetJob") 712 defer func() { 713 sc := -1 714 if result.Response.Response != nil { 715 sc = result.Response.Response.StatusCode 716 } 717 tracing.EndSpan(ctx, sc, err) 718 }() 719 } 720 req, err := client.GetJobPreparer(ctx, resourceGroupName, resourceName, jobID) 721 if err != nil { 722 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", nil, "Failure preparing request") 723 return 724 } 725 726 resp, err := client.GetJobSender(req) 727 if err != nil { 728 result.Response = autorest.Response{Response: resp} 729 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", resp, "Failure sending request") 730 return 731 } 732 733 result, err = client.GetJobResponder(resp) 734 if err != nil { 735 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", resp, "Failure responding to request") 736 return 737 } 738 739 return 740} 741 742// GetJobPreparer prepares the GetJob request. 743func (client IotHubResourceClient) GetJobPreparer(ctx context.Context, resourceGroupName string, resourceName string, jobID string) (*http.Request, error) { 744 pathParameters := map[string]interface{}{ 745 "jobId": autorest.Encode("path", jobID), 746 "resourceGroupName": autorest.Encode("path", resourceGroupName), 747 "resourceName": autorest.Encode("path", resourceName), 748 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 749 } 750 751 const APIVersion = "2016-02-03" 752 queryParameters := map[string]interface{}{ 753 "api-version": APIVersion, 754 } 755 756 preparer := autorest.CreatePreparer( 757 autorest.AsGet(), 758 autorest.WithBaseURL(client.BaseURI), 759 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/jobs/{jobId}", pathParameters), 760 autorest.WithQueryParameters(queryParameters)) 761 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 762} 763 764// GetJobSender sends the GetJob request. The method will close the 765// http.Response Body if it receives an error. 766func (client IotHubResourceClient) GetJobSender(req *http.Request) (*http.Response, error) { 767 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 768} 769 770// GetJobResponder handles the response to the GetJob request. The method always 771// closes the http.Response Body. 772func (client IotHubResourceClient) GetJobResponder(resp *http.Response) (result JobResponse, err error) { 773 err = autorest.Respond( 774 resp, 775 azure.WithErrorUnlessStatusCode(http.StatusOK), 776 autorest.ByUnmarshallingJSON(&result), 777 autorest.ByClosing()) 778 result.Response = autorest.Response{Response: resp} 779 return 780} 781 782// GetKeysForKeyName get a shared access policy by name from an IoT hub. For more information, see: 783// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-security. 784// Parameters: 785// resourceGroupName - the name of the resource group that contains the IoT hub. 786// resourceName - the name of the IoT hub. 787// keyName - the name of the shared access policy. 788func (client IotHubResourceClient) GetKeysForKeyName(ctx context.Context, resourceGroupName string, resourceName string, keyName string) (result SharedAccessSignatureAuthorizationRule, err error) { 789 if tracing.IsEnabled() { 790 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetKeysForKeyName") 791 defer func() { 792 sc := -1 793 if result.Response.Response != nil { 794 sc = result.Response.Response.StatusCode 795 } 796 tracing.EndSpan(ctx, sc, err) 797 }() 798 } 799 req, err := client.GetKeysForKeyNamePreparer(ctx, resourceGroupName, resourceName, keyName) 800 if err != nil { 801 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", nil, "Failure preparing request") 802 return 803 } 804 805 resp, err := client.GetKeysForKeyNameSender(req) 806 if err != nil { 807 result.Response = autorest.Response{Response: resp} 808 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", resp, "Failure sending request") 809 return 810 } 811 812 result, err = client.GetKeysForKeyNameResponder(resp) 813 if err != nil { 814 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", resp, "Failure responding to request") 815 return 816 } 817 818 return 819} 820 821// GetKeysForKeyNamePreparer prepares the GetKeysForKeyName request. 822func (client IotHubResourceClient) GetKeysForKeyNamePreparer(ctx context.Context, resourceGroupName string, resourceName string, keyName string) (*http.Request, error) { 823 pathParameters := map[string]interface{}{ 824 "keyName": autorest.Encode("path", keyName), 825 "resourceGroupName": autorest.Encode("path", resourceGroupName), 826 "resourceName": autorest.Encode("path", resourceName), 827 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 828 } 829 830 const APIVersion = "2016-02-03" 831 queryParameters := map[string]interface{}{ 832 "api-version": APIVersion, 833 } 834 835 preparer := autorest.CreatePreparer( 836 autorest.AsPost(), 837 autorest.WithBaseURL(client.BaseURI), 838 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/IotHubKeys/{keyName}/listkeys", pathParameters), 839 autorest.WithQueryParameters(queryParameters)) 840 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 841} 842 843// GetKeysForKeyNameSender sends the GetKeysForKeyName request. The method will close the 844// http.Response Body if it receives an error. 845func (client IotHubResourceClient) GetKeysForKeyNameSender(req *http.Request) (*http.Response, error) { 846 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 847} 848 849// GetKeysForKeyNameResponder handles the response to the GetKeysForKeyName request. The method always 850// closes the http.Response Body. 851func (client IotHubResourceClient) GetKeysForKeyNameResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRule, err error) { 852 err = autorest.Respond( 853 resp, 854 azure.WithErrorUnlessStatusCode(http.StatusOK), 855 autorest.ByUnmarshallingJSON(&result), 856 autorest.ByClosing()) 857 result.Response = autorest.Response{Response: resp} 858 return 859} 860 861// GetQuotaMetrics get the quota metrics for an IoT hub. 862// Parameters: 863// resourceGroupName - the name of the resource group that contains the IoT hub. 864// resourceName - the name of the IoT hub. 865func (client IotHubResourceClient) GetQuotaMetrics(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubQuotaMetricInfoListResultPage, err error) { 866 if tracing.IsEnabled() { 867 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetQuotaMetrics") 868 defer func() { 869 sc := -1 870 if result.ihqmilr.Response.Response != nil { 871 sc = result.ihqmilr.Response.Response.StatusCode 872 } 873 tracing.EndSpan(ctx, sc, err) 874 }() 875 } 876 result.fn = client.getQuotaMetricsNextResults 877 req, err := client.GetQuotaMetricsPreparer(ctx, resourceGroupName, resourceName) 878 if err != nil { 879 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", nil, "Failure preparing request") 880 return 881 } 882 883 resp, err := client.GetQuotaMetricsSender(req) 884 if err != nil { 885 result.ihqmilr.Response = autorest.Response{Response: resp} 886 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", resp, "Failure sending request") 887 return 888 } 889 890 result.ihqmilr, err = client.GetQuotaMetricsResponder(resp) 891 if err != nil { 892 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", resp, "Failure responding to request") 893 return 894 } 895 if result.ihqmilr.hasNextLink() && result.ihqmilr.IsEmpty() { 896 err = result.NextWithContext(ctx) 897 return 898 } 899 900 return 901} 902 903// GetQuotaMetricsPreparer prepares the GetQuotaMetrics request. 904func (client IotHubResourceClient) GetQuotaMetricsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 905 pathParameters := map[string]interface{}{ 906 "resourceGroupName": autorest.Encode("path", resourceGroupName), 907 "resourceName": autorest.Encode("path", resourceName), 908 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 909 } 910 911 const APIVersion = "2016-02-03" 912 queryParameters := map[string]interface{}{ 913 "api-version": APIVersion, 914 } 915 916 preparer := autorest.CreatePreparer( 917 autorest.AsGet(), 918 autorest.WithBaseURL(client.BaseURI), 919 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/quotaMetrics", pathParameters), 920 autorest.WithQueryParameters(queryParameters)) 921 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 922} 923 924// GetQuotaMetricsSender sends the GetQuotaMetrics request. The method will close the 925// http.Response Body if it receives an error. 926func (client IotHubResourceClient) GetQuotaMetricsSender(req *http.Request) (*http.Response, error) { 927 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 928} 929 930// GetQuotaMetricsResponder handles the response to the GetQuotaMetrics request. The method always 931// closes the http.Response Body. 932func (client IotHubResourceClient) GetQuotaMetricsResponder(resp *http.Response) (result IotHubQuotaMetricInfoListResult, err error) { 933 err = autorest.Respond( 934 resp, 935 azure.WithErrorUnlessStatusCode(http.StatusOK), 936 autorest.ByUnmarshallingJSON(&result), 937 autorest.ByClosing()) 938 result.Response = autorest.Response{Response: resp} 939 return 940} 941 942// getQuotaMetricsNextResults retrieves the next set of results, if any. 943func (client IotHubResourceClient) getQuotaMetricsNextResults(ctx context.Context, lastResults IotHubQuotaMetricInfoListResult) (result IotHubQuotaMetricInfoListResult, err error) { 944 req, err := lastResults.iotHubQuotaMetricInfoListResultPreparer(ctx) 945 if err != nil { 946 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", nil, "Failure preparing next results request") 947 } 948 if req == nil { 949 return 950 } 951 resp, err := client.GetQuotaMetricsSender(req) 952 if err != nil { 953 result.Response = autorest.Response{Response: resp} 954 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", resp, "Failure sending next results request") 955 } 956 result, err = client.GetQuotaMetricsResponder(resp) 957 if err != nil { 958 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", resp, "Failure responding to next results request") 959 } 960 return 961} 962 963// GetQuotaMetricsComplete enumerates all values, automatically crossing page boundaries as required. 964func (client IotHubResourceClient) GetQuotaMetricsComplete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubQuotaMetricInfoListResultIterator, err error) { 965 if tracing.IsEnabled() { 966 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetQuotaMetrics") 967 defer func() { 968 sc := -1 969 if result.Response().Response.Response != nil { 970 sc = result.page.Response().Response.Response.StatusCode 971 } 972 tracing.EndSpan(ctx, sc, err) 973 }() 974 } 975 result.page, err = client.GetQuotaMetrics(ctx, resourceGroupName, resourceName) 976 return 977} 978 979// GetStats get the statistics from an IoT hub. 980// Parameters: 981// resourceGroupName - the name of the resource group that contains the IoT hub. 982// resourceName - the name of the IoT hub. 983func (client IotHubResourceClient) GetStats(ctx context.Context, resourceGroupName string, resourceName string) (result RegistryStatistics, err error) { 984 if tracing.IsEnabled() { 985 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetStats") 986 defer func() { 987 sc := -1 988 if result.Response.Response != nil { 989 sc = result.Response.Response.StatusCode 990 } 991 tracing.EndSpan(ctx, sc, err) 992 }() 993 } 994 req, err := client.GetStatsPreparer(ctx, resourceGroupName, resourceName) 995 if err != nil { 996 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", nil, "Failure preparing request") 997 return 998 } 999 1000 resp, err := client.GetStatsSender(req) 1001 if err != nil { 1002 result.Response = autorest.Response{Response: resp} 1003 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", resp, "Failure sending request") 1004 return 1005 } 1006 1007 result, err = client.GetStatsResponder(resp) 1008 if err != nil { 1009 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", resp, "Failure responding to request") 1010 return 1011 } 1012 1013 return 1014} 1015 1016// GetStatsPreparer prepares the GetStats request. 1017func (client IotHubResourceClient) GetStatsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1018 pathParameters := map[string]interface{}{ 1019 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1020 "resourceName": autorest.Encode("path", resourceName), 1021 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1022 } 1023 1024 const APIVersion = "2016-02-03" 1025 queryParameters := map[string]interface{}{ 1026 "api-version": APIVersion, 1027 } 1028 1029 preparer := autorest.CreatePreparer( 1030 autorest.AsGet(), 1031 autorest.WithBaseURL(client.BaseURI), 1032 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/IotHubStats", pathParameters), 1033 autorest.WithQueryParameters(queryParameters)) 1034 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1035} 1036 1037// GetStatsSender sends the GetStats request. The method will close the 1038// http.Response Body if it receives an error. 1039func (client IotHubResourceClient) GetStatsSender(req *http.Request) (*http.Response, error) { 1040 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1041} 1042 1043// GetStatsResponder handles the response to the GetStats request. The method always 1044// closes the http.Response Body. 1045func (client IotHubResourceClient) GetStatsResponder(resp *http.Response) (result RegistryStatistics, err error) { 1046 err = autorest.Respond( 1047 resp, 1048 azure.WithErrorUnlessStatusCode(http.StatusOK), 1049 autorest.ByUnmarshallingJSON(&result), 1050 autorest.ByClosing()) 1051 result.Response = autorest.Response{Response: resp} 1052 return 1053} 1054 1055// GetValidSkus get the list of valid SKUs for an IoT hub. 1056// Parameters: 1057// resourceGroupName - the name of the resource group that contains the IoT hub. 1058// resourceName - the name of the IoT hub. 1059func (client IotHubResourceClient) GetValidSkus(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubSkuDescriptionListResultPage, err error) { 1060 if tracing.IsEnabled() { 1061 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetValidSkus") 1062 defer func() { 1063 sc := -1 1064 if result.ihsdlr.Response.Response != nil { 1065 sc = result.ihsdlr.Response.Response.StatusCode 1066 } 1067 tracing.EndSpan(ctx, sc, err) 1068 }() 1069 } 1070 result.fn = client.getValidSkusNextResults 1071 req, err := client.GetValidSkusPreparer(ctx, resourceGroupName, resourceName) 1072 if err != nil { 1073 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", nil, "Failure preparing request") 1074 return 1075 } 1076 1077 resp, err := client.GetValidSkusSender(req) 1078 if err != nil { 1079 result.ihsdlr.Response = autorest.Response{Response: resp} 1080 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", resp, "Failure sending request") 1081 return 1082 } 1083 1084 result.ihsdlr, err = client.GetValidSkusResponder(resp) 1085 if err != nil { 1086 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", resp, "Failure responding to request") 1087 return 1088 } 1089 if result.ihsdlr.hasNextLink() && result.ihsdlr.IsEmpty() { 1090 err = result.NextWithContext(ctx) 1091 return 1092 } 1093 1094 return 1095} 1096 1097// GetValidSkusPreparer prepares the GetValidSkus request. 1098func (client IotHubResourceClient) GetValidSkusPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1099 pathParameters := map[string]interface{}{ 1100 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1101 "resourceName": autorest.Encode("path", resourceName), 1102 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1103 } 1104 1105 const APIVersion = "2016-02-03" 1106 queryParameters := map[string]interface{}{ 1107 "api-version": APIVersion, 1108 } 1109 1110 preparer := autorest.CreatePreparer( 1111 autorest.AsGet(), 1112 autorest.WithBaseURL(client.BaseURI), 1113 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/skus", pathParameters), 1114 autorest.WithQueryParameters(queryParameters)) 1115 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1116} 1117 1118// GetValidSkusSender sends the GetValidSkus request. The method will close the 1119// http.Response Body if it receives an error. 1120func (client IotHubResourceClient) GetValidSkusSender(req *http.Request) (*http.Response, error) { 1121 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1122} 1123 1124// GetValidSkusResponder handles the response to the GetValidSkus request. The method always 1125// closes the http.Response Body. 1126func (client IotHubResourceClient) GetValidSkusResponder(resp *http.Response) (result IotHubSkuDescriptionListResult, err error) { 1127 err = autorest.Respond( 1128 resp, 1129 azure.WithErrorUnlessStatusCode(http.StatusOK), 1130 autorest.ByUnmarshallingJSON(&result), 1131 autorest.ByClosing()) 1132 result.Response = autorest.Response{Response: resp} 1133 return 1134} 1135 1136// getValidSkusNextResults retrieves the next set of results, if any. 1137func (client IotHubResourceClient) getValidSkusNextResults(ctx context.Context, lastResults IotHubSkuDescriptionListResult) (result IotHubSkuDescriptionListResult, err error) { 1138 req, err := lastResults.iotHubSkuDescriptionListResultPreparer(ctx) 1139 if err != nil { 1140 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", nil, "Failure preparing next results request") 1141 } 1142 if req == nil { 1143 return 1144 } 1145 resp, err := client.GetValidSkusSender(req) 1146 if err != nil { 1147 result.Response = autorest.Response{Response: resp} 1148 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", resp, "Failure sending next results request") 1149 } 1150 result, err = client.GetValidSkusResponder(resp) 1151 if err != nil { 1152 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", resp, "Failure responding to next results request") 1153 } 1154 return 1155} 1156 1157// GetValidSkusComplete enumerates all values, automatically crossing page boundaries as required. 1158func (client IotHubResourceClient) GetValidSkusComplete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubSkuDescriptionListResultIterator, err error) { 1159 if tracing.IsEnabled() { 1160 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetValidSkus") 1161 defer func() { 1162 sc := -1 1163 if result.Response().Response.Response != nil { 1164 sc = result.page.Response().Response.Response.StatusCode 1165 } 1166 tracing.EndSpan(ctx, sc, err) 1167 }() 1168 } 1169 result.page, err = client.GetValidSkus(ctx, resourceGroupName, resourceName) 1170 return 1171} 1172 1173// ImportDevices import, update, or delete device identities in the IoT hub identity registry from a blob. For more 1174// information, see: 1175// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities. 1176// Parameters: 1177// resourceGroupName - the name of the resource group that contains the IoT hub. 1178// resourceName - the name of the IoT hub. 1179// importDevicesParameters - the parameters that specify the import devices operation. 1180func (client IotHubResourceClient) ImportDevices(ctx context.Context, resourceGroupName string, resourceName string, importDevicesParameters ImportDevicesRequest) (result JobResponse, err error) { 1181 if tracing.IsEnabled() { 1182 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ImportDevices") 1183 defer func() { 1184 sc := -1 1185 if result.Response.Response != nil { 1186 sc = result.Response.Response.StatusCode 1187 } 1188 tracing.EndSpan(ctx, sc, err) 1189 }() 1190 } 1191 if err := validation.Validate([]validation.Validation{ 1192 {TargetValue: importDevicesParameters, 1193 Constraints: []validation.Constraint{{Target: "importDevicesParameters.InputBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil}, 1194 {Target: "importDevicesParameters.OutputBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 1195 return result, validation.NewError("devices.IotHubResourceClient", "ImportDevices", err.Error()) 1196 } 1197 1198 req, err := client.ImportDevicesPreparer(ctx, resourceGroupName, resourceName, importDevicesParameters) 1199 if err != nil { 1200 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", nil, "Failure preparing request") 1201 return 1202 } 1203 1204 resp, err := client.ImportDevicesSender(req) 1205 if err != nil { 1206 result.Response = autorest.Response{Response: resp} 1207 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", resp, "Failure sending request") 1208 return 1209 } 1210 1211 result, err = client.ImportDevicesResponder(resp) 1212 if err != nil { 1213 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", resp, "Failure responding to request") 1214 return 1215 } 1216 1217 return 1218} 1219 1220// ImportDevicesPreparer prepares the ImportDevices request. 1221func (client IotHubResourceClient) ImportDevicesPreparer(ctx context.Context, resourceGroupName string, resourceName string, importDevicesParameters ImportDevicesRequest) (*http.Request, error) { 1222 pathParameters := map[string]interface{}{ 1223 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1224 "resourceName": autorest.Encode("path", resourceName), 1225 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1226 } 1227 1228 const APIVersion = "2016-02-03" 1229 queryParameters := map[string]interface{}{ 1230 "api-version": APIVersion, 1231 } 1232 1233 preparer := autorest.CreatePreparer( 1234 autorest.AsContentType("application/json; charset=utf-8"), 1235 autorest.AsPost(), 1236 autorest.WithBaseURL(client.BaseURI), 1237 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/importDevices", pathParameters), 1238 autorest.WithJSON(importDevicesParameters), 1239 autorest.WithQueryParameters(queryParameters)) 1240 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1241} 1242 1243// ImportDevicesSender sends the ImportDevices request. The method will close the 1244// http.Response Body if it receives an error. 1245func (client IotHubResourceClient) ImportDevicesSender(req *http.Request) (*http.Response, error) { 1246 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1247} 1248 1249// ImportDevicesResponder handles the response to the ImportDevices request. The method always 1250// closes the http.Response Body. 1251func (client IotHubResourceClient) ImportDevicesResponder(resp *http.Response) (result JobResponse, err error) { 1252 err = autorest.Respond( 1253 resp, 1254 azure.WithErrorUnlessStatusCode(http.StatusOK), 1255 autorest.ByUnmarshallingJSON(&result), 1256 autorest.ByClosing()) 1257 result.Response = autorest.Response{Response: resp} 1258 return 1259} 1260 1261// ListByResourceGroup get all the IoT hubs in a resource group. 1262// Parameters: 1263// resourceGroupName - the name of the resource group that contains the IoT hubs. 1264func (client IotHubResourceClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result IotHubDescriptionListResultPage, err error) { 1265 if tracing.IsEnabled() { 1266 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListByResourceGroup") 1267 defer func() { 1268 sc := -1 1269 if result.ihdlr.Response.Response != nil { 1270 sc = result.ihdlr.Response.Response.StatusCode 1271 } 1272 tracing.EndSpan(ctx, sc, err) 1273 }() 1274 } 1275 result.fn = client.listByResourceGroupNextResults 1276 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 1277 if err != nil { 1278 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", nil, "Failure preparing request") 1279 return 1280 } 1281 1282 resp, err := client.ListByResourceGroupSender(req) 1283 if err != nil { 1284 result.ihdlr.Response = autorest.Response{Response: resp} 1285 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", resp, "Failure sending request") 1286 return 1287 } 1288 1289 result.ihdlr, err = client.ListByResourceGroupResponder(resp) 1290 if err != nil { 1291 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", resp, "Failure responding to request") 1292 return 1293 } 1294 if result.ihdlr.hasNextLink() && result.ihdlr.IsEmpty() { 1295 err = result.NextWithContext(ctx) 1296 return 1297 } 1298 1299 return 1300} 1301 1302// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 1303func (client IotHubResourceClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 1304 pathParameters := map[string]interface{}{ 1305 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1306 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1307 } 1308 1309 const APIVersion = "2016-02-03" 1310 queryParameters := map[string]interface{}{ 1311 "api-version": APIVersion, 1312 } 1313 1314 preparer := autorest.CreatePreparer( 1315 autorest.AsGet(), 1316 autorest.WithBaseURL(client.BaseURI), 1317 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs", pathParameters), 1318 autorest.WithQueryParameters(queryParameters)) 1319 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1320} 1321 1322// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 1323// http.Response Body if it receives an error. 1324func (client IotHubResourceClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 1325 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1326} 1327 1328// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 1329// closes the http.Response Body. 1330func (client IotHubResourceClient) ListByResourceGroupResponder(resp *http.Response) (result IotHubDescriptionListResult, err error) { 1331 err = autorest.Respond( 1332 resp, 1333 azure.WithErrorUnlessStatusCode(http.StatusOK), 1334 autorest.ByUnmarshallingJSON(&result), 1335 autorest.ByClosing()) 1336 result.Response = autorest.Response{Response: resp} 1337 return 1338} 1339 1340// listByResourceGroupNextResults retrieves the next set of results, if any. 1341func (client IotHubResourceClient) listByResourceGroupNextResults(ctx context.Context, lastResults IotHubDescriptionListResult) (result IotHubDescriptionListResult, err error) { 1342 req, err := lastResults.iotHubDescriptionListResultPreparer(ctx) 1343 if err != nil { 1344 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 1345 } 1346 if req == nil { 1347 return 1348 } 1349 resp, err := client.ListByResourceGroupSender(req) 1350 if err != nil { 1351 result.Response = autorest.Response{Response: resp} 1352 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 1353 } 1354 result, err = client.ListByResourceGroupResponder(resp) 1355 if err != nil { 1356 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 1357 } 1358 return 1359} 1360 1361// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 1362func (client IotHubResourceClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result IotHubDescriptionListResultIterator, err error) { 1363 if tracing.IsEnabled() { 1364 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListByResourceGroup") 1365 defer func() { 1366 sc := -1 1367 if result.Response().Response.Response != nil { 1368 sc = result.page.Response().Response.Response.StatusCode 1369 } 1370 tracing.EndSpan(ctx, sc, err) 1371 }() 1372 } 1373 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 1374 return 1375} 1376 1377// ListBySubscription get all the IoT hubs in a subscription. 1378func (client IotHubResourceClient) ListBySubscription(ctx context.Context) (result IotHubDescriptionListResultPage, err error) { 1379 if tracing.IsEnabled() { 1380 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListBySubscription") 1381 defer func() { 1382 sc := -1 1383 if result.ihdlr.Response.Response != nil { 1384 sc = result.ihdlr.Response.Response.StatusCode 1385 } 1386 tracing.EndSpan(ctx, sc, err) 1387 }() 1388 } 1389 result.fn = client.listBySubscriptionNextResults 1390 req, err := client.ListBySubscriptionPreparer(ctx) 1391 if err != nil { 1392 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", nil, "Failure preparing request") 1393 return 1394 } 1395 1396 resp, err := client.ListBySubscriptionSender(req) 1397 if err != nil { 1398 result.ihdlr.Response = autorest.Response{Response: resp} 1399 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", resp, "Failure sending request") 1400 return 1401 } 1402 1403 result.ihdlr, err = client.ListBySubscriptionResponder(resp) 1404 if err != nil { 1405 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", resp, "Failure responding to request") 1406 return 1407 } 1408 if result.ihdlr.hasNextLink() && result.ihdlr.IsEmpty() { 1409 err = result.NextWithContext(ctx) 1410 return 1411 } 1412 1413 return 1414} 1415 1416// ListBySubscriptionPreparer prepares the ListBySubscription request. 1417func (client IotHubResourceClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) { 1418 pathParameters := map[string]interface{}{ 1419 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1420 } 1421 1422 const APIVersion = "2016-02-03" 1423 queryParameters := map[string]interface{}{ 1424 "api-version": APIVersion, 1425 } 1426 1427 preparer := autorest.CreatePreparer( 1428 autorest.AsGet(), 1429 autorest.WithBaseURL(client.BaseURI), 1430 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/IotHubs", pathParameters), 1431 autorest.WithQueryParameters(queryParameters)) 1432 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1433} 1434 1435// ListBySubscriptionSender sends the ListBySubscription request. The method will close the 1436// http.Response Body if it receives an error. 1437func (client IotHubResourceClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { 1438 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1439} 1440 1441// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always 1442// closes the http.Response Body. 1443func (client IotHubResourceClient) ListBySubscriptionResponder(resp *http.Response) (result IotHubDescriptionListResult, err error) { 1444 err = autorest.Respond( 1445 resp, 1446 azure.WithErrorUnlessStatusCode(http.StatusOK), 1447 autorest.ByUnmarshallingJSON(&result), 1448 autorest.ByClosing()) 1449 result.Response = autorest.Response{Response: resp} 1450 return 1451} 1452 1453// listBySubscriptionNextResults retrieves the next set of results, if any. 1454func (client IotHubResourceClient) listBySubscriptionNextResults(ctx context.Context, lastResults IotHubDescriptionListResult) (result IotHubDescriptionListResult, err error) { 1455 req, err := lastResults.iotHubDescriptionListResultPreparer(ctx) 1456 if err != nil { 1457 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request") 1458 } 1459 if req == nil { 1460 return 1461 } 1462 resp, err := client.ListBySubscriptionSender(req) 1463 if err != nil { 1464 result.Response = autorest.Response{Response: resp} 1465 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", resp, "Failure sending next results request") 1466 } 1467 result, err = client.ListBySubscriptionResponder(resp) 1468 if err != nil { 1469 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request") 1470 } 1471 return 1472} 1473 1474// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required. 1475func (client IotHubResourceClient) ListBySubscriptionComplete(ctx context.Context) (result IotHubDescriptionListResultIterator, err error) { 1476 if tracing.IsEnabled() { 1477 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListBySubscription") 1478 defer func() { 1479 sc := -1 1480 if result.Response().Response.Response != nil { 1481 sc = result.page.Response().Response.Response.StatusCode 1482 } 1483 tracing.EndSpan(ctx, sc, err) 1484 }() 1485 } 1486 result.page, err = client.ListBySubscription(ctx) 1487 return 1488} 1489 1490// ListEventHubConsumerGroups get a list of the consumer groups in the Event Hub-compatible device-to-cloud endpoint in 1491// an IoT hub. 1492// Parameters: 1493// resourceGroupName - the name of the resource group that contains the IoT hub. 1494// resourceName - the name of the IoT hub. 1495// eventHubEndpointName - the name of the Event Hub-compatible endpoint. 1496func (client IotHubResourceClient) ListEventHubConsumerGroups(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (result EventHubConsumerGroupsListResultPage, err error) { 1497 if tracing.IsEnabled() { 1498 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListEventHubConsumerGroups") 1499 defer func() { 1500 sc := -1 1501 if result.ehcglr.Response.Response != nil { 1502 sc = result.ehcglr.Response.Response.StatusCode 1503 } 1504 tracing.EndSpan(ctx, sc, err) 1505 }() 1506 } 1507 result.fn = client.listEventHubConsumerGroupsNextResults 1508 req, err := client.ListEventHubConsumerGroupsPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName) 1509 if err != nil { 1510 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", nil, "Failure preparing request") 1511 return 1512 } 1513 1514 resp, err := client.ListEventHubConsumerGroupsSender(req) 1515 if err != nil { 1516 result.ehcglr.Response = autorest.Response{Response: resp} 1517 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", resp, "Failure sending request") 1518 return 1519 } 1520 1521 result.ehcglr, err = client.ListEventHubConsumerGroupsResponder(resp) 1522 if err != nil { 1523 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", resp, "Failure responding to request") 1524 return 1525 } 1526 if result.ehcglr.hasNextLink() && result.ehcglr.IsEmpty() { 1527 err = result.NextWithContext(ctx) 1528 return 1529 } 1530 1531 return 1532} 1533 1534// ListEventHubConsumerGroupsPreparer prepares the ListEventHubConsumerGroups request. 1535func (client IotHubResourceClient) ListEventHubConsumerGroupsPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (*http.Request, error) { 1536 pathParameters := map[string]interface{}{ 1537 "eventHubEndpointName": autorest.Encode("path", eventHubEndpointName), 1538 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1539 "resourceName": autorest.Encode("path", resourceName), 1540 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1541 } 1542 1543 const APIVersion = "2016-02-03" 1544 queryParameters := map[string]interface{}{ 1545 "api-version": APIVersion, 1546 } 1547 1548 preparer := autorest.CreatePreparer( 1549 autorest.AsGet(), 1550 autorest.WithBaseURL(client.BaseURI), 1551 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups", pathParameters), 1552 autorest.WithQueryParameters(queryParameters)) 1553 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1554} 1555 1556// ListEventHubConsumerGroupsSender sends the ListEventHubConsumerGroups request. The method will close the 1557// http.Response Body if it receives an error. 1558func (client IotHubResourceClient) ListEventHubConsumerGroupsSender(req *http.Request) (*http.Response, error) { 1559 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1560} 1561 1562// ListEventHubConsumerGroupsResponder handles the response to the ListEventHubConsumerGroups request. The method always 1563// closes the http.Response Body. 1564func (client IotHubResourceClient) ListEventHubConsumerGroupsResponder(resp *http.Response) (result EventHubConsumerGroupsListResult, err error) { 1565 err = autorest.Respond( 1566 resp, 1567 azure.WithErrorUnlessStatusCode(http.StatusOK), 1568 autorest.ByUnmarshallingJSON(&result), 1569 autorest.ByClosing()) 1570 result.Response = autorest.Response{Response: resp} 1571 return 1572} 1573 1574// listEventHubConsumerGroupsNextResults retrieves the next set of results, if any. 1575func (client IotHubResourceClient) listEventHubConsumerGroupsNextResults(ctx context.Context, lastResults EventHubConsumerGroupsListResult) (result EventHubConsumerGroupsListResult, err error) { 1576 req, err := lastResults.eventHubConsumerGroupsListResultPreparer(ctx) 1577 if err != nil { 1578 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", nil, "Failure preparing next results request") 1579 } 1580 if req == nil { 1581 return 1582 } 1583 resp, err := client.ListEventHubConsumerGroupsSender(req) 1584 if err != nil { 1585 result.Response = autorest.Response{Response: resp} 1586 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", resp, "Failure sending next results request") 1587 } 1588 result, err = client.ListEventHubConsumerGroupsResponder(resp) 1589 if err != nil { 1590 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", resp, "Failure responding to next results request") 1591 } 1592 return 1593} 1594 1595// ListEventHubConsumerGroupsComplete enumerates all values, automatically crossing page boundaries as required. 1596func (client IotHubResourceClient) ListEventHubConsumerGroupsComplete(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (result EventHubConsumerGroupsListResultIterator, err error) { 1597 if tracing.IsEnabled() { 1598 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListEventHubConsumerGroups") 1599 defer func() { 1600 sc := -1 1601 if result.Response().Response.Response != nil { 1602 sc = result.page.Response().Response.Response.StatusCode 1603 } 1604 tracing.EndSpan(ctx, sc, err) 1605 }() 1606 } 1607 result.page, err = client.ListEventHubConsumerGroups(ctx, resourceGroupName, resourceName, eventHubEndpointName) 1608 return 1609} 1610 1611// ListJobs get a list of all the jobs in an IoT hub. For more information, see: 1612// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry. 1613// Parameters: 1614// resourceGroupName - the name of the resource group that contains the IoT hub. 1615// resourceName - the name of the IoT hub. 1616func (client IotHubResourceClient) ListJobs(ctx context.Context, resourceGroupName string, resourceName string) (result JobResponseListResultPage, err error) { 1617 if tracing.IsEnabled() { 1618 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListJobs") 1619 defer func() { 1620 sc := -1 1621 if result.jrlr.Response.Response != nil { 1622 sc = result.jrlr.Response.Response.StatusCode 1623 } 1624 tracing.EndSpan(ctx, sc, err) 1625 }() 1626 } 1627 result.fn = client.listJobsNextResults 1628 req, err := client.ListJobsPreparer(ctx, resourceGroupName, resourceName) 1629 if err != nil { 1630 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", nil, "Failure preparing request") 1631 return 1632 } 1633 1634 resp, err := client.ListJobsSender(req) 1635 if err != nil { 1636 result.jrlr.Response = autorest.Response{Response: resp} 1637 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", resp, "Failure sending request") 1638 return 1639 } 1640 1641 result.jrlr, err = client.ListJobsResponder(resp) 1642 if err != nil { 1643 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", resp, "Failure responding to request") 1644 return 1645 } 1646 if result.jrlr.hasNextLink() && result.jrlr.IsEmpty() { 1647 err = result.NextWithContext(ctx) 1648 return 1649 } 1650 1651 return 1652} 1653 1654// ListJobsPreparer prepares the ListJobs request. 1655func (client IotHubResourceClient) ListJobsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1656 pathParameters := map[string]interface{}{ 1657 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1658 "resourceName": autorest.Encode("path", resourceName), 1659 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1660 } 1661 1662 const APIVersion = "2016-02-03" 1663 queryParameters := map[string]interface{}{ 1664 "api-version": APIVersion, 1665 } 1666 1667 preparer := autorest.CreatePreparer( 1668 autorest.AsGet(), 1669 autorest.WithBaseURL(client.BaseURI), 1670 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/jobs", pathParameters), 1671 autorest.WithQueryParameters(queryParameters)) 1672 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1673} 1674 1675// ListJobsSender sends the ListJobs request. The method will close the 1676// http.Response Body if it receives an error. 1677func (client IotHubResourceClient) ListJobsSender(req *http.Request) (*http.Response, error) { 1678 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1679} 1680 1681// ListJobsResponder handles the response to the ListJobs request. The method always 1682// closes the http.Response Body. 1683func (client IotHubResourceClient) ListJobsResponder(resp *http.Response) (result JobResponseListResult, err error) { 1684 err = autorest.Respond( 1685 resp, 1686 azure.WithErrorUnlessStatusCode(http.StatusOK), 1687 autorest.ByUnmarshallingJSON(&result), 1688 autorest.ByClosing()) 1689 result.Response = autorest.Response{Response: resp} 1690 return 1691} 1692 1693// listJobsNextResults retrieves the next set of results, if any. 1694func (client IotHubResourceClient) listJobsNextResults(ctx context.Context, lastResults JobResponseListResult) (result JobResponseListResult, err error) { 1695 req, err := lastResults.jobResponseListResultPreparer(ctx) 1696 if err != nil { 1697 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", nil, "Failure preparing next results request") 1698 } 1699 if req == nil { 1700 return 1701 } 1702 resp, err := client.ListJobsSender(req) 1703 if err != nil { 1704 result.Response = autorest.Response{Response: resp} 1705 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", resp, "Failure sending next results request") 1706 } 1707 result, err = client.ListJobsResponder(resp) 1708 if err != nil { 1709 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", resp, "Failure responding to next results request") 1710 } 1711 return 1712} 1713 1714// ListJobsComplete enumerates all values, automatically crossing page boundaries as required. 1715func (client IotHubResourceClient) ListJobsComplete(ctx context.Context, resourceGroupName string, resourceName string) (result JobResponseListResultIterator, err error) { 1716 if tracing.IsEnabled() { 1717 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListJobs") 1718 defer func() { 1719 sc := -1 1720 if result.Response().Response.Response != nil { 1721 sc = result.page.Response().Response.Response.StatusCode 1722 } 1723 tracing.EndSpan(ctx, sc, err) 1724 }() 1725 } 1726 result.page, err = client.ListJobs(ctx, resourceGroupName, resourceName) 1727 return 1728} 1729 1730// ListKeys get the security metadata for an IoT hub. For more information, see: 1731// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-security. 1732// Parameters: 1733// resourceGroupName - the name of the resource group that contains the IoT hub. 1734// resourceName - the name of the IoT hub. 1735func (client IotHubResourceClient) ListKeys(ctx context.Context, resourceGroupName string, resourceName string) (result SharedAccessSignatureAuthorizationRuleListResultPage, err error) { 1736 if tracing.IsEnabled() { 1737 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListKeys") 1738 defer func() { 1739 sc := -1 1740 if result.sasarlr.Response.Response != nil { 1741 sc = result.sasarlr.Response.Response.StatusCode 1742 } 1743 tracing.EndSpan(ctx, sc, err) 1744 }() 1745 } 1746 result.fn = client.listKeysNextResults 1747 req, err := client.ListKeysPreparer(ctx, resourceGroupName, resourceName) 1748 if err != nil { 1749 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", nil, "Failure preparing request") 1750 return 1751 } 1752 1753 resp, err := client.ListKeysSender(req) 1754 if err != nil { 1755 result.sasarlr.Response = autorest.Response{Response: resp} 1756 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", resp, "Failure sending request") 1757 return 1758 } 1759 1760 result.sasarlr, err = client.ListKeysResponder(resp) 1761 if err != nil { 1762 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", resp, "Failure responding to request") 1763 return 1764 } 1765 if result.sasarlr.hasNextLink() && result.sasarlr.IsEmpty() { 1766 err = result.NextWithContext(ctx) 1767 return 1768 } 1769 1770 return 1771} 1772 1773// ListKeysPreparer prepares the ListKeys request. 1774func (client IotHubResourceClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 1775 pathParameters := map[string]interface{}{ 1776 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1777 "resourceName": autorest.Encode("path", resourceName), 1778 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1779 } 1780 1781 const APIVersion = "2016-02-03" 1782 queryParameters := map[string]interface{}{ 1783 "api-version": APIVersion, 1784 } 1785 1786 preparer := autorest.CreatePreparer( 1787 autorest.AsPost(), 1788 autorest.WithBaseURL(client.BaseURI), 1789 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/listkeys", pathParameters), 1790 autorest.WithQueryParameters(queryParameters)) 1791 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1792} 1793 1794// ListKeysSender sends the ListKeys request. The method will close the 1795// http.Response Body if it receives an error. 1796func (client IotHubResourceClient) ListKeysSender(req *http.Request) (*http.Response, error) { 1797 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1798} 1799 1800// ListKeysResponder handles the response to the ListKeys request. The method always 1801// closes the http.Response Body. 1802func (client IotHubResourceClient) ListKeysResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRuleListResult, err error) { 1803 err = autorest.Respond( 1804 resp, 1805 azure.WithErrorUnlessStatusCode(http.StatusOK), 1806 autorest.ByUnmarshallingJSON(&result), 1807 autorest.ByClosing()) 1808 result.Response = autorest.Response{Response: resp} 1809 return 1810} 1811 1812// listKeysNextResults retrieves the next set of results, if any. 1813func (client IotHubResourceClient) listKeysNextResults(ctx context.Context, lastResults SharedAccessSignatureAuthorizationRuleListResult) (result SharedAccessSignatureAuthorizationRuleListResult, err error) { 1814 req, err := lastResults.sharedAccessSignatureAuthorizationRuleListResultPreparer(ctx) 1815 if err != nil { 1816 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", nil, "Failure preparing next results request") 1817 } 1818 if req == nil { 1819 return 1820 } 1821 resp, err := client.ListKeysSender(req) 1822 if err != nil { 1823 result.Response = autorest.Response{Response: resp} 1824 return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", resp, "Failure sending next results request") 1825 } 1826 result, err = client.ListKeysResponder(resp) 1827 if err != nil { 1828 err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", resp, "Failure responding to next results request") 1829 } 1830 return 1831} 1832 1833// ListKeysComplete enumerates all values, automatically crossing page boundaries as required. 1834func (client IotHubResourceClient) ListKeysComplete(ctx context.Context, resourceGroupName string, resourceName string) (result SharedAccessSignatureAuthorizationRuleListResultIterator, err error) { 1835 if tracing.IsEnabled() { 1836 ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListKeys") 1837 defer func() { 1838 sc := -1 1839 if result.Response().Response.Response != nil { 1840 sc = result.page.Response().Response.Response.StatusCode 1841 } 1842 tracing.EndSpan(ctx, sc, err) 1843 }() 1844 } 1845 result.page, err = client.ListKeys(ctx, resourceGroupName, resourceName) 1846 return 1847} 1848