/// <summary>
/// Get hybrid connection details async.
/// </summary>
/// <param name="subscription">Selected subscription.</param>
/// <param name="relayNamespace">Selected relay namespace.</param>
/// <param name="hybridConnectionName">Hybrid connection name.</param>
/// <returns>Hybrid connection details.</returns>
public async Task <HybridConnectionDetails> GetHybridConnectionAsync(
SubscriptionInner subscription,
RelayNamespaceInner relayNamespace,
string hybridConnectionName)
{
string accessToken = this.userAuthenticator.GetSubscriptionSpecificUserToken(subscription);
TokenCredentials tokenCredentials = new TokenCredentials(accessToken);
RelayManagementClient relayManagementClient = new RelayManagementClient(tokenCredentials)
{
SubscriptionId = subscription.SubscriptionId,
};
int startIndex = relayNamespace.Id.IndexOf("resourceGroups", StringComparison.OrdinalIgnoreCase) + 15;
string rgName = rgName = relayNamespace.Id.Substring(startIndex, relayNamespace.Id.IndexOf('/', startIndex) - startIndex);
List <HybridConnectionInner> hybridConnections = new List <HybridConnectionInner>();
hybridConnections.AddRange(await relayManagementClient.HybridConnections.ListByNamespaceAsync(rgName, relayNamespace.Name).ConfigureAwait(false));
// Create the hybrid connection if one does not exist.
if (!hybridConnections.Any(connection => connection.Name.Equals(hybridConnectionName, StringComparison.OrdinalIgnoreCase)))
{
await relayManagementClient.HybridConnections.CreateOrUpdateAsync(rgName, relayNamespace.Name, hybridConnectionName, new HybridConnectionInner
{
RequiresClientAuthorization = false,
}).ConfigureAwait(false);
}
return(await AzureRelayResourceManager.GetHybridConnectionDetailsAsync(rgName, hybridConnectionName, relayManagementClient, relayNamespace).ConfigureAwait(false));
}
public static RelayManagementClient GetRelayManagementClient(MockContext context, RecordedDelegatingHandler handler)
{
if (handler != null)
{
handler.IsPassThrough = true;
RelayManagementClient nhManagementClient = context.GetServiceClient <RelayManagementClient>(handlers: handler);
return(nhManagementClient);
}
return(null);
}
public async Task <LivenessResult> IsHealthy(LivenessExecutionContext context, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var tokenCredentials = await GetTokenCredentials(_clientID, _clientSecret, _tenantID);
var relayManagementClient = new RelayManagementClient(tokenCredentials);
return(LivenessResult.Healthy());
}
catch (Exception ex)
{
return(LivenessResult.UnHealthy(ex));
}
}
protected void InitializeClients(MockContext context)
{
if (!m_initialized)
{
lock (m_lock)
{
if (!m_initialized)
{
_resourceManagementClient = RelayManagementHelper.GetResourceManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
_relayManagementClient = RelayManagementHelper.GetRelayManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
}
}
}
}
/// <summary>
/// Gets the auth rules for a relay and return <see cref="HybridConnectionDetails"/> instance containing details of hybrid connection.
/// </summary>
/// <param name="rgName">Name of the Resource Group.</param>
/// <param name="hybridConnectionName">Hybrid connection name.</param>
/// <param name="relayManagementClient">The relay management client.</param>
/// <param name="relayNamespace">The selected relay.</param>
private static async Task <HybridConnectionDetails> GetHybridConnectionDetailsAsync(
string rgName,
string hybridConnectionName,
RelayManagementClient relayManagementClient,
RelayNamespaceInner relayNamespace)
{
List <AuthorizationRuleInner> relayAuthRuleList = new List <AuthorizationRuleInner>();
IPage <AuthorizationRuleInner> resp = await relayManagementClient.Namespaces.ListAuthorizationRulesAsync(rgName, relayNamespace.Name).ConfigureAwait(false);
relayAuthRuleList.AddRange(resp);
while (!string.IsNullOrEmpty(resp.NextPageLink))
{
resp = await relayManagementClient.Namespaces.ListAuthorizationRulesNextAsync(resp.NextPageLink).ConfigureAwait(false);
relayAuthRuleList.AddRange(resp);
}
AuthorizationRuleInner selectedAuthRule = relayAuthRuleList.FirstOrDefault(rule => rule.Rights != null && rule.Rights.Contains(AccessRights.Listen) && rule.Rights.Contains(AccessRights.Manage) && rule.Rights.Contains(AccessRights.Send));
if (selectedAuthRule == null)
{
throw new InvalidOperationException("Failed to find a suitable Authorization rule to use. Please create an Authorization rule with Listen, Manage and Send rights and retry the operation");
}
else
{
AccessKeysInner keyInfo = await relayManagementClient.Namespaces.ListKeysAsync(
rgName,
relayNamespace.Name,
selectedAuthRule.Name).ConfigureAwait(false);
return(new HybridConnectionDetails
{
HybridConnectionKeyName = keyInfo.KeyName,
HybridConnectionName = hybridConnectionName,
HybridConnectionSharedKey = keyInfo.PrimaryKey,
RelayUrl = relayNamespace.ServiceBusEndpoint,
});
}
}
/// <summary>
/// Gets the relay namespaces present in a subscription.
/// </summary>
/// <param name="subscription">Subscription to get namespaces from.</param>
/// <returns>List of relay namespaces.</returns>
public async Task <List <RelayNamespaceInner> > GetRelayNamespacesAsync(SubscriptionInner subscription)
{
string accessToken = this.userAuthenticator.GetSubscriptionSpecificUserToken(subscription);
TokenCredentials tokenCredentials = new TokenCredentials(accessToken);
RelayManagementClient relayManagementClient = new RelayManagementClient(tokenCredentials)
{
SubscriptionId = subscription.SubscriptionId,
};
List <RelayNamespaceInner> relayList = new List <RelayNamespaceInner>();
IPage <RelayNamespaceInner> resp = await relayManagementClient.Namespaces.ListAsync().ConfigureAwait(false);
relayList.AddRange(resp);
while (!string.IsNullOrEmpty(resp.NextPageLink))
{
resp = await relayManagementClient.Namespaces.ListNextAsync(resp.NextPageLink).ConfigureAwait(false);
relayList.AddRange(resp);
}
return(relayList.OrderBy(relay => relay.Name).ToList());
}
/// <summary>
/// Creates a new hybrid connection and returns it's details.
/// </summary>
/// <param name="subscription">Subscription to create the relay under.</param>
/// <param name="relayName">Relay name.</param>
/// <param name="hybridConnectionName">Hybrid connection name.</param>
/// <param name="locationName">Location for the new relay.</param>
/// <returns>Hybrid connection details.</returns>
public async Task <HybridConnectionDetails> CreateHybridConnectionAsync(
SubscriptionInner subscription,
string relayName,
string hybridConnectionName,
string locationName)
{
string accessToken = this.userAuthenticator.GetSubscriptionSpecificUserToken(subscription);
TokenCredentials tokenCredentials = new TokenCredentials(accessToken);
ResourceManagementClient resourceManagementClient = new ResourceManagementClient(tokenCredentials)
{
SubscriptionId = subscription.SubscriptionId,
};
RelayManagementClient relayManagementClient = new RelayManagementClient(tokenCredentials)
{
SubscriptionId = subscription.SubscriptionId,
};
ResourceGroupInner resourceGroup = null;
RelayNamespaceInner relayNamespace = null;
Location location = this.userAuthenticator.GetSubscriptionLocations(subscription).First(region =>
region.DisplayName.Equals(locationName, StringComparison.OrdinalIgnoreCase) ||
region.Name.Equals(locationName, StringComparison.OrdinalIgnoreCase));
try
{
resourceGroup = await resourceManagementClient.ResourceGroups.GetAsync("TunnelRelay").ConfigureAwait(false);
}
catch (CloudException httpEx)
{
if (httpEx.Response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
resourceGroup = await resourceManagementClient.ResourceGroups.CreateOrUpdateAsync("TunnelRelay", new ResourceGroupInner
{
Location = location.Name,
Name = "TunnelRelay",
Tags = new Dictionary <string, string>()
{
{ "CreatedBy", "TunnelRelayv2" }
},
}).ConfigureAwait(false);
}
}
string rgName = resourceGroup.Name;
relayNamespace = await relayManagementClient.Namespaces.CreateOrUpdateAsync(rgName, relayName, new RelayNamespaceInner
{
Location = resourceGroup.Location,
Sku = new Microsoft.Azure.Management.Relay.Fluent.Models.Sku(SkuTier.Standard),
Tags = new Dictionary <string, string>()
{
{ "CreatedBy", "TunnelRelayv2" }
},
}).ConfigureAwait(false);
await relayManagementClient.HybridConnections.CreateOrUpdateAsync(rgName, relayName, hybridConnectionName, new HybridConnectionInner
{
RequiresClientAuthorization = false,
}).ConfigureAwait(false);
return(await AzureRelayResourceManager.GetHybridConnectionDetailsAsync(rgName, hybridConnectionName, relayManagementClient, relayNamespace).ConfigureAwait(false));
}
