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