public override void ExecuteCmdlet()
{
var regenKey = new RegenerateAccessKeyParameters {
Key = RegenerateKey
};
// Generate new Namespace List Keys for the specified AuthorizationRule
if (ParameterSetName == NamespaceAuthoRuleParameterSet)
{
if (ShouldProcess(target: RegenerateKey, action: string.Format(Resources.RegenerateKeyNamesapce, Name, Namespace)))
{
WriteObject(Client.SetRegenerateKeys(ResourceGroupName, Namespace, Name, RegenerateKey));
}
}
// Generate new WcfRelay List Keys for the specified AuthorizationRule
if (ParameterSetName == EventhubAuthoRuleParameterSet)
{
if (ShouldProcess(target: RegenerateKey, action: string.Format(Resources.RegenerateKeyEventHub, Name, EventHub)))
{
WriteObject(Client.SetRegenerateKeys(ResourceGroupName, Namespace, EventHub, Name, RegenerateKey));
}
}
}
public override void ExecuteCmdlet()
{
var regenKey = new RegenerateAccessKeyParameters {
Key = RegenerateKey
};
// Get a EventHub List Keys for the specified AuthorizationRule
if (ShouldProcess(target: RegenerateKey, action: string.Format("Generating PrimaryKey/SecondaryKey for AuthorizationRule: {0} of EventHub:{1}", AuthorizationRuleName, EventHubName)))
{
WriteObject(Client.SetRegenerateKeys(ResourceGroup, NamespaceName, EventHubName, AuthorizationRuleName, RegenerateKey));
}
}
///GENMHASH:2A78999F239DA090C8DF19A6D1F08331:8F91E65E832D3679B5CB708B68F15EFC
protected override async Task <AccessKeysInner> RegenerateKeysInnerAsync(KeyType keyType, CancellationToken cancellationToken = default(CancellationToken))
{
RegenerateAccessKeyParameters regenKeyInner = new RegenerateAccessKeyParameters
{
KeyType = keyType
};
return(await this.Manager.Inner.Namespaces
.RegenerateKeysAsync(this.Ancestor().ResourceGroupName,
this.Ancestor().Ancestor1Name,
this.Name,
regenKeyInner,
cancellationToken));
}
public PSRegenerateKeysAttributes(RegenerateAccessKeyParameters RegenerateKeysResource)
{
if (RegenerateKeysResource != null)
{
if (RegenerateKeysResource.Key.ToString() == "PrimaryKey")
{
Policykey = "PrimaryKey";
}
if (RegenerateKeysResource.Key.ToString() == "SecondaryKey")
{
Policykey = "SecondaryKey";
}
}
;
}
/// <summary>
/// Rotates the connection string key of the Azure Service Bus Queue, returning the new connection string as result.
/// </summary>
/// <param name="keyType">The type of key to rotate.</param>
/// <returns>
/// The new connection string according to the <paramref name="keyType"/>.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">Thrown when the <paramref name="keyType"/> is not within the bounds of the enumration.</exception>
public async Task <string> RotateConnectionStringKeysForQueueAsync(KeyType keyType)
{
Guard.For <ArgumentOutOfRangeException>(
() => !Enum.IsDefined(typeof(KeyType), keyType),
$"Requires a KeyType that is either '{nameof(KeyType.PrimaryKey)}' or '{nameof(KeyType.SecondaryKey)}'");
var parameters = new RegenerateAccessKeyParameters(keyType);
string queueName = _configuration.ServiceBusNamespace.QueueName;
const ServiceBusEntityType entity = ServiceBusEntityType.Queue;
try
{
using IServiceBusManagementClient client = await CreateServiceManagementClientAsync();
_logger.LogTrace(
"Start rotating {KeyType} connection string of Azure Service Bus {EntityType} '{EntityName}'...",
keyType, entity, queueName);
AccessKeys accessKeys = await client.Queues.RegenerateKeysAsync(
_configuration.ServiceBusNamespace.ResourceGroup,
_configuration.ServiceBusNamespace.Namespace,
queueName,
_configuration.ServiceBusNamespace.AuthorizationRuleName,
parameters);
_logger.LogInformation(
"Rotated {KeyType} connection string of Azure Service Bus {EntityType} '{EntityName}'",
keyType, entity, queueName);
switch (keyType)
{
case KeyType.PrimaryKey: return(accessKeys.PrimaryConnectionString);
case KeyType.SecondaryKey: return(accessKeys.SecondaryConnectionString);
default:
throw new ArgumentOutOfRangeException(nameof(keyType), keyType, "Unknown key type");
}
}
catch (Exception exception)
{
_logger.LogError(
exception, "Failed to rotate the {KeyType} connection string of the Azure Service Bus {EntityType} '{EntityName}'", keyType, entity, queueName);
throw;
}
}
public PSListKeysAttributes NewTopicKey(string resourceGroupName, string namespaceName, string topicName, string authRuleName, string regenerateKeys, string keyValue = null)
{
AccessKeys regenerateKeyslistKeys;
RegenerateAccessKeyParameters regenParam = new RegenerateAccessKeyParameters();
if (regenerateKeys == "PrimaryKey")
{
regenParam.KeyType = KeyType.PrimaryKey;
}
else
{
regenParam.KeyType = KeyType.SecondaryKey;
}
regenParam.Key = keyValue;
regenerateKeyslistKeys = Client.Topics.RegenerateKeys(resourceGroupName, namespaceName, topicName, authRuleName, regenParam);
return(new PSListKeysAttributes(regenerateKeyslistKeys));
}
public virtual Response <AccessKeys> RegenerateKeys(string resourceGroupName, string namespaceName, string eventHubName, string authorizationRuleName, RegenerateAccessKeyParameters parameters, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("EventHubsOperations.RegenerateKeys");
scope.Start();
try
{
return(RestClient.RegenerateKeys(resourceGroupName, namespaceName, eventHubName, authorizationRuleName, parameters, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public void HybridConnectionsCreateGetUpdateDeleteAuthorizationRules()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
InitializeClients(context);
var location = this.ResourceManagementClient.GetLocationFromProvider();
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(RelayManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
// Create Namespace
var namespaceName = TestUtilities.GenerateName(RelayManagementHelper.NamespacePrefix);
var createNamespaceResponse = this.RelayManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
new RelayNamespace()
{
Location = location,
Tags = new Dictionary <string, string>()
{
{ "tag1", "value1" },
{ "tag2", "value2" }
}
});
Assert.NotNull(createNamespaceResponse);
Assert.Equal(createNamespaceResponse.Name, namespaceName);
Assert.Equal(2, createNamespaceResponse.Tags.Count);
Assert.Equal("Microsoft.Relay/Namespaces", createNamespaceResponse.Type);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Get the created namespace
var getNamespaceResponse = RelayManagementClient.Namespaces.Get(resourceGroup, namespaceName);
if (string.Compare(getNamespaceResponse.ProvisioningState.ToString(), "Succeeded", true) != 0)
{
TestUtilities.Wait(TimeSpan.FromSeconds(5));
}
getNamespaceResponse = RelayManagementClient.Namespaces.Get(resourceGroup, namespaceName);
Assert.NotNull(getNamespaceResponse);
Assert.Equal("Succeeded", getNamespaceResponse.ProvisioningState.ToString(), StringComparer.CurrentCultureIgnoreCase);
Assert.Equal(location, getNamespaceResponse.Location, StringComparer.CurrentCultureIgnoreCase);
// Get all namespaces created within a resourceGroup
var getAllNamespacesResponse = RelayManagementClient.Namespaces.ListByResourceGroup(resourceGroup);
Assert.NotNull(getAllNamespacesResponse);
Assert.True(getAllNamespacesResponse.Count() >= 1);
Assert.Contains(getAllNamespacesResponse, ns => ns.Name == namespaceName);
Assert.True(getAllNamespacesResponse.All(ns => ns.Id.Contains(resourceGroup)));
// Get all namespaces created within the subscription irrespective of the resourceGroup
getAllNamespacesResponse = RelayManagementClient.Namespaces.List();
Assert.NotNull(getAllNamespacesResponse);
Assert.True(getAllNamespacesResponse.Count() >= 1);
Assert.Contains(getAllNamespacesResponse, ns => ns.Name == namespaceName);
// Create Relay HybridConnections -
var hybridConnectionsName = TestUtilities.GenerateName(RelayManagementHelper.HybridPrefix);
var createdWCFRelayResponse = RelayManagementClient.HybridConnections.CreateOrUpdate(resourceGroup, namespaceName, hybridConnectionsName, new HybridConnection()
{
RequiresClientAuthorization = true,
});
Assert.NotNull(createdWCFRelayResponse);
Assert.Equal(createdWCFRelayResponse.Name, hybridConnectionsName);
Assert.True(createdWCFRelayResponse.RequiresClientAuthorization);
var getWCFRelaysResponse = RelayManagementClient.HybridConnections.Get(resourceGroup, namespaceName, hybridConnectionsName);
// Create a HybridConnections AuthorizationRule
var authorizationRuleName = TestUtilities.GenerateName(RelayManagementHelper.AuthorizationRulesPrefix);
string createPrimaryKey = HttpMockServer.GetVariable("CreatePrimaryKey", RelayManagementHelper.GenerateRandomKey());
var createAutorizationRuleParameter = new AuthorizationRule()
{
Rights = new List <AccessRights?>()
{
AccessRights.Listen, AccessRights.Send
}
};
var jsonStr = RelayManagementHelper.ConvertObjectToJSon(createAutorizationRuleParameter);
var test = RelayManagementClient.HybridConnections.CreateOrUpdateAuthorizationRule(resourceGroup, namespaceName, hybridConnectionsName, authorizationRuleName, createAutorizationRuleParameter);
var createNamespaceAuthorizationRuleResponse = RelayManagementClient.HybridConnections.CreateOrUpdateAuthorizationRule(resourceGroup, namespaceName, hybridConnectionsName,
authorizationRuleName, createAutorizationRuleParameter);
Assert.NotNull(createNamespaceAuthorizationRuleResponse);
Assert.True(createNamespaceAuthorizationRuleResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(createNamespaceAuthorizationRuleResponse.Rights, r => r == right);
}
// Get created HybridConnections AuthorizationRules
var getNamespaceAuthorizationRulesResponse = RelayManagementClient.HybridConnections.GetAuthorizationRule(resourceGroup, namespaceName, hybridConnectionsName, authorizationRuleName);
Assert.NotNull(getNamespaceAuthorizationRulesResponse);
Assert.True(getNamespaceAuthorizationRulesResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == right);
}
// Get all HybridConnections AuthorizationRules
var getAllNamespaceAuthorizationRulesResponse = RelayManagementClient.HybridConnections.ListAuthorizationRules(resourceGroup, namespaceName, hybridConnectionsName);
Assert.NotNull(getAllNamespaceAuthorizationRulesResponse);
Assert.True(getAllNamespaceAuthorizationRulesResponse.Count() >= 1);
Assert.Contains(getAllNamespaceAuthorizationRulesResponse, ns => ns.Name == authorizationRuleName);
// Update HybridConnections authorizationRule
string updatePrimaryKey = HttpMockServer.GetVariable("UpdatePrimaryKey", RelayManagementHelper.GenerateRandomKey());
AuthorizationRule updateNamespaceAuthorizationRuleParameter = new AuthorizationRule();
updateNamespaceAuthorizationRuleParameter.Rights = new List <AccessRights?>()
{
AccessRights.Listen
};
var updateNamespaceAuthorizationRuleResponse = RelayManagementClient.HybridConnections.CreateOrUpdateAuthorizationRule(resourceGroup,
namespaceName, hybridConnectionsName, authorizationRuleName, updateNamespaceAuthorizationRuleParameter);
Assert.NotNull(updateNamespaceAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, updateNamespaceAuthorizationRuleResponse.Name);
Assert.True(updateNamespaceAuthorizationRuleResponse.Rights.Count == updateNamespaceAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateNamespaceAuthorizationRuleParameter.Rights)
{
Assert.Contains(updateNamespaceAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the HybridConnections namespace AuthorizationRule
var getNamespaceAuthorizationRuleResponse = RelayManagementClient.HybridConnections.GetAuthorizationRule(resourceGroup, namespaceName, hybridConnectionsName, authorizationRuleName);
Assert.NotNull(getNamespaceAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, getNamespaceAuthorizationRuleResponse.Name);
Assert.True(getNamespaceAuthorizationRuleResponse.Rights.Count == updateNamespaceAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateNamespaceAuthorizationRuleParameter.Rights)
{
Assert.Contains(getNamespaceAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the connectionString to the HybridConnections for a Authorization rule created
var listKeysResponse = RelayManagementClient.HybridConnections.ListKeys(resourceGroup, namespaceName, hybridConnectionsName, authorizationRuleName);
Assert.NotNull(listKeysResponse);
Assert.NotNull(listKeysResponse.PrimaryConnectionString);
Assert.NotNull(listKeysResponse.SecondaryConnectionString);
// Regenerate AuthorizationRules
var regenerateKeysParameters = new RegenerateAccessKeyParameters();
regenerateKeysParameters.KeyType = KeyType.PrimaryKey;
//Primary Key
var regenerateKeysPrimaryResponse = RelayManagementClient.HybridConnections.RegenerateKeys(resourceGroup, namespaceName, hybridConnectionsName, authorizationRuleName, regenerateKeysParameters);
Assert.NotNull(regenerateKeysPrimaryResponse);
Assert.NotEqual(regenerateKeysPrimaryResponse.PrimaryKey, listKeysResponse.PrimaryKey);
Assert.Equal(regenerateKeysPrimaryResponse.SecondaryKey, listKeysResponse.SecondaryKey);
regenerateKeysParameters.KeyType = KeyType.SecondaryKey;
//Secondary Key
var regenerateKeysSecondaryResponse = RelayManagementClient.HybridConnections.RegenerateKeys(resourceGroup, namespaceName, hybridConnectionsName, authorizationRuleName, regenerateKeysParameters);
Assert.NotNull(regenerateKeysSecondaryResponse);
Assert.NotEqual(regenerateKeysSecondaryResponse.SecondaryKey, listKeysResponse.SecondaryKey);
Assert.Equal(regenerateKeysSecondaryResponse.PrimaryKey, regenerateKeysPrimaryResponse.PrimaryKey);
// Delete HybridConnections authorizationRule
RelayManagementClient.HybridConnections.DeleteAuthorizationRule(resourceGroup, namespaceName, hybridConnectionsName, authorizationRuleName);
try
{
RelayManagementClient.HybridConnections.Delete(resourceGroup, namespaceName, hybridConnectionsName);
}
catch (Exception ex)
{
Assert.Contains("NotFound", ex.Message);
}
try
{
// Delete namespace
RelayManagementClient.Namespaces.Delete(resourceGroup, namespaceName);
}
catch (Exception ex)
{
Assert.Contains("NotFound", ex.Message);
}
}
}
/// <summary>
/// Regenerates primary or secondary connection strings for the topic.
/// <see href="https://msdn.microsoft.com/en-us/library/azure/mt720679.aspx" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the Resource group within the Azure subscription.
/// </param>
/// <param name='namespaceName'>
/// The namespace name
/// </param>
/// <param name='topicName'>
/// The topic name.
/// </param>
/// <param name='authorizationRuleName'>
/// The authorization rule name.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to regenerate the authorization rule.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <AccessKeys> RegenerateKeysAsync(this ITopicsOperations operations, string resourceGroupName, string namespaceName, string topicName, string authorizationRuleName, RegenerateAccessKeyParameters parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.RegenerateKeysWithHttpMessagesAsync(resourceGroupName, namespaceName, topicName, authorizationRuleName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Regenerates primary or secondary connection strings for the topic.
/// <see href="https://msdn.microsoft.com/en-us/library/azure/mt720679.aspx" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the Resource group within the Azure subscription.
/// </param>
/// <param name='namespaceName'>
/// The namespace name
/// </param>
/// <param name='topicName'>
/// The topic name.
/// </param>
/// <param name='authorizationRuleName'>
/// The authorization rule name.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to regenerate the authorization rule.
/// </param>
public static AccessKeys RegenerateKeys(this ITopicsOperations operations, string resourceGroupName, string namespaceName, string topicName, string authorizationRuleName, RegenerateAccessKeyParameters parameters)
{
return(operations.RegenerateKeysAsync(resourceGroupName, namespaceName, topicName, authorizationRuleName, parameters).GetAwaiter().GetResult());
}
public void QueuesCreateGetUpdateDeleteAuthorizationRules()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
InitializeClients(context);
var location = this.ResourceManagementClient.GetLocationFromProvider();
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(ServiceBusManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
// Create a namespace
var namespaceName = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix);
var createNamespaceResponse = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
new SBNamespace()
{
Location = location,
Sku = new SBSku
{
Name = SkuName.Standard,
Tier = SkuTier.Standard
}
});
Assert.NotNull(createNamespaceResponse);
Assert.Equal(createNamespaceResponse.Name, namespaceName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
//Get the created namespace
var getNamespaceResponse = ServiceBusManagementClient.Namespaces.Get(resourceGroup, namespaceName);
if (string.Compare(getNamespaceResponse.ProvisioningState, "Succeeded", true) != 0)
{
TestUtilities.Wait(TimeSpan.FromSeconds(5));
}
getNamespaceResponse = ServiceBusManagementClient.Namespaces.Get(resourceGroup, namespaceName);
Assert.NotNull(getNamespaceResponse);
Assert.Equal("Succeeded", getNamespaceResponse.ProvisioningState, StringComparer.CurrentCultureIgnoreCase);
Assert.Equal(location, getNamespaceResponse.Location, StringComparer.CurrentCultureIgnoreCase);
// Create Queue
var queueName = TestUtilities.GenerateName(ServiceBusManagementHelper.QueuesPrefix);
var createQueueResponse = this.ServiceBusManagementClient.Queues.CreateOrUpdate(resourceGroup, namespaceName, queueName,
new SBQueue()
{
EnablePartitioning = true
});
Assert.NotNull(createQueueResponse);
Assert.Equal(createQueueResponse.Name, queueName);
// Get the created Queue
var getQueueResponse = ServiceBusManagementClient.Queues.Get(resourceGroup, namespaceName, queueName);
Assert.NotNull(getQueueResponse);
Assert.Equal(EntityStatus.Active, getQueueResponse.Status);
Assert.Equal(getQueueResponse.Name, queueName);
// Create a queue AuthorizationRule
var authorizationRuleName = TestUtilities.GenerateName(ServiceBusManagementHelper.AuthorizationRulesPrefix);
string createPrimaryKey = HttpMockServer.GetVariable("CreatePrimaryKey", ServiceBusManagementHelper.GenerateRandomKey());
var createAutorizationRuleParameter = new SBAuthorizationRule()
{
Rights = new List <AccessRights?>()
{
AccessRights.Listen, AccessRights.Send
}
};
var jsonStr = ServiceBusManagementHelper.ConvertObjectToJSon(createAutorizationRuleParameter);
var createQueueAuthorizationRuleResponse = ServiceBusManagementClient.Queues.CreateOrUpdateAuthorizationRule(resourceGroup, namespaceName, queueName,
authorizationRuleName, createAutorizationRuleParameter);
Assert.NotNull(createQueueAuthorizationRuleResponse);
Assert.True(createQueueAuthorizationRuleResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(createQueueAuthorizationRuleResponse.Rights, r => r == right);
}
// Get created queues AuthorizationRules
var getQueueAuthorizationRulesResponse = ServiceBusManagementClient.Queues.GetAuthorizationRule(resourceGroup, namespaceName, queueName, authorizationRuleName);
Assert.NotNull(getQueueAuthorizationRulesResponse);
Assert.True(getQueueAuthorizationRulesResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(getQueueAuthorizationRulesResponse.Rights, r => r == right);
}
// Get all queues AuthorizationRules
var getAllNamespaceAuthorizationRulesResponse = ServiceBusManagementClient.Queues.ListAuthorizationRules(resourceGroup, namespaceName, queueName);
Assert.NotNull(getAllNamespaceAuthorizationRulesResponse);
Assert.Single(getAllNamespaceAuthorizationRulesResponse);
Assert.Contains(getAllNamespaceAuthorizationRulesResponse, ns => ns.Name == authorizationRuleName);
// Update queues authorizationRule
string updatePrimaryKey = HttpMockServer.GetVariable("UpdatePrimaryKey", ServiceBusManagementHelper.GenerateRandomKey());
SBAuthorizationRule updateQueuesAuthorizationRuleParameter = new SBAuthorizationRule();
updateQueuesAuthorizationRuleParameter.Rights = new List <AccessRights?>()
{
AccessRights.Listen
};
var updateQueueAuthorizationRuleResponse = ServiceBusManagementClient.Queues.CreateOrUpdateAuthorizationRule(resourceGroup,
namespaceName, queueName, authorizationRuleName, updateQueuesAuthorizationRuleParameter);
Assert.NotNull(updateQueueAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, updateQueueAuthorizationRuleResponse.Name);
Assert.True(updateQueueAuthorizationRuleResponse.Rights.Count == updateQueuesAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateQueuesAuthorizationRuleParameter.Rights)
{
Assert.Contains(updateQueueAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the updated queues AuthorizationRule
var getQueueAuthorizationRuleResponse = ServiceBusManagementClient.Queues.GetAuthorizationRule(resourceGroup, namespaceName, queueName,
authorizationRuleName);
Assert.NotNull(getQueueAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, getQueueAuthorizationRuleResponse.Name);
Assert.True(getQueueAuthorizationRuleResponse.Rights.Count == updateQueuesAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateQueuesAuthorizationRuleParameter.Rights)
{
Assert.Contains(getQueueAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the connectionString to the queues for a Authorization rule created
var listKeysResponse = ServiceBusManagementClient.Queues.ListKeys(resourceGroup, namespaceName, queueName, authorizationRuleName);
Assert.NotNull(listKeysResponse);
Assert.NotNull(listKeysResponse.PrimaryConnectionString);
Assert.NotNull(listKeysResponse.SecondaryConnectionString);
// Regenerate Keys for the create Authorization rules
var regenerateKeysParameters = new RegenerateAccessKeyParameters();
regenerateKeysParameters.KeyType = KeyType.PrimaryKey;
var regenerateKeysResposnse = ServiceBusManagementClient.Queues.RegenerateKeys(resourceGroup, namespaceName, queueName, authorizationRuleName, regenerateKeysParameters);
Assert.NotEqual(listKeysResponse.PrimaryKey, regenerateKeysResposnse.PrimaryKey);
Assert.NotNull(regenerateKeysResposnse.SecondaryConnectionString);
Assert.NotNull(regenerateKeysResposnse.SecondaryKey);
regenerateKeysParameters.KeyType = KeyType.SecondaryKey;
regenerateKeysResposnse = ServiceBusManagementClient.Queues.RegenerateKeys(resourceGroup, namespaceName, queueName, authorizationRuleName, regenerateKeysParameters);
Assert.NotEqual(listKeysResponse.SecondaryKey, regenerateKeysResposnse.SecondaryKey);
Assert.NotNull(regenerateKeysResposnse.PrimaryConnectionString);
Assert.NotNull(regenerateKeysResposnse.SecondaryConnectionString);
Assert.NotNull(regenerateKeysResposnse.PrimaryKey);
// Delete Queue authorizationRule
ServiceBusManagementClient.Queues.DeleteAuthorizationRule(resourceGroup, namespaceName, queueName, authorizationRuleName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Delete queue
ServiceBusManagementClient.Queues.Delete(resourceGroup, namespaceName, queueName);
// Delete namespace
ServiceBusManagementClient.Namespaces.Delete(resourceGroup, namespaceName);
}
}
public void NamespaceCreateGetUpdateDeleteAuthorizationRules()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
InitializeClients(context);
var location = this.ResourceManagementClient.GetLocationFromProvider();
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(RelayManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
// Create a namespace
var namespaceName = TestUtilities.GenerateName(RelayManagementHelper.NamespacePrefix);
var createNamespaceResponse = RelayManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
new RelayNamespace()
{
Location = location,
});
Assert.NotNull(createNamespaceResponse);
Assert.Equal(createNamespaceResponse.Name, namespaceName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Get the created namespace
var getNamespaceResponse = RelayManagementClient.Namespaces.Get(resourceGroup, namespaceName);
if (string.Compare(getNamespaceResponse.ProvisioningState.ToString(), "Succeeded", true) != 0)
{
TestUtilities.Wait(TimeSpan.FromSeconds(5));
}
getNamespaceResponse = RelayManagementClient.Namespaces.Get(resourceGroup, namespaceName);
Assert.NotNull(getNamespaceResponse);
Assert.Equal("Succeeded", getNamespaceResponse.ProvisioningState.ToString(), StringComparer.CurrentCultureIgnoreCase);
Assert.Equal(location, getNamespaceResponse.Location, StringComparer.CurrentCultureIgnoreCase);
// Create a namespace AuthorizationRule
var authorizationRuleName = TestUtilities.GenerateName(RelayManagementHelper.AuthorizationRulesPrefix);
string createPrimaryKey = HttpMockServer.GetVariable("CreatePrimaryKey", RelayManagementHelper.GenerateRandomKey());
var createAutorizationRuleParameter = new AuthorizationRule()
{
Rights = new List <AccessRights?>()
{
AccessRights.Listen, AccessRights.Send
}
};
var jsonStr = RelayManagementHelper.ConvertObjectToJSon(createAutorizationRuleParameter);
var createNamespaceAuthorizationRuleResponse = RelayManagementClient.Namespaces.CreateOrUpdateAuthorizationRule(resourceGroup, namespaceName,
authorizationRuleName, createAutorizationRuleParameter);
Assert.NotNull(createNamespaceAuthorizationRuleResponse);
Assert.True(createNamespaceAuthorizationRuleResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(createNamespaceAuthorizationRuleResponse.Rights, r => r == right);
}
// Get default namespace AuthorizationRules
var getNamespaceAuthorizationRulesResponse = RelayManagementClient.Namespaces.GetAuthorizationRule(resourceGroup, namespaceName, RelayManagementHelper.DefaultNamespaceAuthorizationRule);
Assert.NotNull(getNamespaceAuthorizationRulesResponse);
Assert.Equal(getNamespaceAuthorizationRulesResponse.Name, RelayManagementHelper.DefaultNamespaceAuthorizationRule);
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == AccessRights.Listen);
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == AccessRights.Send);
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == AccessRights.Manage);
// Get created namespace AuthorizationRules
getNamespaceAuthorizationRulesResponse = RelayManagementClient.Namespaces.GetAuthorizationRule(resourceGroup, namespaceName, authorizationRuleName);
Assert.NotNull(getNamespaceAuthorizationRulesResponse);
Assert.True(getNamespaceAuthorizationRulesResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == right);
}
// Get all namespaces AuthorizationRules
var getAllNamespaceAuthorizationRulesResponse = RelayManagementClient.Namespaces.ListAuthorizationRules(resourceGroup, namespaceName);
Assert.NotNull(getAllNamespaceAuthorizationRulesResponse);
Assert.True(getAllNamespaceAuthorizationRulesResponse.Count() > 1);
Assert.Contains(getAllNamespaceAuthorizationRulesResponse, ns => ns.Name == authorizationRuleName);
Assert.Contains(getAllNamespaceAuthorizationRulesResponse, auth => auth.Name == RelayManagementHelper.DefaultNamespaceAuthorizationRule);
// Update namespace authorizationRule
string updatePrimaryKey = HttpMockServer.GetVariable("UpdatePrimaryKey", RelayManagementHelper.GenerateRandomKey());
AuthorizationRule updateNamespaceAuthorizationRuleParameter = new AuthorizationRule();
updateNamespaceAuthorizationRuleParameter.Rights = new List <AccessRights?>()
{
AccessRights.Listen
};
var updateNamespaceAuthorizationRuleResponse = RelayManagementClient.Namespaces.CreateOrUpdateAuthorizationRule(resourceGroup,
namespaceName, authorizationRuleName, updateNamespaceAuthorizationRuleParameter);
Assert.NotNull(updateNamespaceAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, updateNamespaceAuthorizationRuleResponse.Name);
Assert.True(updateNamespaceAuthorizationRuleResponse.Rights.Count == updateNamespaceAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateNamespaceAuthorizationRuleParameter.Rights)
{
Assert.Contains(updateNamespaceAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the updated namespace AuthorizationRule
var getNamespaceAuthorizationRuleResponse = RelayManagementClient.Namespaces.GetAuthorizationRule(resourceGroup, namespaceName, authorizationRuleName);
Assert.NotNull(getNamespaceAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, getNamespaceAuthorizationRuleResponse.Name);
Assert.True(getNamespaceAuthorizationRuleResponse.Rights.Count == updateNamespaceAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateNamespaceAuthorizationRuleParameter.Rights)
{
Assert.Contains(getNamespaceAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the connectionString to the namespace for a Authorization rule created
var listKeysResponse = RelayManagementClient.Namespaces.ListKeys(resourceGroup, namespaceName, authorizationRuleName);
Assert.NotNull(listKeysResponse);
Assert.NotNull(listKeysResponse.PrimaryConnectionString);
Assert.NotNull(listKeysResponse.SecondaryConnectionString);
// Regenerate AuthorizationRules
var regenerateKeysParameters = new RegenerateAccessKeyParameters();
regenerateKeysParameters.KeyType = KeyType.PrimaryKey;
//Primary Key
var regenerateKeysPrimaryResponse = RelayManagementClient.Namespaces.RegenerateKeys(resourceGroup, namespaceName, authorizationRuleName, regenerateKeysParameters);
Assert.NotNull(regenerateKeysPrimaryResponse);
Assert.NotEqual(regenerateKeysPrimaryResponse.PrimaryKey, listKeysResponse.PrimaryKey);
Assert.Equal(regenerateKeysPrimaryResponse.SecondaryKey, listKeysResponse.SecondaryKey);
regenerateKeysParameters.KeyType = KeyType.SecondaryKey;
//Secondary Key
var regenerateKeysSecondaryResponse = RelayManagementClient.Namespaces.RegenerateKeys(resourceGroup, namespaceName, authorizationRuleName, regenerateKeysParameters);
Assert.NotNull(regenerateKeysSecondaryResponse);
Assert.NotEqual(regenerateKeysSecondaryResponse.SecondaryKey, listKeysResponse.SecondaryKey);
Assert.Equal(regenerateKeysSecondaryResponse.PrimaryKey, regenerateKeysPrimaryResponse.PrimaryKey);
// Delete namespace authorizationRule
RelayManagementClient.Namespaces.DeleteAuthorizationRule(resourceGroup, namespaceName, authorizationRuleName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
try
{
// Delete namespace
RelayManagementClient.Namespaces.Delete(resourceGroup, namespaceName);
}
catch (Exception ex)
{
Assert.Contains("NotFound", ex.Message);
}
}
}
