private void EnsureNameAvailabilityOrThrow()
{
var checkNameInputs = new OperationInputs(this.Name, resourceType);
var nameAvailabilityInfo = this.IotCentralClient.Apps.CheckNameAvailability(checkNameInputs);
IotCentralUtils.EnsureAvailabilityOrThrow(nameAvailabilityInfo);
}
private void EnsureSubdomainAvailabilityOrThrow()
{
var checkSubdomainInputs = new OperationInputs(this.Subdomain, resourceType);
var subdomainAvailabilityInfo = this.IotCentralClient.Apps.CheckSubdomainAvailability(checkSubdomainInputs);
IotCentralUtils.EnsureAvailabilityOrThrow(subdomainAvailabilityInfo);
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(Name, ResourceProperties.Resources.NewIotCentralApp))
{
var inputs = new OperationInputs(this.Name, "IotApps");
var availabilityInfo = this.IotCentralClient.Apps.CheckNameAvailability(inputs);
if (!(availabilityInfo.NameAvailable == true))
{
throw new PSArgumentException(availabilityInfo.Message);
}
var iotCentralApp = new App()
{
DisplayName = this.GetDisplayName(),
Subdomain = this.Subdomain,
Template = this.Template,
Sku = new AppSkuInfo()
{
Name = this.GetAppSkuName()
},
Location = this.GetLocation(),
Tags = this.GetTags()
};
this.IotCentralClient.Apps.CreateOrUpdate(this.ResourceGroupName, this.Name, iotCentralApp);
App createdIotCentralApp = this.IotCentralClient.Apps.Get(this.ResourceGroupName, this.Name);
this.WriteObject(IotCentralUtils.ToPSIotCentralApp(createdIotCentralApp), false);
}
}
/// <summary>
/// Checks whether given IoTHub name is available.
/// </summary>
/// <param name="iotHubName"></param>
/// <param name="cancellationToken"></param>
/// <returns>True if name is available, False otherwise.</returns>
public async Task <bool> CheckNameAvailabilityAsync(
string iotHubName,
CancellationToken cancellationToken = default
)
{
try {
var operationInputs = new OperationInputs {
Name = iotHubName
};
var nameAvailabilityInfo = await _iotHubClient
.IotHubResource
.CheckNameAvailabilityAsync(
operationInputs,
cancellationToken
);
if (nameAvailabilityInfo.NameAvailable.HasValue)
{
return(nameAvailabilityInfo.NameAvailable.Value);
}
}
catch (Exception ex) {
Log.Error(ex, $"Failed to check IoTHub Service name availability for {iotHubName}");
throw;
}
// !nameAvailabilityInfo.NameAvailable.HasValue
throw new Exception($"Failed to check IoTHub Service name availability for {iotHubName}");
}
static void Main()
{
// Access token from the azure-cli
// az account get-access-token
var token = "";
var subscriptionId = "";
var creds = new TokenCredentials(token, "Bearer");
var client = new IotCentralClient(creds);
var skuInfo = new AppSkuInfo("ST2");
var location = "unitedstates";
var app = new App(location, skuInfo);
client.SubscriptionId = subscriptionId;
var name = "csharp-test-app";
var resourceGroup = "myResourceGroup";
app.Location = location;
app.Subdomain = name;
app.DisplayName = name;
Console.WriteLine("Check if the app name is available");
OperationInputs input = new OperationInputs(name);
var nameAvailable = client.Apps.CheckNameAvailability(input);
Console.WriteLine(nameAvailable.Message);
Console.WriteLine("Creating the app");
client.Apps.CreateOrUpdate(resourceGroup, name, app);
Console.WriteLine("Getting the app");
var resultApp = client.Apps.Get(resourceGroup, name);
Console.WriteLine(resultApp);
Console.WriteLine("Updating the app");
var updateApp = new AppPatch();
updateApp.DisplayName = name + "-new-name";
var updateResult = client.Apps.Update(resourceGroup, name, updateApp);
Console.WriteLine(updateResult);
Console.WriteLine("Listing apps");
foreach (var currentApp in client.Apps.ListByResourceGroup(resourceGroup))
{
Console.WriteLine($"{currentApp.DisplayName} ({currentApp.Id})");
}
Console.WriteLine(Environment.NewLine);
// Console.WriteLine("Removing app");
// client.Apps.Delete(resourceGroup, name);
Console.WriteLine("Done");
}
public virtual Response <AppAvailabilityInfo> CheckSubdomainAvailabilityApp(OperationInputs operationInputs, CancellationToken cancellationToken = default)
{
using var scope = IotCentralAppAppsClientDiagnostics.CreateScope("SubscriptionResourceExtensionClient.CheckSubdomainAvailabilityApp");
scope.Start();
try
{
var response = IotCentralAppAppsRestClient.CheckSubdomainAvailability(Id.SubscriptionId, operationInputs, cancellationToken);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public void TestOperationInputsWhenInvalidInput()
{
var exceptionThrown = false;
try
{
var nameInput = "SOMEINVALIDINPUT";
OperationInputs operationInput = new OperationInputs(nameInput);
operationInput.Validate();
}
catch (Exception ex)
{
exceptionThrown = true;
Assert.Equal(typeof(ValidationException), ex.GetType());
}
Assert.True(exceptionThrown);
}
/// <summary>
/// Checks whether given IoTHub name is available.
/// </summary>
/// <param name="iotHubName"></param>
/// <param name="cancellationToken"></param>
/// <returns>True if name is available, False otherwise.</returns>
/// <exception cref="Microsoft.Rest.Azure.CloudException"></exception>
public async Task <bool> CheckNameAvailabilityAsync(
string iotHubName,
CancellationToken cancellationToken = default
)
{
try {
var operationInputs = new OperationInputs {
Name = iotHubName
};
var nameAvailabilityInfo = await _iotHubClient
.IotHubResource
.CheckNameAvailabilityAsync(
operationInputs,
cancellationToken
);
if (nameAvailabilityInfo.NameAvailable.HasValue)
{
return(nameAvailabilityInfo.NameAvailable.Value);
}
}
catch (Microsoft.Rest.Azure.CloudException) {
// Will be thrown if there is no registered resource provider
// found for specified location and/or api version to perform
// name availability check.
throw;
}
catch (Exception ex) {
Log.Error(ex, $"Failed to check IoTHub Service name availability for {iotHubName}");
throw;
}
// !nameAvailabilityInfo.NameAvailable.HasValue
throw new Exception($"Failed to check IoTHub Service name availability for {iotHubName}");
}
public void TestIotHubUpdateLifeCycle()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
this.Initialize(context);
// Create Resource Group
var resourceGroup = this.CreateResourceGroup(IotHubTestUtilities.DefaultUpdateResourceGroupName);
// Check if Hub Exists and Delete
var operationInputs = new OperationInputs()
{
Name = IotHubTestUtilities.DefaultUpdateIotHubName
};
var iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
if (!(bool)iotHubNameAvailabilityInfo.NameAvailable)
{
this.iotHubClient.IotHubResource.Delete(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultUpdateIotHubName);
iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
Assert.True(iotHubNameAvailabilityInfo.NameAvailable);
}
var iotHub = this.CreateIotHub(resourceGroup, IotHubTestUtilities.DefaultLocation, IotHubTestUtilities.DefaultUpdateIotHubName, null);
Assert.NotNull(iotHub);
Assert.Equal(IotHubSku.S1, iotHub.Sku.Name);
Assert.Equal(IotHubTestUtilities.DefaultUpdateIotHubName, iotHub.Name);
// Update capacity
iotHub.Sku.Capacity += 1;
var retIotHub = this.UpdateIotHub(resourceGroup, iotHub, IotHubTestUtilities.DefaultUpdateIotHubName);
Assert.NotNull(retIotHub);
Assert.Equal(IotHubSku.S1, retIotHub.Sku.Name);
Assert.Equal(iotHub.Sku.Capacity, retIotHub.Sku.Capacity);
Assert.Equal(IotHubTestUtilities.DefaultUpdateIotHubName, retIotHub.Name);
// Update IotHub with routing rules
iotHub.Properties.Routing = this.GetIotHubRoutingProperties(resourceGroup);
retIotHub = this.UpdateIotHub(resourceGroup, iotHub, IotHubTestUtilities.DefaultUpdateIotHubName);
Assert.NotNull(retIotHub);
Assert.Equal(IotHubTestUtilities.DefaultUpdateIotHubName, retIotHub.Name);
Assert.Equal(4, retIotHub.Properties.Routing.Routes.Count);
Assert.Equal(1, retIotHub.Properties.Routing.Endpoints.EventHubs.Count);
Assert.Equal(1, retIotHub.Properties.Routing.Endpoints.ServiceBusTopics.Count);
Assert.Equal(1, retIotHub.Properties.Routing.Endpoints.ServiceBusQueues.Count);
Assert.Equal("route1", retIotHub.Properties.Routing.Routes[0].Name);
// Get an Iot Hub
var iotHubDesc = this.iotHubClient.IotHubResource.Get(
IotHubTestUtilities.DefaultUpdateResourceGroupName,
IotHubTestUtilities.DefaultUpdateIotHubName);
Assert.NotNull(iotHubDesc);
Assert.Equal(IotHubSku.S1, iotHubDesc.Sku.Name);
Assert.Equal(iotHub.Sku.Capacity, iotHubDesc.Sku.Capacity);
Assert.Equal(IotHubTestUtilities.DefaultUpdateIotHubName, iotHubDesc.Name);
// Update Again
// perform a dummy update
iotHubDesc.Properties.Routing.Endpoints.EventHubs[0].ResourceGroup = "1";
retIotHub = this.UpdateIotHub(resourceGroup, iotHubDesc, IotHubTestUtilities.DefaultUpdateIotHubName);
Assert.NotNull(retIotHub);
Assert.Equal(IotHubTestUtilities.DefaultUpdateIotHubName, retIotHub.Name);
Assert.Equal(4, retIotHub.Properties.Routing.Routes.Count);
Assert.Equal(1, retIotHub.Properties.Routing.Endpoints.EventHubs.Count);
Assert.Equal(1, retIotHub.Properties.Routing.Endpoints.ServiceBusTopics.Count);
Assert.Equal(1, retIotHub.Properties.Routing.Endpoints.ServiceBusQueues.Count);
Assert.Equal("route1", retIotHub.Properties.Routing.Routes[0].Name);
}
}
static void Main()
{
// Access token from the azure-cli
// az account get-access-token
var token = "";
var subscriptionId = "";
var creds = new TokenCredentials(token, "Bearer");
var client = new IotCentralClient(creds);
var skuInfo = new AppSkuInfo("ST2");
var location = "unitedstates";
var app = new App(location, skuInfo);
client.SubscriptionId = subscriptionId;
var name = "csharp-test-app";
var resourceGroup = "myResourceGroup";
app.Location = location;
app.Subdomain = name;
app.DisplayName = name;
Console.WriteLine("===Check if the app name is available");
OperationInputs input = new OperationInputs(name);
var appNameAvailability = client.Apps.CheckNameAvailability(input);
if (appNameAvailability.NameAvailable == true)
{
Console.WriteLine("app name is available!");
}
else
{
Console.WriteLine($"app name isn't available because {appNameAvailability.Reason}");
}
Console.WriteLine("===Creating the app");
var createApp = client.Apps.CreateOrUpdate(resourceGroup, name, app);
Console.WriteLine(createApp.Name);
Console.WriteLine(createApp.DisplayName);
Console.WriteLine("===Getting the app");
var resultApp = client.Apps.Get(resourceGroup, name);
Console.WriteLine(resultApp.Name);
Console.WriteLine(resultApp.DisplayName);
Console.WriteLine("===Updating the app");
var updateApp = new AppPatch();
updateApp.DisplayName = name + "-new-name";
var updateResult = client.Apps.Update(resourceGroup, name, updateApp);
Console.WriteLine(updateResult.Name);
Console.WriteLine(updateResult.DisplayName);
Console.WriteLine($"===Listing all the apps under the resource group of {resourceGroup}");
foreach (var currentApp in client.Apps.ListByResourceGroup(resourceGroup))
{
Console.WriteLine($"{currentApp.DisplayName} ({currentApp.Id})");
}
Console.WriteLine("===Listing all the operations in iotc");
foreach (var currentOperation in client.Operations.List())
{
Console.WriteLine(currentOperation.Name);
}
Console.WriteLine("===Listing all the app templates in iotc");
foreach (var currentAppTemplate in client.Apps.ListTemplates())
{
Console.WriteLine(currentAppTemplate.Name);
}
Console.WriteLine("===Removing app");
client.Apps.Delete(resourceGroup, name);
Console.WriteLine("Done");
}
public void TestIotHubLifeCycle()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
this.Initialize(context);
// Create Resource Group
var resourceGroup = this.CreateResourceGroup();
// Check if Hub Exists and Delete
var operationInputs = new OperationInputs()
{
Name = IotHubTestUtilities.DefaultIotHubName
};
var iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
if (!(bool)iotHubNameAvailabilityInfo.NameAvailable)
{
this.iotHubClient.IotHubResource.Delete(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
Assert.Equal(true, iotHubNameAvailabilityInfo.NameAvailable);
}
// Create Hub
var iotHub = this.CreateDefaultIotHub(resourceGroup);
Assert.NotNull(iotHub);
Assert.Equal(IotHubSku.S1, iotHub.Sku.Name);
Assert.Equal(IotHubTestUtilities.DefaultIotHubName, iotHub.Name);
// Get quota metrics
var quotaMetrics = this.iotHubClient.IotHubResource.GetQuotaMetrics(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
Assert.True(quotaMetrics.Count() > 0);
Assert.True(quotaMetrics.Any(q => q.Name.Equals("TotalMessages", StringComparison.OrdinalIgnoreCase) &&
q.CurrentValue == 0 &&
q.MaxValue == 400000));
Assert.True(quotaMetrics.Any(q => q.Name.Equals("TotalDeviceCount", StringComparison.OrdinalIgnoreCase) &&
q.CurrentValue == 0 &&
q.MaxValue == 500000));
// Update capacity
iotHub.Sku.Capacity += 1;
var retIotHub = this.UpdateIotHub(resourceGroup, iotHub);
Assert.NotNull(retIotHub);
Assert.Equal(IotHubSku.S1, retIotHub.Sku.Name);
Assert.Equal(iotHub.Sku.Capacity, retIotHub.Sku.Capacity);
Assert.Equal(IotHubTestUtilities.DefaultIotHubName, retIotHub.Name);
// Get an Iot Hub
var iotHubDesc = this.iotHubClient.IotHubResource.Get(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
Assert.NotNull(iotHubDesc);
Assert.Equal(IotHubSku.S1, iotHubDesc.Sku.Name);
Assert.Equal(iotHub.Sku.Capacity, iotHubDesc.Sku.Capacity);
Assert.Equal(IotHubTestUtilities.DefaultIotHubName, iotHubDesc.Name);
// Get all Iot Hubs in a resource group
var iotHubs = this.iotHubClient.IotHubResource.ListByResourceGroup(IotHubTestUtilities.DefaultResourceGroupName);
Assert.True(iotHubs.Count() > 0);
// Get Valid Skus
var skus = this.iotHubClient.IotHubResource.GetValidSkus(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
Assert.Equal(3, skus.Count());
// Get All Iothub Keys
var keys = this.iotHubClient.IotHubResource.ListKeys(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
Assert.True(keys.Count() > 0);
Assert.True(keys.Any(k => k.KeyName.Equals("iothubowner", StringComparison.OrdinalIgnoreCase)));
// Get specific IotHub Key
var key = this.iotHubClient.IotHubResource.GetKeysForKeyName(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
"iothubowner");
Assert.Equal("iothubowner", key.KeyName);
// Get All EH consumer groups
var ehConsumerGroups = this.iotHubClient.IotHubResource.ListEventHubConsumerGroups(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
IotHubTestUtilities.EventsEndpointName);
Assert.True(ehConsumerGroups.Count() > 0);
Assert.True(ehConsumerGroups.Any(e => e.Equals("$Default", StringComparison.OrdinalIgnoreCase)));
// Add EH consumer group
var ehConsumerGroup = this.iotHubClient.IotHubResource.CreateEventHubConsumerGroup(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
IotHubTestUtilities.EventsEndpointName,
"testConsumerGroup");
Assert.Equal("testConsumerGroup", ehConsumerGroup.Name);
// Get EH consumer group
ehConsumerGroup = this.iotHubClient.IotHubResource.GetEventHubConsumerGroup(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
IotHubTestUtilities.EventsEndpointName,
"testConsumerGroup");
Assert.Equal("testConsumerGroup", ehConsumerGroup.Name);
// Delete EH consumer group
this.iotHubClient.IotHubResource.DeleteEventHubConsumerGroup(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
IotHubTestUtilities.EventsEndpointName,
"testConsumerGroup");
// Delete Hub
this.iotHubClient.IotHubResource.Delete(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
Assert.Equal(true, iotHubNameAvailabilityInfo.NameAvailable);
}
}
public static async Task <Response <AppAvailabilityInfo> > CheckSubdomainAvailabilityAppAsync(this SubscriptionResource subscriptionResource, OperationInputs operationInputs, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(operationInputs, nameof(operationInputs));
return(await GetExtensionClient(subscriptionResource).CheckSubdomainAvailabilityAppAsync(operationInputs, cancellationToken).ConfigureAwait(false));
}
public static Response <AppAvailabilityInfo> CheckNameAvailabilityApp(this SubscriptionResource subscriptionResource, OperationInputs operationInputs, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(operationInputs, nameof(operationInputs));
return(GetExtensionClient(subscriptionResource).CheckNameAvailabilityApp(operationInputs, cancellationToken));
}
/// <summary>
/// Check if an IoT Central application subdomain is available.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='operationInputs'>
/// Set the name parameter in the OperationInputs structure to the subdomain of
/// the IoT Central application to check.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <AppAvailabilityInfo> CheckSubdomainAvailabilityAsync(this IAppsOperations operations, OperationInputs operationInputs, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CheckSubdomainAvailabilityWithHttpMessagesAsync(operationInputs, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public void TestIotHubCreateLifeCycle()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
this.Initialize(context);
// Create Resource Group
var resourceGroup = this.CreateResourceGroup(IotHubTestUtilities.DefaultResourceGroupName);
// Check if Hub Exists and Delete
var operationInputs = new OperationInputs()
{
Name = IotHubTestUtilities.DefaultIotHubName
};
var iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
if (!(bool)iotHubNameAvailabilityInfo.NameAvailable)
{
this.iotHubClient.IotHubResource.Delete(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
Assert.True(iotHubNameAvailabilityInfo.NameAvailable);
}
//CreateEH and AuthRule
var properties = new IotHubProperties();
properties.Routing = this.GetIotHubRoutingProperties(resourceGroup);
var iotHub = this.CreateIotHub(resourceGroup, IotHubTestUtilities.DefaultLocation, IotHubTestUtilities.DefaultIotHubName, properties);
Assert.NotNull(iotHub);
Assert.Equal(IotHubSku.S1, iotHub.Sku.Name);
Assert.Equal(IotHubTestUtilities.DefaultIotHubName, iotHub.Name);
// Add and Get Tags
IDictionary <string, string> tags = new Dictionary <string, string>();
tags.Add("key1", "value1");
tags.Add("key2", "value2");
var tag = new TagsResource(tags);
iotHub = this.iotHubClient.IotHubResource.Update(IotHubTestUtilities.DefaultResourceGroupName, IotHubTestUtilities.DefaultIotHubName, tag);
Assert.NotNull(iotHub);
Assert.True(iotHub.Tags.Count().Equals(2));
Assert.Equal("value2", iotHub.Tags["key2"]);
var subscriptionQuota = this.iotHubClient.ResourceProviderCommon.GetSubscriptionQuota();
Assert.Equal(2, subscriptionQuota.Value.Count);
Assert.Equal(1, subscriptionQuota.Value.FirstOrDefault(x => x.Name.Value.Equals("freeIotHubCount")).Limit);
Assert.Equal(100, subscriptionQuota.Value.FirstOrDefault(x => x.Name.Value.Equals("paidIotHubCount")).Limit);
var endpointHealth = this.iotHubClient.IotHubResource.GetEndpointHealth(IotHubTestUtilities.DefaultResourceGroupName, IotHubTestUtilities.DefaultIotHubName);
Assert.Equal(4, endpointHealth.Count());
Assert.Contains(endpointHealth, q => q.EndpointId.Equals("events", StringComparison.OrdinalIgnoreCase));
TestAllRoutesInput testAllRoutesInput = new TestAllRoutesInput(RoutingSource.DeviceMessages, new RoutingMessage(), new RoutingTwin());
TestAllRoutesResult testAllRoutesResult = this.iotHubClient.IotHubResource.TestAllRoutes(testAllRoutesInput, IotHubTestUtilities.DefaultIotHubName, IotHubTestUtilities.DefaultResourceGroupName);
Assert.Equal(4, testAllRoutesResult.Routes.Count);
TestRouteInput testRouteInput = new TestRouteInput(properties.Routing.Routes[0], new RoutingMessage(), new RoutingTwin());
TestRouteResult testRouteResult = this.iotHubClient.IotHubResource.TestRoute(testRouteInput, IotHubTestUtilities.DefaultIotHubName, IotHubTestUtilities.DefaultResourceGroupName);
Assert.Equal("true", testRouteResult.Result);
// Get quota metrics
var quotaMetrics = this.iotHubClient.IotHubResource.GetQuotaMetrics(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
Assert.True(quotaMetrics.Count() > 0);
Assert.Contains(quotaMetrics, q => q.Name.Equals("TotalMessages", StringComparison.OrdinalIgnoreCase) &&
q.CurrentValue == 0 &&
q.MaxValue == 400000);
Assert.Contains(quotaMetrics, q => q.Name.Equals("TotalDeviceCount", StringComparison.OrdinalIgnoreCase) &&
q.CurrentValue == 0 &&
q.MaxValue == 500000);
// Get all Iot Hubs in a resource group
var iotHubs = this.iotHubClient.IotHubResource.ListByResourceGroup(IotHubTestUtilities.DefaultResourceGroupName);
Assert.True(iotHubs.Count() > 0);
// Get all Iot Hubs in a subscription
var iotHubBySubscription = this.iotHubClient.IotHubResource.ListBySubscription();
Assert.True(iotHubBySubscription.Count() > 0);
// Get Registry Stats
var regStats = this.iotHubClient.IotHubResource.GetStats(IotHubTestUtilities.DefaultResourceGroupName, IotHubTestUtilities.DefaultIotHubName);
Assert.True(regStats.TotalDeviceCount.Value.Equals(0));
Assert.True(regStats.EnabledDeviceCount.Value.Equals(0));
Assert.True(regStats.DisabledDeviceCount.Value.Equals(0));
// Get Valid Skus
var skus = this.iotHubClient.IotHubResource.GetValidSkus(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
Assert.Equal(3, skus.Count());
// Get All Iothub Keys
var keys = this.iotHubClient.IotHubResource.ListKeys(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName);
Assert.True(keys.Count() > 0);
Assert.Contains(keys, k => k.KeyName.Equals("iothubowner", StringComparison.OrdinalIgnoreCase));
// Get specific IotHub Key
var key = this.iotHubClient.IotHubResource.GetKeysForKeyName(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
"iothubowner");
Assert.Equal("iothubowner", key.KeyName);
// Get All EH consumer groups
var ehConsumerGroups = this.iotHubClient.IotHubResource.ListEventHubConsumerGroups(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
IotHubTestUtilities.EventsEndpointName);
Assert.True(ehConsumerGroups.Count() > 0);
Assert.Contains(ehConsumerGroups, e => e.Name.Equals("$Default", StringComparison.OrdinalIgnoreCase));
// Add EH consumer group
var ehConsumerGroup = this.iotHubClient.IotHubResource.CreateEventHubConsumerGroup(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
IotHubTestUtilities.EventsEndpointName,
"testConsumerGroup");
Assert.Equal("testConsumerGroup", ehConsumerGroup.Name);
// Get EH consumer group
ehConsumerGroup = this.iotHubClient.IotHubResource.GetEventHubConsumerGroup(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
IotHubTestUtilities.EventsEndpointName,
"testConsumerGroup");
Assert.Equal("testConsumerGroup", ehConsumerGroup.Name);
// Delete EH consumer group
this.iotHubClient.IotHubResource.DeleteEventHubConsumerGroup(
IotHubTestUtilities.DefaultResourceGroupName,
IotHubTestUtilities.DefaultIotHubName,
IotHubTestUtilities.EventsEndpointName,
"testConsumerGroup");
// Get all of the available IoT Hub REST API operations
var operationList = this.iotHubClient.Operations.List();
Assert.True(operationList.Count() > 0);
Assert.Contains(operationList, e => e.Name.Equals("Microsoft.Devices/iotHubs/Read", StringComparison.OrdinalIgnoreCase));
// Get IoT Hub REST API read operation
var hubReadOperation = operationList.Where(e => e.Name.Equals("Microsoft.Devices/iotHubs/Read", StringComparison.OrdinalIgnoreCase));
Assert.True(hubReadOperation.Count().Equals(1));
Assert.Equal("Microsoft Devices", hubReadOperation.First().Display.Provider, ignoreCase: true);
Assert.Equal("Get IotHub(s)", hubReadOperation.First().Display.Operation, ignoreCase: true);
}
}
public virtual async Task <Response <AppAvailabilityInfo> > CheckNameAvailabilityAppAsync(OperationInputs operationInputs, CancellationToken cancellationToken = default)
{
using var scope = IotCentralAppAppsClientDiagnostics.CreateScope("SubscriptionResourceExtensionClient.CheckNameAvailabilityApp");
scope.Start();
try
{
var response = await IotCentralAppAppsRestClient.CheckNameAvailabilityAsync(Id.SubscriptionId, operationInputs, cancellationToken).ConfigureAwait(false);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Check if a provisioning service name is available.
/// </summary>
/// <remarks>
/// Check if a provisioning service name is available. This will validate if
/// the name is syntactically valid and if the name is usable
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='arguments'>
/// Set the name parameter in the OperationInputs structure to the name of the
/// provisioning service to check.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <NameAvailabilityInfo> CheckProvisioningServiceNameAvailabilityAsync(this IIotDpsResourceOperations operations, OperationInputs arguments, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CheckProvisioningServiceNameAvailabilityWithHttpMessagesAsync(arguments, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Check if a provisioning service name is available.
/// </summary>
/// <remarks>
/// Check if a provisioning service name is available. This will validate if
/// the name is syntactically valid and if the name is usable
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='arguments'>
/// Set the name parameter in the OperationInputs structure to the name of the
/// provisioning service to check.
/// </param>
public static NameAvailabilityInfo CheckProvisioningServiceNameAvailability(this IIotDpsResourceOperations operations, OperationInputs arguments)
{
return(operations.CheckProvisioningServiceNameAvailabilityAsync(arguments).GetAwaiter().GetResult());
}
public void TestIotHubCertificateLifeCycle()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
this.Initialize(context);
// Create Resource Group
var resourceGroup = this.CreateResourceGroup(IotHubTestUtilities.DefaultCertificateResourceGroupName);
// Check if Hub Exists and Delete
var operationInputs = new OperationInputs()
{
Name = IotHubTestUtilities.DefaultCertificateIotHubName
};
var iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
if (!(bool)iotHubNameAvailabilityInfo.NameAvailable)
{
this.iotHubClient.IotHubResource.Delete(
IotHubTestUtilities.DefaultCertificateResourceGroupName,
IotHubTestUtilities.DefaultCertificateIotHubName);
iotHubNameAvailabilityInfo = this.iotHubClient.IotHubResource.CheckNameAvailability(operationInputs);
Assert.True(iotHubNameAvailabilityInfo.NameAvailable);
}
// Create Hub
var iotHub = this.CreateIotHub(resourceGroup, IotHubTestUtilities.DefaultLocation, IotHubTestUtilities.DefaultCertificateIotHubName, null);
// Upload Certificate to the Hub
var newCertificateDescription = this.CreateCertificate(resourceGroup, IotHubTestUtilities.DefaultCertificateIotHubName, IotHubTestUtilities.DefaultIotHubCertificateName, IotHubTestUtilities.DefaultIotHubCertificateContent);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateName, newCertificateDescription.Name);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateSubject, newCertificateDescription.Properties.Subject);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateThumbprint, newCertificateDescription.Properties.Thumbprint);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateType, newCertificateDescription.Type);
Assert.False(newCertificateDescription.Properties.IsVerified);
// Get all certificates
var certificateList = this.GetCertificates(resourceGroup, IotHubTestUtilities.DefaultCertificateIotHubName);
Assert.True(certificateList.Value.Count().Equals(1));
// Get certificate
var certificate = this.GetCertificate(resourceGroup, IotHubTestUtilities.DefaultCertificateIotHubName, IotHubTestUtilities.DefaultIotHubCertificateName);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateName, certificate.Name);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateSubject, certificate.Properties.Subject);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateThumbprint, certificate.Properties.Thumbprint);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateType, certificate.Type);
Assert.False(certificate.Properties.IsVerified);
var certificateWithNonceDescription = this.GenerateVerificationCode(resourceGroup, IotHubTestUtilities.DefaultCertificateIotHubName, IotHubTestUtilities.DefaultIotHubCertificateName, certificate.Etag);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateName, certificateWithNonceDescription.Name);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateSubject, certificateWithNonceDescription.Properties.Subject);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateThumbprint, certificateWithNonceDescription.Properties.Thumbprint);
Assert.Equal(IotHubTestUtilities.DefaultIotHubCertificateType, certificateWithNonceDescription.Type);
Assert.False(certificateWithNonceDescription.Properties.IsVerified);
Assert.NotNull(certificateWithNonceDescription.Properties.VerificationCode);
// Delete certificate
this.DeleteCertificate(resourceGroup, IotHubTestUtilities.DefaultCertificateIotHubName, IotHubTestUtilities.DefaultIotHubCertificateName, certificateWithNonceDescription.Etag);
// Get all certificate after delete
var certificateListAfterDelete = this.GetCertificates(resourceGroup, IotHubTestUtilities.DefaultCertificateIotHubName);
Assert.True(certificateListAfterDelete.Value.Count().Equals(0));
}
}
/// <summary>
/// Check if an IoT Central application subdomain is available.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='operationInputs'>
/// Set the name parameter in the OperationInputs structure to the subdomain of
/// the IoT Central application to check.
/// </param>
public static AppAvailabilityInfo CheckSubdomainAvailability(this IAppsOperations operations, OperationInputs operationInputs)
{
return(operations.CheckSubdomainAvailabilityAsync(operationInputs).GetAwaiter().GetResult());
}
