static public SharedAccessAuthorizationRule ToSharedAccessAuthorizationRule(
this ServiceBusSharedAccessAuthorizationRule sbRule)
{
List <AccessRights> rights = new List <AccessRights>();
if (sbRule.Rights.Contains(AccessRight.Listen))
{
rights.Add(AccessRights.Listen);
}
if (sbRule.Rights.Contains(AccessRight.Manage))
{
rights.Add(AccessRights.Manage);
}
if (sbRule.Rights.Contains(AccessRight.Send))
{
rights.Add(AccessRights.Send);
}
var sasRule = new SharedAccessAuthorizationRule(sbRule.KeyName, sbRule.PrimaryKey, sbRule.SecondaryKey, rights);
sasRule.Revision = sbRule.Revision;
return(sasRule);
}
/// <summary>
/// Lists the notification hubs associated with a namespace.
/// </summary>
/// <param name='namespaceName'>
/// Required. The namespace name.
/// </param>
/// <param name='notificationHubName'>
/// Required. The notification hub name.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
/// <returns>
/// A standard service response including an HTTP status code and
/// request ID.
/// </returns>
public async System.Threading.Tasks.Task <Microsoft.WindowsAzure.Management.ServiceBus.Models.ServiceBusNotificationHubResponse> GetAsync(string namespaceName, string notificationHubName, CancellationToken cancellationToken)
{
// Validate
if (namespaceName == null)
{
throw new ArgumentNullException("namespaceName");
}
if (notificationHubName == null)
{
throw new ArgumentNullException("notificationHubName");
}
// Tracing
bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = Tracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("namespaceName", namespaceName);
tracingParameters.Add("notificationHubName", notificationHubName);
Tracing.Enter(invocationId, this, "GetAsync", tracingParameters);
}
// Construct URL
string url = "/" + (this.Client.Credentials.SubscriptionId != null ? this.Client.Credentials.SubscriptionId.Trim() : "") + "/services/servicebus/namespaces/" + namespaceName.Trim() + "/NotificationHubs/" + notificationHubName.Trim();
string baseUrl = this.Client.BaseUri.AbsoluteUri;
// Trim '/' character from the end of baseUrl and beginning of url.
if (baseUrl[baseUrl.Length - 1] == '/')
{
baseUrl = baseUrl.Substring(0, baseUrl.Length - 1);
}
if (url[0] == '/')
{
url = url.Substring(1);
}
url = baseUrl + "/" + url;
url = url.Replace(" ", "%20");
// Create HTTP transport objects
HttpRequestMessage httpRequest = null;
try
{
httpRequest = new HttpRequestMessage();
httpRequest.Method = HttpMethod.Get;
httpRequest.RequestUri = new Uri(url);
// Set Headers
httpRequest.Headers.Add("x-ms-version", "2013-08-01");
// Set Credentials
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
// Send Request
HttpResponseMessage httpResponse = null;
try
{
if (shouldTrace)
{
Tracing.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
Tracing.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
if (statusCode != HttpStatusCode.OK)
{
cancellationToken.ThrowIfCancellationRequested();
CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
if (shouldTrace)
{
Tracing.Error(invocationId, ex);
}
throw ex;
}
// Create Result
ServiceBusNotificationHubResponse result = null;
// Deserialize Response
cancellationToken.ThrowIfCancellationRequested();
string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
result = new ServiceBusNotificationHubResponse();
XDocument responseDoc = XDocument.Parse(responseContent);
XElement entryElement = responseDoc.Element(XName.Get("entry", "http://www.w3.org/2005/Atom"));
if (entryElement != null)
{
XElement titleElement = entryElement.Element(XName.Get("title", "http://www.w3.org/2005/Atom"));
if (titleElement != null)
{
}
XElement contentElement = entryElement.Element(XName.Get("content", "http://www.w3.org/2005/Atom"));
if (contentElement != null)
{
XElement notificationHubDescriptionElement = contentElement.Element(XName.Get("NotificationHubDescription", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (notificationHubDescriptionElement != null)
{
ServiceBusNotificationHub notificationHubDescriptionInstance = new ServiceBusNotificationHub();
result.NotificationHub = notificationHubDescriptionInstance;
XElement registrationTtlElement = notificationHubDescriptionElement.Element(XName.Get("RegistrationTtl", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (registrationTtlElement != null)
{
string registrationTtlInstance = registrationTtlElement.Value;
notificationHubDescriptionInstance.RegistrationTtl = registrationTtlInstance;
}
XElement authorizationRulesSequenceElement = notificationHubDescriptionElement.Element(XName.Get("AuthorizationRules", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (authorizationRulesSequenceElement != null)
{
foreach (XElement authorizationRulesElement in authorizationRulesSequenceElement.Elements(XName.Get("AuthorizationRule", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect")))
{
ServiceBusSharedAccessAuthorizationRule authorizationRuleInstance = new ServiceBusSharedAccessAuthorizationRule();
notificationHubDescriptionInstance.AuthorizationRules.Add(authorizationRuleInstance);
XElement claimTypeElement = authorizationRulesElement.Element(XName.Get("ClaimType", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (claimTypeElement != null)
{
string claimTypeInstance = claimTypeElement.Value;
authorizationRuleInstance.ClaimType = claimTypeInstance;
}
XElement claimValueElement = authorizationRulesElement.Element(XName.Get("ClaimValue", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (claimValueElement != null)
{
string claimValueInstance = claimValueElement.Value;
authorizationRuleInstance.ClaimValue = claimValueInstance;
}
XElement rightsSequenceElement = authorizationRulesElement.Element(XName.Get("Rights", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (rightsSequenceElement != null)
{
foreach (XElement rightsElement in rightsSequenceElement.Elements(XName.Get("AccessRights", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect")))
{
authorizationRuleInstance.Rights.Add(((AccessRight)Enum.Parse(typeof(AccessRight), rightsElement.Value, true)));
}
}
XElement createdTimeElement = authorizationRulesElement.Element(XName.Get("CreatedTime", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (createdTimeElement != null)
{
DateTime createdTimeInstance = DateTime.Parse(createdTimeElement.Value, CultureInfo.InvariantCulture);
authorizationRuleInstance.CreatedTime = createdTimeInstance;
}
XElement keyNameElement = authorizationRulesElement.Element(XName.Get("KeyName", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (keyNameElement != null)
{
string keyNameInstance = keyNameElement.Value;
authorizationRuleInstance.KeyName = keyNameInstance;
}
XElement modifiedTimeElement = authorizationRulesElement.Element(XName.Get("ModifiedTime", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (modifiedTimeElement != null)
{
DateTime modifiedTimeInstance = DateTime.Parse(modifiedTimeElement.Value, CultureInfo.InvariantCulture);
authorizationRuleInstance.ModifiedTime = modifiedTimeInstance;
}
XElement primaryKeyElement = authorizationRulesElement.Element(XName.Get("PrimaryKey", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (primaryKeyElement != null)
{
string primaryKeyInstance = primaryKeyElement.Value;
authorizationRuleInstance.PrimaryKey = primaryKeyInstance;
}
XElement secondaryKeyElement = authorizationRulesElement.Element(XName.Get("SecondaryKey", "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect"));
if (secondaryKeyElement != null)
{
string secondaryKeyInstance = secondaryKeyElement.Value;
authorizationRuleInstance.SecondaryKey = secondaryKeyInstance;
}
}
}
}
}
}
result.StatusCode = statusCode;
if (httpResponse.Headers.Contains("x-ms-request-id"))
{
result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (shouldTrace)
{
Tracing.Exit(invocationId, result);
}
return(result);
}
finally
{
if (httpResponse != null)
{
httpResponse.Dispose();
}
}
}
finally
{
if (httpRequest != null)
{
httpRequest.Dispose();
}
}
}
/// <summary>
/// The update authorization rule operation updates an authorization
/// rule for a namespace.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.ServiceBus.INamespaceOperations.
/// </param>
/// <param name='namespaceName'>
/// The namespace name.
/// </param>
/// <param name='rule'>
/// Updated access authorization rule.
/// </param>
/// <returns>
/// A response to a request for a particular authorization rule.
/// </returns>
public static Task <ServiceBusAuthorizationRuleResponse> UpdateAuthorizationRuleAsync(this INamespaceOperations operations, string namespaceName, ServiceBusSharedAccessAuthorizationRule rule)
{
return(operations.UpdateAuthorizationRuleAsync(namespaceName, rule, CancellationToken.None));
}
/// <summary>
/// The update authorization rule operation updates an authorization
/// rule for a namespace.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.ServiceBus.INamespaceOperations.
/// </param>
/// <param name='namespaceName'>
/// The namespace name.
/// </param>
/// <param name='rule'>
/// Updated access authorization rule.
/// </param>
/// <returns>
/// A response to a request for a particular authorization rule.
/// </returns>
public static ServiceBusAuthorizationRuleResponse UpdateAuthorizationRule(this INamespaceOperations operations, string namespaceName, ServiceBusSharedAccessAuthorizationRule rule)
{
try
{
return(operations.UpdateAuthorizationRuleAsync(namespaceName, rule).Result);
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.Count > 1)
{
throw;
}
else
{
throw ex.InnerException;
}
}
}
/// <summary>
/// The update authorization rule operation updates an authorization
/// rule for a namespace.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.ServiceBus.INamespaceOperations.
/// </param>
/// <param name='namespaceName'>
/// Required. The namespace name.
/// </param>
/// <param name='rule'>
/// Optional. Updated access authorization rule.
/// </param>
/// <returns>
/// A response to a request for a particular authorization rule.
/// </returns>
public static ServiceBusAuthorizationRuleResponse UpdateAuthorizationRule(this INamespaceOperations operations, string namespaceName, ServiceBusSharedAccessAuthorizationRule rule)
{
return(Task.Factory.StartNew((object s) =>
{
return ((INamespaceOperations)s).UpdateAuthorizationRuleAsync(namespaceName, rule);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
