Source file src/github.com/Azure/azure-sdk-for-go/services/iothub/mgmt/2016-02-03/devices/iothubresource.go

Documentation: github.com/Azure/azure-sdk-for-go/services/iothub/mgmt/2016-02-03/devices

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

View as plain text