ServiceBusNamespace IOperationSource <ServiceBusNamespace> .CreateResult(Response response, CancellationToken cancellationToken)
{
using var document = JsonDocument.Parse(response.ContentStream);
var data = ServiceBusNamespaceData.DeserializeServiceBusNamespaceData(document.RootElement);
return(new ServiceBusNamespace(_armClient, data));
}
internal static ServiceBusNamespaceListResult DeserializeServiceBusNamespaceListResult(JsonElement element)
{
Optional <IReadOnlyList <ServiceBusNamespaceData> > value = default;
Optional <string> nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
List <ServiceBusNamespaceData> array = new List <ServiceBusNamespaceData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(ServiceBusNamespaceData.DeserializeServiceBusNamespaceData(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new ServiceBusNamespaceListResult(Optional.ToList(value), nextLink.Value));
}
public async Task CreateNamespaceAndGetTopicCollection()
{
IgnoreTestInLiveMode();
_resourceGroup = await CreateResourceGroupAsync();
string namespaceName = await CreateValidNamespaceName("testnamespacemgmt");
ServiceBusNamespaceCollection namespaceCollection = _resourceGroup.GetServiceBusNamespaces();
ServiceBusNamespaceData parameters = new ServiceBusNamespaceData(DefaultLocation)
{
Sku = new Sku(SkuName.Premium)
{
Tier = SkuTier.Premium
}
};
ServiceBusNamespace serviceBusNamespace = (await namespaceCollection.CreateOrUpdateAsync(true, namespaceName, parameters)).Value;
_topicCollection = serviceBusNamespace.GetServiceBusTopics();
}
public async Task CreateNamespaceWithZoneRedundant()
{
IgnoreTestInLiveMode();
//create namespace and wait for completion
string namespaceName = await CreateValidNamespaceName(namespacePrefix);
_resourceGroup = await CreateResourceGroupAsync();
ServiceBusNamespaceCollection namespaceCollection = _resourceGroup.GetServiceBusNamespaces();
var parameters = new ServiceBusNamespaceData(DefaultLocation)
{
Sku = new ServiceBusSku(ServiceBusSkuName.Premium)
{
Tier = ServiceBusSkuTier.Premium
},
ZoneRedundant = true
};
ServiceBusNamespaceResource serviceBusNamespace = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName, parameters)).Value;
VerifyNamespaceProperties(serviceBusNamespace, false);
Assert.IsTrue(serviceBusNamespace.Data.ZoneRedundant);
}
public async Task CreateGetUpdateDeleteDisasterRecovery()
{
IgnoreTestInLiveMode();
_resourceGroup = await CreateResourceGroupAsync();
//create namespace1
string namespaceName1 = await CreateValidNamespaceName("testnamespacemgmt");
ServiceBusNamespaceCollection namespaceCollection = _resourceGroup.GetServiceBusNamespaces();
ServiceBusNamespaceData parameters1 = new ServiceBusNamespaceData(DefaultLocation)
{
Sku = new Models.Sku(SkuName.Premium)
{
Tier = SkuTier.Premium,
Capacity = 1
}
};
ServiceBusNamespace serviceBusNamespace1 = (await namespaceCollection.CreateOrUpdateAsync(true, namespaceName1, parameters1)).Value;
//create namespace2 with a different location
string namespaceName2 = await CreateValidNamespaceName("testnamespacemgmt");
ServiceBusNamespaceData parameters2 = new ServiceBusNamespaceData(AzureLocation.EastUS)
{
Sku = new Models.Sku(SkuName.Premium)
{
Tier = SkuTier.Premium,
Capacity = 1
}
};
ServiceBusNamespace serviceBusNamespace2 = (await namespaceCollection.CreateOrUpdateAsync(true, namespaceName2, parameters2)).Value;
//create authorization rule on namespace1
string ruleName = Recording.GenerateAssetName("authorizationrule");
ServiceBusAuthorizationRuleData ruleParameter = new ServiceBusAuthorizationRuleData()
{
Rights = { AccessRights.Listen, AccessRights.Send }
};
NamespaceAuthorizationRule authorizationRule = (await serviceBusNamespace1.GetNamespaceAuthorizationRules().CreateOrUpdateAsync(true, ruleName, ruleParameter)).Value;
Assert.NotNull(authorizationRule);
Assert.AreEqual(authorizationRule.Data.Rights.Count, ruleParameter.Rights.Count);
//create a disaster recovery
string disasterRecoveryName = Recording.GenerateAssetName("disasterrecovery");
DisasterRecoveryData parameter = new DisasterRecoveryData()
{
PartnerNamespace = serviceBusNamespace2.Id
};
DisasterRecovery disasterRecovery = (await serviceBusNamespace1.GetDisasterRecoveries().CreateOrUpdateAsync(true, disasterRecoveryName, parameter)).Value;
Assert.NotNull(disasterRecovery);
Assert.AreEqual(disasterRecovery.Id.Name, disasterRecoveryName);
Assert.AreEqual(disasterRecovery.Data.PartnerNamespace, serviceBusNamespace2.Id.ToString());
//get the disaster recovery - primary
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
Assert.AreEqual(disasterRecovery.Data.Role, RoleDisasterRecovery.Primary);
//get the disaster recovery - secondary
DisasterRecovery disasterRecoverySec = await serviceBusNamespace2.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
Assert.AreEqual(disasterRecoverySec.Data.Role, RoleDisasterRecovery.Secondary);
//wait for completion, this may take several minutes in live and record mode
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
int i = 0;
while (disasterRecovery.Data.ProvisioningState != ProvisioningStateDisasterRecovery.Succeeded && i < 100)
{
if (Mode != RecordedTestMode.Playback)
{
await Task.Delay(5000);
}
i++;
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
}
//check name availability
CheckNameAvailabilityResult nameAvailability = await serviceBusNamespace1.CheckDisasterRecoveryNameAvailabilityAsync(new CheckNameAvailability(disasterRecoveryName));
Assert.IsFalse(nameAvailability.NameAvailable);
List <NamespaceDisasterRecoveryAuthorizationRule> rules = await disasterRecovery.GetNamespaceDisasterRecoveryAuthorizationRules().GetAllAsync().ToEnumerableAsync();
Assert.IsTrue(rules.Count > 0);
//get access keys of the authorization rule
NamespaceDisasterRecoveryAuthorizationRule rule = rules.First();
AccessKeys keys = await rule.GetKeysAsync();
Assert.NotNull(keys);
//break pairing and wait for competion
await disasterRecovery.BreakPairingAsync();
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
i = 0;
while (disasterRecovery.Data.ProvisioningState != ProvisioningStateDisasterRecovery.Succeeded && i < 100)
{
if (Mode != RecordedTestMode.Playback)
{
await Task.Delay(5000);
}
i++;
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
}
//get all disaster recoveries for a name space
List <DisasterRecovery> disasterRcoveries = await serviceBusNamespace1.GetDisasterRecoveries().GetAllAsync().ToEnumerableAsync();
Assert.IsTrue(disasterRcoveries.Count >= 1);
//delete disaster recovery;
await disasterRecovery.DeleteAsync(true);
}
public async Task StandardToPremiumMigration()
{
IgnoreTestInLiveMode();
//create namespace with premium
_resourceGroup = await CreateResourceGroupAsync();
ServiceBusNamespaceCollection namespaceCollection = _resourceGroup.GetServiceBusNamespaces();
string namespaceName1 = await CreateValidNamespaceName(namespacePrefix);
ServiceBusNamespaceData createParameters1 = new ServiceBusNamespaceData(DefaultLocation);
createParameters1.Sku = new ServiceBusSku(ServiceBusSkuName.Premium)
{
Tier = ServiceBusSkuTier.Premium
};
ServiceBusNamespaceResource serviceBusNamespace1 = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName1, createParameters1)).Value;
//create namespace with standard
string namespaceName2 = await CreateValidNamespaceName(namespacePrefix);
ServiceBusNamespaceData createParameters2 = new ServiceBusNamespaceData(AzureLocation.EastUS);
createParameters2.Sku = new ServiceBusSku(ServiceBusSkuName.Standard)
{
Tier = ServiceBusSkuTier.Standard
};
ServiceBusNamespaceResource serviceBusNamespace2 = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName2, createParameters2)).Value;
//add 10 queues to standard namespace
for (int i = 0; i < 10; i++)
{
string queueName = Recording.GenerateAssetName("queue" + i);
_ = await serviceBusNamespace2.GetServiceBusQueues().CreateOrUpdateAsync(WaitUntil.Completed, queueName, new ServiceBusQueueData());
}
//add 10 topics to standard namespace
for (int i = 0; i < 10; i++)
{
string topicName = Recording.GenerateAssetName("topic" + i);
_ = await serviceBusNamespace2.GetServiceBusTopics().CreateOrUpdateAsync(WaitUntil.Completed, topicName, new ServiceBusTopicData());
}
//create the migration config, it's name should always be $default
string postMigrationName = Recording.GenerateAssetName("postmigration");
var migrationParameters = new MigrationConfigPropertiesData()
{
PostMigrationName = postMigrationName,
TargetNamespace = serviceBusNamespace1.Id.ToString()
};
_ = await serviceBusNamespace2.GetMigrationConfigProperties().CreateOrUpdateAsync(WaitUntil.Completed, MigrationConfigurationName.Default, migrationParameters);
//wait for migration state
MigrationConfigPropertiesResource migrationConfig = await serviceBusNamespace2.GetMigrationConfigProperties().GetAsync(MigrationConfigurationName.Default);
int count = 0;
while (count < 100 && (migrationConfig.Data.MigrationState != "Active" || (migrationConfig.Data.PendingReplicationOperationsCount.HasValue && migrationConfig.Data.PendingReplicationOperationsCount != 0)))
{
if (Mode != RecordedTestMode.Playback)
{
await Task.Delay(30000);
}
migrationConfig = await serviceBusNamespace2.GetMigrationConfigProperties().GetAsync(MigrationConfigurationName.Default);
count++;
}
Assert.NotNull(migrationConfig);
List <MigrationConfigPropertiesResource> migrationConfigs = await serviceBusNamespace2.GetMigrationConfigProperties().GetAllAsync().ToEnumerableAsync();
Assert.AreEqual(1, migrationConfigs.Count);
//complete migration
await migrationConfig.CompleteMigrationAsync();
//validate migration
List <ServiceBusTopicResource> topics = await serviceBusNamespace1.GetServiceBusTopics().GetAllAsync().ToEnumerableAsync();
Assert.AreEqual(10, topics.Count);
List <ServiceBusQueueResource> queues = await serviceBusNamespace1.GetServiceBusQueues().GetAllAsync().ToEnumerableAsync();
Assert.AreEqual(10, queues.Count);
//wait for migration config and premium namespace
migrationConfig = await serviceBusNamespace2.GetMigrationConfigProperties().GetAsync(MigrationConfigurationName.Default);
count = 0;
while (count < 100 && migrationConfig.Data.MigrationState != "Active")
{
if (Mode != RecordedTestMode.Playback)
{
await Task.Delay(30000);
}
migrationConfig = await serviceBusNamespace2.GetMigrationConfigProperties().GetAsync(MigrationConfigurationName.Default);
count++;
}
await GetSucceededNamespace(serviceBusNamespace1);
}
public async Task SetGetNetworkRuleSets()
{
IgnoreTestInLiveMode();
//create namespace with premium
_resourceGroup = await CreateResourceGroupAsync();
ServiceBusNamespaceCollection namespaceCollection = _resourceGroup.GetServiceBusNamespaces();
string namespaceName = await CreateValidNamespaceName(namespacePrefix);
ServiceBusNamespaceData createParameters = new ServiceBusNamespaceData(DefaultLocation);
createParameters.Sku = new ServiceBusSku(ServiceBusSkuName.Premium)
{
Tier = ServiceBusSkuTier.Premium
};
ServiceBusNamespaceResource serviceBusNamespace = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName, createParameters)).Value;
//prepare vnet
string vnetName = Recording.GenerateAssetName("sdktestvnet");
var parameters = new VirtualNetworkData
{
Subnets =
{
new SubnetData
{
Name = "default1",
AddressPrefix = "10.0.0.0/24",
ServiceEndpoints ={ new ServiceEndpointPropertiesFormat {
Service = "Microsoft.ServiceBus"
} }
},
new SubnetData
{
Name = "default2",
AddressPrefix = "10.0.1.0/24",
ServiceEndpoints ={ new ServiceEndpointPropertiesFormat {
Service = "Microsoft.ServiceBus"
} }
},
new SubnetData
{
Name = "default3",
AddressPrefix = "10.0.2.0/24",
ServiceEndpoints ={ new ServiceEndpointPropertiesFormat {
Service = "Microsoft.ServiceBus"
} }
}
},
Location = "eastus2"
};
parameters.AddressPrefixes.Add("10.0.0.0/16");
VirtualNetworkResource virtualNetwork = (await _resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, vnetName, parameters)).Value;
//set network rule set
string subscriptionId = DefaultSubscription.Id.ToString();
ResourceIdentifier subnetId1 = new ResourceIdentifier(subscriptionId + "/resourceGroups/" + _resourceGroup.Id.Name + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default1");
ResourceIdentifier subnetId2 = new ResourceIdentifier(subscriptionId + "/resourceGroups/" + _resourceGroup.Id.Name + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default2");
ResourceIdentifier subnetId3 = new ResourceIdentifier(subscriptionId + "/resourceGroups/" + _resourceGroup.Id.Name + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default3");
NetworkRuleSetData parameter = new NetworkRuleSetData()
{
DefaultAction = DefaultAction.Deny,
VirtualNetworkRules =
{
new NetworkRuleSetVirtualNetworkRules()
{
Subnet = new WritableSubResource()
{
Id = subnetId1
}, IgnoreMissingVnetServiceEndpoint = true
},
new NetworkRuleSetVirtualNetworkRules()
{
Subnet = new WritableSubResource()
{
Id = subnetId2
}, IgnoreMissingVnetServiceEndpoint = false
},
new NetworkRuleSetVirtualNetworkRules()
{
Subnet = new WritableSubResource()
{
Id = subnetId3
}, IgnoreMissingVnetServiceEndpoint = false
}
},
IPRules =
{
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.1", Action = "Allow"
},
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.2", Action = "Allow"
},
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.3", Action = "Allow"
},
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.4", Action = "Allow"
},
new NetworkRuleSetIPRules()
{
IPMask = "1.1.1.5", Action = "Allow"
}
}
};
await serviceBusNamespace.GetNetworkRuleSet().CreateOrUpdateAsync(WaitUntil.Completed, parameter);
//get the network rule set
NetworkRuleSetResource networkRuleSet = await serviceBusNamespace.GetNetworkRuleSet().GetAsync();
Assert.NotNull(networkRuleSet);
Assert.NotNull(networkRuleSet.Data.IPRules);
Assert.NotNull(networkRuleSet.Data.VirtualNetworkRules);
Assert.AreEqual(networkRuleSet.Data.VirtualNetworkRules.Count, 3);
Assert.AreEqual(networkRuleSet.Data.IPRules.Count, 5);
//delete virtual network
await virtualNetwork.DeleteAsync(WaitUntil.Completed);
}
