public static void SendAsynchronously(this INotificationContent notification, Uri channelUri, IAccessTokenProvider accessTokenProvider, Action<NotificationSendResult> sent, Action<NotificationSendResult> error, NotificationSendOptions options) { var payload = notification.GetContent(); var type = notification.GetNotificationType(); NotificationSendUtils.SendAsynchronously(channelUri, accessTokenProvider, payload, sent, error, type, options); }
public static NotificationSendResult Send(this INotificationContent notification, Uri channelUri, IAccessTokenProvider accessTokenProvider, NotificationSendOptions options) { var payload = notification.GetContent(); var type = notification.GetNotificationType(); return NotificationSendUtils.Send(channelUri, accessTokenProvider, payload, type, options); }
public HttpUserProxy( Uri uri, IAccessTokenProvider accessTokenProvider) { _uri = uri; _accessTokenProvider = accessTokenProvider; }
public FilesCommunicationClientFactory(IServicePartitionResolver resolver, IAccessTokenProvider accessTokenProvider, IOptions <ApiOptions> apiOptions) : base(resolver, new[] { new HttpExceptionHandler() }) { if (accessTokenProvider == null) { throw new ArgumentNullException(nameof(accessTokenProvider)); } this.accessTokenProvider = accessTokenProvider; this.apiOptions = apiOptions.Value; }
public TokenService(IAccessTokenProvider accessTokenProvider, IRefreshTokenProvider refreshTokenProvider, ITokensRepository tokensRepository, TokensConfiguration config) { this._accessTokenProvider = accessTokenProvider; this._refreshTokenProvider = refreshTokenProvider; this._tokensRepository = tokensRepository; this._config = config; this._claims = ConfigureClaims(); }
public WorkflowClientController(WorkflowHttpClientProxyProvider workflowHttpClientProxy, IAccessTokenProvider accessToken, IHttpContextAccessor httpContextAccessor) { httpContext = httpContextAccessor.HttpContext; this.accessToken = accessToken; processInstanceClient = workflowHttpClientProxy.GetProcessInstanceClient(); taskClient = workflowHttpClientProxy.GetTaskClient(); taskAdminClient = workflowHttpClientProxy.GetTaskAdminClient(); deployerClient = workflowHttpClientProxy.GetDefinitionDeployerClient(); processDefinitionClient = workflowHttpClientProxy.GetProcessDefinitionClient(); processInstanceTaskClient = workflowHttpClientProxy.GetProcessInstanceTasksClient(); }
public async Task ProvisionAccessTokenAsync_ServiceClaimProvided_ServiceCacheUsed() { m_serviceTokenCacheMock.Setup(x => x.GetAsync(It.IsAny <string>())) .Returns(Task.FromResult(new CacheResponse(true, BuildTestToken(specifyUserClaim: false)))); IAccessTokenProvider cachedAccessTokenProvider = GetCachedAccessTokenProvider(); IAccessToken token = await cachedAccessTokenProvider.ProvisionAccessTokenAsync(m_claims, m_scopes, m_serviceTokenCacheMock.Object).ConfigureAwait(false); Assert.NotNull(token); }
public AuthorizedAuthorizationMessageHandler(IAccessTokenProvider provider, NavigationManager navigationManager) : base(provider, navigationManager) { ConfigureHandler( authorizedUrls: new[] { "https://dzigalleryfunctions.azurewebsites.net" }, scopes: new[] { "fca594e3-3b1d-460a-b21a-425b32473479/Annotations.Edit", "fca594e3-3b1d-460a-b21a-425b32473479/Images.Edit" }); }
public AzureAccessTokenClientInitializerTests() { _exportJobConfiguration = new ExportJobConfiguration(); IOptions <ExportJobConfiguration> optionsExportConfig = Substitute.For <IOptions <ExportJobConfiguration> >(); optionsExportConfig.Value.Returns(_exportJobConfiguration); _accessTokenProvider = Substitute.For <IAccessTokenProvider>(); _logger = Substitute.For <ILogger <AzureAccessTokenClientInitializer> >(); _azureAccessTokenClientInitializer = new AzureAccessTokenClientInitializer(_accessTokenProvider, optionsExportConfig, _logger); }
/// <summary> /// /// </summary> /// <param name="httpClient"></param> /// <param name="accessTokenProvider"></param> /// <param name="httpContext"></param> public DefaultHttpClientProxy(HttpClient httpClient, IAccessTokenProvider accessTokenProvider, IHttpContextAccessor httpContextAccessor, ILoggerFactory loggerFactory) { this.httpClient = httpClient; this.httpClient.Timeout = TimeSpan.FromMinutes(10); this.httpClient.DefaultRequestHeaders.ConnectionClose = false; this.accessTokenProvider = accessTokenProvider; this.httpContextAccessor = httpContextAccessor; this.logger = loggerFactory.CreateLogger <DefaultHttpClientProxy>(); }
/// <summary> /// Initializes the http client for access Bridge API /// </summary> /// <param name="client">the http client</param> /// <param name="accessTokenProvider">The provider giving an access token to use against the brdige API</param> /// <param name="platformSettings">the platform settings configured for the authorization functions</param> /// <param name="logger">The logger</param> public BridgeClient(HttpClient client, IAccessTokenProvider accessTokenProvider, IOptions <PlatformSettings> platformSettings, ILogger <BridgeClient> logger) { _accessTokenProvider = accessTokenProvider; _logger = logger; PlatformSettings settings = platformSettings.Value; Client = client; Client.BaseAddress = new Uri(settings.BridgeApiEndpoint); Client.Timeout = new TimeSpan(0, 0, 30); Client.DefaultRequestHeaders.Clear(); Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); }
public static IMembersClient CreateMembersClient( string baseUrl, HttpClient http, IAccessTokenProvider tokenProvider, Func <IAccessTokenProvider, Task <string> > retrieveAuthorizationToken) { return(new MembersClient(baseUrl, http) { AccessTokenProvider = tokenProvider, RetrieveAuthorizationToken = retrieveAuthorizationToken }); }
/// <summary> /// Initializes a new instance of the <see cref="AuthenticationProvider"/> class. /// </summary> /// <param name="customerId">Identifier for customer whose resources are being accessed.</param> /// <param name="authorizationCode">The authorization code received from service authorization endpoint.</param> /// <param name="redirectUri">Address to return to upon receiving a response from the authority.</param> /// <exception cref="ArgumentException"> /// <paramref name="customerId"/> is empty or null. /// or /// <paramref name="authorizationCode"/> is empty or null. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="redirectUri"/> is null. /// </exception> public AuthenticationProvider(string customerId, string authorizationCode, Uri redirectUri) { customerId.AssertNotEmpty(nameof(customerId)); authorizationCode.AssertNotNull(nameof(authorizationCode)); redirectUri.AssertNotNull(nameof(redirectUri)); this.customerId = customerId; this.authorizationCode = authorizationCode; this.redirectUri = redirectUri; tokenProvider = new AccessTokenProvider(); }
public void TestAccessTokenProvider_InvalidRSAParameters_TokenIsInvalid() { var randomRsaParameters = new RSACryptoServiceProvider(OAuth2.Keys.Constants.GENERATED_RSA_KEY_SIZE) { PersistKeyInCsp = false }.ExportParameters(true); using (var httpClient = new HttpClient()) { IAccessTokenProvider provider = TestAccessTokenProviderFactory.Create(httpClient, DEV_AUTH_URL, Guid.NewGuid(), randomRsaParameters); Assert.Throws <AuthServiceException>(async() => await provider.ProvisionAccessTokenAsync(testClaimSet, testScopes).SafeAsync()); } }
public DigitalTwinsApiConnector(ILogger logger, IAccessTokenProvider accessTokenProvider, IConfigurationProvider configurationProvider) { _logger = logger; _accessTokenProvider = accessTokenProvider; _configurationProvider = configurationProvider; _httpClient = new HttpClient() { BaseAddress = new Uri(_configurationProvider.AzureDigitalTwinsApiUrl) }; }
public NotificationHub(Uri host, IAccessTokenProvider tokenProvider, AuthenticationStateProvider stateProvider) { _stateProvider = stateProvider; _notifications = new List <NotificationModel>(); _connection = new HubConnectionBuilder() .WithUrl(new Uri(host, "/hubs/notification"), options => { options.AccessTokenProvider = async() => { var result = await tokenProvider.RequestAccessToken(); return(result.TryGetToken(out var token) ? token.Value : null); };
public async Task ProvisionAccessTokenAsync_AlreadyCached_UsesCachedValueAndDoesNotCallThroughToAccessTokenProvider() { m_serviceTokenCacheMock.Setup(x => x.GetAsync(It.IsAny <string>())) .Returns(Task.FromResult(new CacheResponse(true, BuildTestToken()))); IAccessTokenProvider cachedAccessTokenProvider = GetCachedAccessTokenProvider(); IAccessToken token = await cachedAccessTokenProvider.ProvisionAccessTokenAsync(m_claims, m_scopes, m_serviceTokenCacheMock.Object).ConfigureAwait(false); Assert.NotNull(token); }
public CustomAuthorizationMessageHandler(IAccessTokenProvider provider, NavigationManager navigationManager) : base(provider, navigationManager) { ConfigureHandler( authorizedUrls: new[] { "https://localhost:44300", "https://localhost:44301", "https://localhost:44302" }, scopes: new[] { "api.read.access" }); }
public async Task ProvisionAccessTokenAsync_UserClaimProvided_UserCacheUsed() { m_userTokenCacheMock.Setup(x => x.GetAsync(It.IsAny <string>())) .Returns(Task.FromResult(new CacheResponse(true, BuildTestToken(specifyUserClaim: true)))); IAccessTokenProvider cachedAccessTokenProvider = GetCachedAccessTokenProvider(); Claim userClaim = new Claim(Constants.Claims.USER_ID, "user"); IAccessToken token = await cachedAccessTokenProvider.ProvisionAccessTokenAsync(new[] { userClaim }, m_scopes, m_userTokenCacheMock.Object).ConfigureAwait(false); Assert.NotNull(token); }
public static Task <Episode> GetFullDetailsAsync( this SimplifiedEpisode episode, HttpClient httpClient, IAccessTokenProvider accessTokenProvider, CancellationToken cancellationToken = default) { if (episode is Episode original) { return(Task.FromResult(original)); } return(httpClient.GetAsync <Episode>(episode.Href, accessTokenProvider, cancellationToken)); }
public OrganisationInviteFunctions() { //var issuerToken = Environment.GetEnvironmentVariable("IssuerToken"); //var audience = Environment.GetEnvironmentVariable("Audience"); //var issuer = Environment.GetEnvironmentVariable("Issuer"); var issuerToken = TemporaryEnvironmentVariables.GetIssuerToken(); var audience = TemporaryEnvironmentVariables.GetAudience(); var issuer = TemporaryEnvironmentVariables.GetIssuer(); _tokenCreator = new AccessTokenCreator(issuerToken, audience, issuer); _tokenProvider = new AccessTokenProvider(issuerToken, audience, issuer); }
public AuthorizedAuthorizationMessageHandler( IAccessTokenProvider provider, NavigationManager navigationManager) : base(provider, navigationManager) { ConfigureHandler( authorizedUrls: new[] { "https://serverlesscrud.azurewebsites.net" }, scopes: new[] { "db944478-cbda-4214-8ad6-7b310465ce97/BlogPosts.Read", "db944478-cbda-4214-8ad6-7b310465ce97/BlogPosts.Write" }); }
public static Task <Track> GetFullDetailsAsync( this SimplifiedTrack track, HttpClient httpClient, IAccessTokenProvider accessTokenProvider, CancellationToken cancellationToken = default) { if (track is Track original) { return(Task.FromResult(original)); } return(httpClient.GetAsync <Track>(track.Href, accessTokenProvider, cancellationToken)); }
public AzureAccessTokenClientInitializer( IAccessTokenProvider accessTokenProvider, IOptions <ExportJobConfiguration> exportJobConfiguration, ILogger <AzureAccessTokenClientInitializer> logger) { EnsureArg.IsNotNull(accessTokenProvider, nameof(accessTokenProvider)); EnsureArg.IsNotNull(exportJobConfiguration?.Value, nameof(exportJobConfiguration)); EnsureArg.IsNotNull(logger, nameof(logger)); _accessTokenProvider = accessTokenProvider; _exportJobConfiguration = exportJobConfiguration.Value; _logger = logger; }
public static Task <Album> GetFullDetailsAsync( this SimplifiedAlbum album, HttpClient httpClient, IAccessTokenProvider accessTokenProvider, CancellationToken cancellationToken = default) { if (album is Album original) { return(Task.FromResult(original)); } return(httpClient.GetAsync <Album>(album.Href, accessTokenProvider, cancellationToken)); }
public static async Task UseToken(this IRepository repository, IAccessTokenProvider provider) { var tokenResult = await provider.RequestAccessToken(); if (tokenResult.TryGetToken(out var token)) { if (repository.Context is null) { repository.Context = new RepositoryAccessContext(); } repository.Context.Token = token.Value; } }
public static Task <Show> GetFullDetailsAsync( this SimplifiedShow show, HttpClient httpClient, IAccessTokenProvider accessTokenProvider, CancellationToken cancellationToken = default) { if (show is Show original) { return(Task.FromResult(original)); } return(httpClient.GetAsync <Show>(show.Href, accessTokenProvider, cancellationToken)); }
/// <summary> /// Creates a new instance of the <see cref="AzFuncAuthorizationMessageHandler"/> /// class. /// </summary> /// <param name="config"><see cref="IConfiguration"/> to access endpoint.</param> /// <param name="provider"><see cref="IAccessTokenProvider"/> service.</param> /// <param name="navigation"><see cref="NavigationManager"/> to navigate based on authentication.</param> public AzFuncAuthorizationMessageHandler( IConfiguration config, IAccessTokenProvider provider, NavigationManager navigation) : base(provider, navigation) { var section = config.GetSection(nameof(UrlShortenerSecuredService)); Endpoint = section.GetValue <string>(nameof(Endpoint)); ConfigureHandler( new[] { Endpoint }, new[] { string.Concat(Endpoint, "user_impersonation") } ); }
public VacationController( ILogger <VacationController> logger, IAccessTokenProvider accessTokenProvider, IVacationRepository vacationRepository, IUserRepository userRepository, IMailHelper mailHelper) { _logger = logger; _accessTokenProvider = accessTokenProvider; _vacationRepository = vacationRepository; _userRepository = userRepository; _mailHelper = mailHelper; }
public ClientHubClientService( IAccessTokenProvider tokenProvider, NavigationManager navigationManager, IWebGroupService groupService, IWebUserService userService, IWebMessageService messagesService) { _tokenProvider = tokenProvider; _navigationManager = navigationManager; _groupService = groupService; _userService = userService; _messagesService = messagesService; }
public AuthController(GoogleDriveSettings googleDriveSettings) { settings = googleDriveSettings; // WebGL doesn't support loopback method; using redirection scheme instead. #if UNITY_WEBGL && !UNITY_EDITOR accessTokenProvider = new RedirectAccessTokenProvider(settings); #else accessTokenProvider = new LoopbackAccessTokenProvider(settings); #endif accessTokenProvider.OnDone += HandleAccessTokenProviderDone; }
public AzureAccessTokenClientInitializerV2( IAccessTokenProvider accessTokenProvider, IOptions <IntegrationDataStoreConfiguration> integrationDataStoreConfiguration, ILogger <AzureAccessTokenClientInitializerV2> logger) { EnsureArg.IsNotNull(accessTokenProvider, nameof(accessTokenProvider)); EnsureArg.IsNotNull(integrationDataStoreConfiguration?.Value, nameof(integrationDataStoreConfiguration)); EnsureArg.IsNotNull(logger, nameof(logger)); _accessTokenProvider = accessTokenProvider; _integrationDataStoreConfiguration = integrationDataStoreConfiguration.Value; _logger = logger; }
public PlatformClient(string host, IAccessTokenProvider accessTokenProvider) : base(host, accessTokenProvider) { Clusters = new ClusterClient(this); Domains = new DomainClient(this); Hosts = new HostClient(this); Programs = new ProgramClient(this); Repositories = new RepositoryClient(this); Environments = new EnvironmentClient(this); Events = new EventClient(this); Exceptions = new ExceptionClient(this); Deployments = new DeploymentClient(this); Users = new UsersClient(this); }
public OAuth2BearerTokenHandler(IAccessTokenStore tokenStore, IAccessTokenProvider tokenProvider) { if (tokenStore == null) { throw new ArgumentNullException("tokenStore"); } if (tokenProvider == null) { throw new ArgumentNullException("tokenProvider"); } this.TokenStore = tokenStore; this.TokenProvider = tokenProvider; }
public PushNotificationController(CloudQueueClient cloudQueueClient, CloudBlobClient cloudBlobClient, IWnsEndpointRepository endpointsRepository, IAccessTokenProvider tokenProvider) { this.endpointsRepository = endpointsRepository; CloudStorageAccount account = null; if ((account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString")) == null) { if (cloudQueueClient == null) { throw new ArgumentNullException("cloudQueueClient", "Cloud Queue Client cannot be null if no configuration is loaded."); } } this.cloudQueueClient = cloudQueueClient ?? account.CreateCloudQueueClient(); this.blobClient = cloudBlobClient ?? account.CreateCloudBlobClient(); this.tokenProvider = tokenProvider; }
public static void SendAsynchronously(Uri channelUri, IAccessTokenProvider accessTokenProvider, string payload, Action<NotificationSendResult> sent, Action<NotificationSendResult> error, NotificationType type, NotificationSendOptions options) { SendAsynchronously(channelUri, accessTokenProvider, payload, sent, error, type, options.SecondsTTL, options.Cache, options.RequestForStatus, options.Tag, options.Priority); }
public static void SendAsynchronously(Uri channelUri, IAccessTokenProvider accessTokenProvider, string payload, Action<NotificationSendResult> sent, Action<NotificationSendResult> error, NotificationType type, int? secondsTTL = null, bool? cache = null, bool? requestForStatus = null, string tag = null, NotificationPriority priority = NotificationPriority.Normal, int tokenRetry = 0) { byte[] payloadBytes; try { WnsDiagnostics.TraceVerbose( DiagnosticsConstants.SendingWNSNotificationID, "Sending WNS notification.\r\n\r\n{0}", NotificationRequestStatus(channelUri.ToString(), payload, secondsTTL, cache, requestForStatus, tag, priority, tokenRetry)); var accessToken = string.Empty; try { accessToken = accessTokenProvider.GetAccessToken(true); } catch (WebException e) { if (e.Response != null) { var accessTokenError = GetAccessTokenError(e.Response); WnsDiagnostics.TraceError(DiagnosticsConstants.WnsAccessTokenSendResultErrorID, AccessTokenLogMessage(e.Response, accessTokenError)); error(new WnsAccessTokenSendResult(channelUri, e, accessTokenError)); } else { WnsDiagnostics.TraceError(DiagnosticsConstants.ServiceUnavailableErrorID, e.Message); error(new NotificationSendResult(channelUri, e.Message, HttpStatusCode.ServiceUnavailable)); } } if (!string.IsNullOrEmpty(accessToken)) { var request = CreateWebRequest(channelUri, accessToken, payload, type, secondsTTL, cache, requestForStatus, tag, priority, out payloadBytes); // Get the request stream asynchronously. request.BeginGetRequestStream( requestAsyncResult => { try { using (Stream requestStream = request.EndGetRequestStream(requestAsyncResult)) { // Start writing the payload to the stream. requestStream.Write(payloadBytes, 0, payloadBytes.Length); } // Switch to receiving the response from WNS asynchronously. request.BeginGetResponse( responseAsyncResult => { try { using ( var response = (HttpWebResponse)request.EndGetResponse(responseAsyncResult)) { var result = new NotificationSendResult(channelUri, response); if (result.StatusCode == HttpStatusCode.OK) { WnsDiagnostics.TraceInformation(DiagnosticsConstants.SentWNSNotificationID, NotificationLogMessage("Sent WNS notification", result.NotificationStatus.ToString(), result, payload, request, response)); sent(result); } else { error(result); WnsDiagnostics.TraceError(DiagnosticsConstants.WNSNotificationFailureID, "WNS notification failure:\r\n\r\n{0}", result); } } } catch (WebException e) { if (e.Response != null) { var result = new NotificationSendResult(channelUri, e); string exceptionDetails = e.Response.Headers[WnsHeaders.WWWAuthenticate]; if (!string.IsNullOrWhiteSpace(exceptionDetails) && exceptionDetails.Contains("Token expired")) { accessTokenProvider.ResetCachedToken(); tokenRetry++; if (tokenRetry <= MaxSendRetries) { SendAsynchronously(channelUri, accessTokenProvider, payload, sent, error, type, secondsTTL, cache, requestForStatus, tag, priority, tokenRetry); } else { WnsDiagnostics.TraceError(DiagnosticsConstants.WNSNotificationFailureID, NotificationLogMessage("WNS notification failure", e.Message, result, payload, request, e.Response)); error(result); } } else { WnsDiagnostics.TraceError(DiagnosticsConstants.WNSNotificationFailureID, NotificationLogMessage("WNS notification failure", e.Message, result, payload, request, e.Response)); error(result); } } else { WnsDiagnostics.TraceError(DiagnosticsConstants.ServiceUnavailableErrorID, e.Message); error(new NotificationSendResult(channelUri, e.Message, HttpStatusCode.ServiceUnavailable)); } } catch (Exception ex3) { var result = new NotificationSendResult(channelUri, ex3); WnsDiagnostics.TraceException(DiagnosticsConstants.GeneralNotificationFailureID, ex3, "WNS notification failure: {0}\r\n\r\n{1}", ex3.Message, result); error(result); } }, null); } catch (Exception ex2) { var result = new NotificationSendResult(channelUri, ex2); WnsDiagnostics.TraceException(DiagnosticsConstants.GeneralNotificationFailureID, ex2, "WNS notification failure: {0}\r\n\r\n{1}", ex2.Message, result); error(result); } }, null); } } catch (Exception ex1) { var result = new NotificationSendResult(channelUri, ex1); WnsDiagnostics.TraceException(DiagnosticsConstants.GeneralNotificationFailureID, ex1, "WNS notification failure: {0}\r\n\r\n{1}", ex1.Message, result); error(result); } }
public static NotificationSendResult Send(Uri channelUri, IAccessTokenProvider accessTokenProvider, string payload, NotificationType type, NotificationSendOptions options) { return Send(channelUri, accessTokenProvider, payload, type, options.SecondsTTL, options.Cache, options.RequestForStatus, options.Tag, options.Priority); }
public static NotificationSendResult Send(Uri channelUri, IAccessTokenProvider accessTokenProvider, string payload, NotificationType type, int? secondsTTL = null, bool? cache = null, bool? requestForStatus = null, string tag = null, NotificationPriority priority = NotificationPriority.Normal, int tokenRetry = 0) { NotificationSendResult result; byte[] payloadBytes; HttpWebRequest request = null; try { WnsDiagnostics.TraceVerbose( DiagnosticsConstants.SendingWNSNotificationID, "Sending WNS notification.\r\n\r\n{0}", NotificationRequestStatus(channelUri.ToString(), payload, secondsTTL, cache, requestForStatus, tag, priority, tokenRetry)); var accessToken = string.Empty; try { accessToken = accessTokenProvider.GetAccessToken(true); } catch (WebException e) { if (e.Response != null) { var accessTokenError = GetAccessTokenError(e.Response); WnsDiagnostics.TraceError(DiagnosticsConstants.WnsAccessTokenSendResultErrorID, AccessTokenLogMessage(e.Response, accessTokenError)); return new WnsAccessTokenSendResult(channelUri, e, accessTokenError); } else { WnsDiagnostics.TraceError(DiagnosticsConstants.ServiceUnavailableErrorID, e.Message); return new NotificationSendResult(channelUri, e.Message, HttpStatusCode.ServiceUnavailable); } } request = CreateWebRequest(channelUri, accessToken, payload, type, secondsTTL, cache, requestForStatus, tag, priority, out payloadBytes); using (Stream requestStream = request.GetRequestStream()) { requestStream.Write(payloadBytes, 0, payloadBytes.Length); } var response = (HttpWebResponse)request.GetResponse(); result = new NotificationSendResult(channelUri, response); WnsDiagnostics.TraceInformation(DiagnosticsConstants.SentWNSNotificationID, NotificationLogMessage("Sent WNS notification", result.NotificationStatus.ToString(), result, payload, request, response)); } catch (WebException e) { if (e.Response != null) { string exceptionDetails = e.Response.Headers[WnsHeaders.WWWAuthenticate]; if (!string.IsNullOrWhiteSpace(exceptionDetails) && exceptionDetails.Contains("Token expired")) { accessTokenProvider.ResetCachedToken(); tokenRetry++; if (tokenRetry <= MaxSendRetries) { result = Send(channelUri, accessTokenProvider, payload, type, secondsTTL, cache, requestForStatus, tag, priority, tokenRetry); } else { result = new NotificationSendResult(channelUri, e); } } else { result = new NotificationSendResult(channelUri, e); } WnsDiagnostics.TraceError(DiagnosticsConstants.WNSNotificationFailureID, NotificationLogMessage("WNS notification failure", e.Message, result, payload, request, e.Response)); } else { WnsDiagnostics.TraceError(DiagnosticsConstants.ServiceUnavailableErrorID, e.Message); return new NotificationSendResult(channelUri, e.Message, HttpStatusCode.ServiceUnavailable); } } catch (Exception e) { result = new NotificationSendResult(channelUri, e); WnsDiagnostics.TraceException(DiagnosticsConstants.WNSNotificationFailureID, e, "WNS notification failure: {0}\r\n\r\n{1}", e.Message, result); } return result; }