public async Task <Response <DigitalTwinsDescription> > GetAsync(string resourceGroupName, string resourceName, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (resourceName == null)
{
throw new ArgumentNullException(nameof(resourceName));
}
using var message = CreateGetRequest(resourceGroupName, resourceName);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
DigitalTwinsDescription value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
if (document.RootElement.ValueKind == JsonValueKind.Null)
{
value = null;
}
else
{
value = DigitalTwinsDescription.DeserializeDigitalTwinsDescription(document.RootElement);
}
return(Response.FromValue(value, message.Response));
}
protected DigitalTwinsDescription CreateDigitalTwinsInstance(ResourceGroup resourceGroup, string location, string digitalTwinsInstanceName)
{
var digitalTwinsDescription = new DigitalTwinsDescription()
{
Location = location,
};
return(this.digitalTwinsClient.DigitalTwins.CreateOrUpdate(
resourceGroup.Name,
digitalTwinsInstanceName,
digitalTwinsDescription
));
}
protected DigitalTwinsDescription CreateDigitalTwinsInstance(ResourceGroup resourceGroup, string location, string digitalTwinsInstanceName)
{
var digitalTwinsDescription = new DigitalTwinsDescription()
{
Location = location,
};
PropertyInfo sku = digitalTwinsDescription.GetType().BaseType.GetProperty("Sku");
DigitalTwinsSkuInfo newSku = new DigitalTwinsSkuInfo();
newSku.GetType().GetProperty("Name").SetValue(newSku, "S1");
sku.SetValue(digitalTwinsDescription, newSku);
return(this.digitalTwinsClient.DigitalTwins.CreateOrUpdate(
resourceGroup.Name,
digitalTwinsInstanceName,
digitalTwinsDescription
));
}
private async Task <DigitalTwinsDescription> FindDigitalTwinInstanceAsync(AzureDigitalTwinsManagementClient dtClient, string instanceName)
{
string nextPageLink = null;
DigitalTwinsDescription match = null;
do
{
var instances = nextPageLink == null
? await dtClient.DigitalTwins.ListAsync()
: await dtClient.DigitalTwins.ListNextAsync(nextPageLink);
nextPageLink = instances.NextPageLink;
match = instances.FirstOrDefault(x => string.Equals(x.Name, instanceName, StringComparison.OrdinalIgnoreCase));
if (match != null)
{
break;
}
} while (nextPageLink != null);
return(match);
}
/// <summary>
/// Create or update the metadata of a DigitalTwinsInstance. The usual pattern
/// to modify a property is to retrieve the DigitalTwinsInstance and security
/// metadata, and then combine them with the modified values in a new body to
/// update the DigitalTwinsInstance.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group that contains the DigitalTwinsInstance.
/// </param>
/// <param name='resourceName'>
/// The name of the DigitalTwinsInstance.
/// </param>
/// <param name='digitalTwinsCreate'>
/// The DigitalTwinsInstance and security metadata.
/// </param>
public static DigitalTwinsDescription CreateOrUpdate(this IDigitalTwinsOperations operations, string resourceGroupName, string resourceName, DigitalTwinsDescription digitalTwinsCreate)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, resourceName, digitalTwinsCreate).GetAwaiter().GetResult());
}
/// <summary>
/// Create or update the metadata of a DigitalTwinsInstance. The usual pattern
/// to modify a property is to retrieve the DigitalTwinsInstance and security
/// metadata, and then combine them with the modified values in a new body to
/// update the DigitalTwinsInstance.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group that contains the DigitalTwinsInstance.
/// </param>
/// <param name='resourceName'>
/// The name of the DigitalTwinsInstance.
/// </param>
/// <param name='digitalTwinsCreate'>
/// The DigitalTwinsInstance and security metadata.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <DigitalTwinsDescription> BeginCreateOrUpdateAsync(this IDigitalTwinsOperations operations, string resourceGroupName, string resourceName, DigitalTwinsDescription digitalTwinsCreate, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, resourceName, digitalTwinsCreate, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public virtual DigitalTwinsCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string resourceName, DigitalTwinsDescription digitalTwinsCreate, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (resourceName == null)
{
throw new ArgumentNullException(nameof(resourceName));
}
if (digitalTwinsCreate == null)
{
throw new ArgumentNullException(nameof(digitalTwinsCreate));
}
using var scope = _clientDiagnostics.CreateScope("DigitalTwinsOperations.StartCreateOrUpdate");
scope.Start();
try
{
var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, resourceName, digitalTwinsCreate, cancellationToken);
return(new DigitalTwinsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, resourceName, digitalTwinsCreate).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task DigitalTwinInstance_Lifecycle()
{
string dtInstanceName;
Response <CheckNameResult> checkNameResponse = null;
const int maxTryCount = 5;
int tryCount = 0;
// Create Resource Group
string resourceGroupName = Recording.GenerateAssetName("DtSDKRG");
await ResourceManagementClient.ResourceGroups.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup("eastus2"));
// Ensure the random instance Id generated does not already exist.
do
{
dtInstanceName = Recording.GenerateAssetName("DtInstanceLifecycle");
if (tryCount++ > maxTryCount)
{
// If for some reason this unique check keeps failing, proceed with the last unique
// name.
break;
}
try
{
checkNameResponse = await DigitalTwinsManagementClient.DigitalTwins
.CheckNameAvailabilityAsync(
TestEnvironment.Location,
dtInstanceName)
.ConfigureAwait(false);
}
catch (RequestFailedException ex) when(ex.Status == (int)HttpStatusCode.Forbidden)
{
// This call requires contributor rights in subscription, which I think might be a bug
// but until it changes, this test should just assume the random name is probably
// unique.
break;
}
catch (RequestFailedException ex)
{
Console.WriteLine(ex);
}
} while (checkNameResponse?.GetRawResponse().Status != 200);
bool createdSuccessfully = false;
try
{
// Test create
DigitalTwinsCreateOrUpdateOperation createResponse = await DigitalTwinsManagementClient.DigitalTwins
.StartCreateOrUpdateAsync(
resourceGroupName,
dtInstanceName,
new DigitalTwinsDescription(TestEnvironment.Location))
.ConfigureAwait(false);
// IsAsync seems to be broken. My async method gets the breakpoint no matter the mode.
// Once issue is resolved, return this code to the right path.
//int expectedCreateResponseCode = IsAsync ? 201 : 200;
//createResponse.GetRawResponse().Status.Should().Be(expectedCreateResponseCode);
createResponse.GetRawResponse().Status.Should().BeOneOf(200, 201);
createResponse.GetRawResponse().ClientRequestId.Should().NotBeNullOrWhiteSpace();
Response <DigitalTwinsDescription> createdResponse = await WaitForCompletionAsync(createResponse).ConfigureAwait(false);
createdResponse.GetRawResponse().Status.Should().Be(200);
createdResponse.GetRawResponse().ClientRequestId.Should().NotBeNullOrWhiteSpace();
createdSuccessfully = true;
// Validate create
DigitalTwinsDescription createdDtInstance = createdResponse.Value;
createdDtInstance.Name.Should().Be(dtInstanceName);
createdDtInstance.Location.Should().Be(TestEnvironment.Location);
createdDtInstance.ProvisioningState.Should().Be(ProvisioningState.Succeeded);
createdDtInstance.HostName.Should().NotBeNullOrWhiteSpace();
createdDtInstance.Id.Should().NotBeNullOrWhiteSpace();
createdDtInstance.CreatedTime.Should().NotBeNull();
createdDtInstance.LastUpdatedTime.Should().NotBeNull();
// Test get
Response <DigitalTwinsDescription> getResponse = await DigitalTwinsManagementClient.DigitalTwins
.GetAsync(
resourceGroupName,
dtInstanceName)
.ConfigureAwait(false);
// Validate get
getResponse.GetRawResponse().Status.Should().Be(200);
getResponse.GetRawResponse().ClientRequestId.Should().NotBeNullOrWhiteSpace();
getResponse.Value.Name.Should().Be(dtInstanceName);
getResponse.Value.Location.Should().Be(TestEnvironment.Location);
getResponse.Value.ProvisioningState.Should().Be(ProvisioningState.Succeeded);
getResponse.Value.HostName.Should().NotBeNullOrWhiteSpace();
getResponse.Value.Id.Should().NotBeNullOrWhiteSpace();
getResponse.Value.CreatedTime.Should().NotBeNull();
getResponse.Value.LastUpdatedTime.Should().NotBeNull();
// Test list
AsyncPageable <DigitalTwinsDescription> listResponse = DigitalTwinsManagementClient.DigitalTwins.ListAsync();
// Validate list
DigitalTwinsDescription foundInstance = null;
await foreach (DigitalTwinsDescription dtInstance in listResponse)
{
if (StringComparer.Ordinal.Equals(dtInstance.Name, dtInstanceName))
{
foundInstance = dtInstance;
break;
}
}
foundInstance.Name.Should().Be(dtInstanceName);
foundInstance.Location.Should().Be(TestEnvironment.Location);
foundInstance.ProvisioningState.Should().Be(ProvisioningState.Succeeded);
foundInstance.HostName.Should().NotBeNullOrWhiteSpace();
foundInstance.Id.Should().NotBeNullOrWhiteSpace();
foundInstance.CreatedTime.Should().NotBeNull();
foundInstance.LastUpdatedTime.Should().NotBeNull();
}
finally
{
if (createdSuccessfully)
{
// Test delete
DigitalTwinsDeleteOperation deleteResponse = await DigitalTwinsManagementClient.DigitalTwins
.StartDeleteAsync(
resourceGroupName,
dtInstanceName)
.ConfigureAwait(false);
deleteResponse.GetRawResponse().Status.Should().BeOneOf(202);
deleteResponse.GetRawResponse().ClientRequestId.Should().NotBeNullOrWhiteSpace();
// Validate delete
Response <Response> deletedResponse = await WaitForCompletionAsync(deleteResponse).ConfigureAwait(false);
// The swagger indicates this should be a 204, but in practice the service returns 200.
// The issue has been raised with the service team, but for now we'll expect a 200 instead.
deletedResponse.Value.Status.Should().Be(200);
deletedResponse.GetRawResponse().ClientRequestId.Should().NotBeNullOrWhiteSpace();
}
}
}
protected DigitalTwinsDescription UpdateDigitalTwinsInstance(ResourceGroup resourceGroup, DigitalTwinsDescription digitalTwinsDescription, string digitalTwinsInstanceName)
{
return(this.digitalTwinsClient.DigitalTwins.CreateOrUpdate(
resourceGroup.Name,
digitalTwinsInstanceName,
digitalTwinsDescription
));
}
public async Task TestDigitalTwinsLifecycle()
{
using var context = MockContext.Start(GetType());
Initialize(context);
// Create Resource Group
ResourceGroup rg = await ResourcesClient.ResourceGroups.CreateOrUpdateAsync(
DefaultResourceGroupName,
new ResourceGroup
{
Location = DefaultLocation,
});
try
{
// Check if instance exists and delete
CheckNameResult dtNameCheck = await DigitalTwinsClient.DigitalTwins.CheckNameAvailabilityAsync(
DefaultLocation,
DefaultInstanceName);
if (!dtNameCheck.NameAvailable.Value)
{
DigitalTwinsDescription dtDelete = await DigitalTwinsClient.DigitalTwins.DeleteAsync(
rg.Name,
DefaultInstanceName);
dtDelete.ProvisioningState.Should().Be(ProvisioningState.Deleted);
dtNameCheck = await DigitalTwinsClient.DigitalTwins.CheckNameAvailabilityAsync(
DefaultLocation,
DefaultInstanceName);
dtNameCheck.NameAvailable.Should().BeTrue();
}
// Create DigitalTwins resource
var dtInstance = await DigitalTwinsClient.DigitalTwins.CreateOrUpdateAsync(
rg.Name,
DefaultInstanceName,
new DigitalTwinsDescription
{
Location = DefaultLocation,
});
try
{
dtInstance.Should().NotBeNull();
dtInstance.Name.Should().Be(DefaultInstanceName);
dtInstance.Location.Should().Be(DefaultLocation);
// Add and Get Tags
const string key2 = "key2";
const string value2 = "value2";
var patch = new DigitalTwinsPatchDescription(
tags: new Dictionary <string, string>
{
{ "key1", "value1" },
{ key2, value2 },
});
dtInstance = await DigitalTwinsClient.DigitalTwins.UpdateAsync(
rg.Name,
dtInstance.Name,
patch);
dtInstance.Should().NotBeNull();
dtInstance.Tags.Count().Should().Be(2);
dtInstance.Tags[key2].Should().Be(value2);
// List DigitalTwins instances in Resource Group
var twinsResources = await DigitalTwinsClient.DigitalTwins.ListByResourceGroupAsync(rg.Name);
twinsResources.Count().Should().BeGreaterThan(0);
// Get all of the available operations, ensure CRUD
var operationList = await DigitalTwinsClient.Operations.ListAsync();
operationList.Count().Should().BeGreaterThan(0);
Assert.Contains(operationList, e => e.Name.Equals($"Microsoft.DigitalTwins/digitalTwinsInstances/read", StringComparison.OrdinalIgnoreCase));
Assert.Contains(operationList, e => e.Name.Equals($"Microsoft.DigitalTwins/digitalTwinsInstances/write", StringComparison.OrdinalIgnoreCase));
Assert.Contains(operationList, e => e.Name.Equals($"Microsoft.DigitalTwins/digitalTwinsInstances/delete", StringComparison.OrdinalIgnoreCase));
// Test other operations
// Register Operation
var registerOperations = operationList.Where(e => e.Name.Contains($"Microsoft.DigitalTwins/register"));
registerOperations.Count().Should().BeGreaterThan(0);
// Twin Operations
var twinOperations = operationList.Where(e => e.Name.Contains($"Microsoft.DigitalTwins/digitaltwins"));
twinOperations.Count().Should().BeGreaterThan(0);
// Event Route Operations
var eventRouteOperations = operationList.Where(e => e.Name.Contains($"Microsoft.DigitalTwins/eventroutes"));
eventRouteOperations.Count().Should().BeGreaterThan(0);
// Model operations
var modelOperations = operationList.Where(e => e.Name.Contains($"Microsoft.DigitalTwins/models"));
modelOperations.Count().Should().BeGreaterThan(0);
}
finally
{
// Delete instance
DigitalTwinsDescription deleteOp = await DigitalTwinsClient.DigitalTwins.BeginDeleteAsync(
rg.Name,
dtInstance.Name);
deleteOp.ProvisioningState.Should().Be(ProvisioningState.Deleting);
}
}
finally
{
await ResourcesClient.ResourceGroups.DeleteAsync(rg.Name);
}
}
public void TestDigitalTwinsLifecycle()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
var digitalTwinsDescription = new DigitalTwinsDescription()
{
Location = location,
};
this.Initialize(context);
// Create Resource Group
var resourceGroup = this.CreateResourceGroup(DigitalTwinsTestUtilities.DefaultResourceGroupName);
// Check if instance exists and delete
var digitalTwinsAvailability = this.digitalTwinsClient.DigitalTwins.CheckNameAvailability(DigitalTwinsTestUtilities.DefaultLocation, DigitalTwinsTestUtilities.DefaultInstanceName);
if (!(bool)digitalTwinsAvailability.NameAvailable)
{
this.digitalTwinsClient.DigitalTwins.Delete(
DigitalTwinsTestUtilities.DefaultResourceGroupName,
DigitalTwinsTestUtilities.DefaultInstanceName);
digitalTwinsAvailability = this.digitalTwinsClient.DigitalTwins.CheckNameAvailability(DigitalTwinsTestUtilities.DefaultLocation, DigitalTwinsTestUtilities.DefaultInstanceName);
Assert.True(digitalTwinsAvailability.NameAvailable);
}
// Create DigitalTwins resource
var digitalTwinsInstance = this.CreateDigitalTwinsInstance(resourceGroup, DigitalTwinsTestUtilities.DefaultLocation, DigitalTwinsTestUtilities.DefaultInstanceName);
Assert.NotNull(digitalTwinsInstance);
Assert.Equal(DigitalTwinsTestUtilities.DefaultInstanceName, digitalTwinsInstance.Name);
Assert.Equal(DigitalTwinsTestUtilities.DefaultLocation, digitalTwinsInstance.Location);
// Add and Get Tags
IDictionary <string, string> tags = new Dictionary <string, string>();
tags.Add("key1", "value1");
tags.Add("key2", "value2");
digitalTwinsInstance = this.digitalTwinsClient.DigitalTwins.Update(DigitalTwinsTestUtilities.DefaultResourceGroupName, DigitalTwinsTestUtilities.DefaultInstanceName, tags);
Assert.NotNull(digitalTwinsInstance);
Assert.True(digitalTwinsInstance.Tags.Count().Equals(2));
Assert.Equal("value2", digitalTwinsInstance.Tags["key2"]);
// List DigitalTwins instances in Resource Group
var twinsResources = this.digitalTwinsClient.DigitalTwins.ListByResourceGroup(DigitalTwinsTestUtilities.DefaultResourceGroupName);
Assert.True(twinsResources.Count() > 0);
// Get all of the available operations, ensure CRUD
var operationList = this.digitalTwinsClient.Operations.List();
Assert.True(operationList.Count() > 0);
Assert.Contains(operationList, e => e.Name.Equals($"Microsoft.DigitalTwins/digitalTwinsInstances/read", StringComparison.OrdinalIgnoreCase));
Assert.Contains(operationList, e => e.Name.Equals($"Microsoft.DigitalTwins/digitalTwinsInstances/write", StringComparison.OrdinalIgnoreCase));
Assert.Contains(operationList, e => e.Name.Equals($"Microsoft.DigitalTwins/digitalTwinsInstances/delete", StringComparison.OrdinalIgnoreCase));
// Get other operations
// Register Operation
var registerOperations = operationList.Where(e => e.Name.Contains($"Microsoft.DigitalTwins/register"));
Assert.True(registerOperations.Count() > 0);
// Twin Operations
var twinOperations = operationList.Where(e => e.Name.Contains($"Microsoft.DigitalTwins/digitaltwins"));
Assert.True(twinOperations.Count() > 0);
// Event Route Operations
var eventRouteOperations = operationList.Where(e => e.Name.Contains($"Microsoft.DigitalTwins/eventroutes"));
Assert.True(eventRouteOperations.Count() > 0);
// Model operations
var modelOperations = operationList.Where(e => e.Name.Contains($"Microsoft.DigitalTwins/models"));
Assert.True(modelOperations.Count() > 0);
// Delete instance
var deleteOp = this.digitalTwinsClient.DigitalTwins.BeginDelete(DigitalTwinsTestUtilities.DefaultResourceGroupName, DigitalTwinsTestUtilities.DefaultInstanceName);
Assert.True(deleteOp.ProvisioningState == ProvisioningState.Deleting);
}
}
