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