private bool IsRetryEligible(HandleUnsuccessfulResponseArgs args) { return(this.HandleUnsuccessfulResponseFunc != null && this.HandleUnsuccessfulResponseFunc(args.Response) && args.SupportsRetry && args.CurrentFailedTry <= this.BackOff.MaxNumOfRetries); }
public Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(); tcs.SetResult(args.Response.StatusCode.Equals(HttpStatusCode.ServiceUnavailable)); return(tcs.Task); }
public Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(); tcs.SetResult(true); return(tcs.Task); }
public override async Task <bool> HandleResponseAsync( HandleUnsuccessfulResponseArgs args) { // if the func returns true try to handle this current failed try if (this.IsRetryEligible(args)) { var delay = this.GetDelayFromResponse(args.Response); // Retry-After header can specify very long delay intervals (e.g. 24 hours). If // we cannot wait that long, we should not perform any retries at all. In // general it is not correct to retry earlier than what the server has // recommended to us. if (delay > this.MaxTimeSpan) { return(false); } else if (delay > TimeSpan.Zero) { await this.Wait(delay, args.CancellationToken).ConfigureAwait(false); return(true); } } return(await base.HandleResponseAsync(args).ConfigureAwait(false)); }
/// <summary> /// Handles an abnormal response when sending a HTTP request. /// A simple rule must be followed, if you modify the request object in a way that the abnormal response can /// be resolved, you must return <c>true</c>. /// </summary> public async Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { if (args.Response.StatusCode == HttpStatusCode.Unauthorized) { return(await RefreshTokenAsync(args.CancellationToken).ConfigureAwait(false)); } return(false); }
public async Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { // TODO(peleyal): check WWW-Authenticate header. if (args.Response.StatusCode == HttpStatusCode.Unauthorized) { return(!Object.Equals(Token.AccessToken, AccessMethod.GetAccessToken(args.Request)) || await RequestAccessTokenAsync(args.CancellationToken).ConfigureAwait(false)); } return(false); }
public async Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { if (args.Response.StatusCode == System.Net.HttpStatusCode.Unauthorized) { await _client.GetCurrentToken(); return(true); } return(false); }
public bool HandleResponse(HandleUnsuccessfulResponseArgs args) { var statusCode = (int)args.Response.StatusCode; // handle the error if and only if all the following conditions occur: // - there is going to be an actual retry // - the message request is for media upload with the current Uri (remember that the message handler // can be invoked from other threads \ messages, so we should call server error callback only if the // request is in the current context). // - we got a 5xx server error. if (args.SupportsRetry && args.Request.RequestUri.Equals(Owner.UploadUri) && statusCode / 100 == 5) { return OnServerError(args.Request); } return false; }
/// <summary> /// Decorates unsuccessful responses, returns true if the response gets modified. /// See IHttpUnsuccessfulResponseHandler for more information. /// </summary> public async Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { // If the response was unauthorized, request a new access token so that the original // request can be retried. // TODO(peleyal): check WWW-Authenticate header. if (args.Response.StatusCode == HttpStatusCode.Unauthorized) { bool tokensEqual = false; if (Token != null) { tokensEqual = Object.Equals( Token.AccessToken, AccessMethod.GetAccessToken(args.Request)); } return(!tokensEqual || await RequestAccessTokenAsync(args.CancellationToken).ConfigureAwait(false)); } return(false); }
public async Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { var retry = args.SupportsRetry && await IsRetriableResponse(args.Response).ConfigureAwait(false); if (!retry) { return(false); } // The first failure will have args.CurrentFailedTry set to 1, // whereas we want the first delay to be 1 second. We use Math.Min on the power // rather than on the result to obtain a max retry of 32 seconds without risking // calling Math.Pow with a huge number. int power = Math.Min(args.CurrentFailedTry - 1, 5); double seconds = Math.Pow(2.0, power); var delay = TimeSpan.FromSeconds(seconds); await Task.Delay(delay, args.CancellationToken).ConfigureAwait(false); return(true); }
/// <summary> /// Handler for back-off, if retry is not possible it returns <c>false</c>. Otherwise it blocks for some time (miliseconds) /// and returns <c>true</c>, so call is retried. /// </summary> /// <param name="args">The arguments object to handler call.</param> /// <returns>If request could be retried.</returns> public async Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { if (!args.SupportsRetry || _backoff.MaxNumOfRetries < args.CurrentFailedTry) { return(false); } if (IsTransientError(args.Response.StatusCode, _service.DeserializeError(args.Response).Result)) { var delay = _backoff.GetNextBackOff(args.CurrentFailedTry); if (delay > _maxTimeSpan || delay < TimeSpan.Zero) { return(false); } await Task.Delay(delay, args.CancellationToken); Logger.Log("Back-Off waited " + delay.TotalMilliseconds + "ms before next retry...", EventType.Debug); return(true); } return(false); }
public Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) => Task.FromResult(++Count == 0);
public bool HandleResponse(HandleUnsuccessfulResponseArgs args) { return(true); }
/// <inheritdoc /> public Task <bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args) { logger.LogWarning($"{args.Request.RequestUri} returned status code {args.Response.StatusCode}", args); return(Task.FromResult(false)); }
public bool HandleResponse(HandleUnsuccessfulResponseArgs args) { HandleCalls++; // Mock a refresh token process here... (second apply will attach SecondToken authorization) return(true); }
/// <summary> /// Override handle response to refresh the token when Unauthorized status code is received. /// </summary> public bool HandleResponse(HandleUnsuccessfulResponseArgs args) { return(args.Response.StatusCode == HttpStatusCode.Unauthorized && tokenProvider.RefreshToken(State, null)); }
public bool HandleResponse(HandleUnsuccessfulResponseArgs args) { return(args.Response.StatusCode == System.Net.HttpStatusCode.ServiceUnavailable); }
public bool HandleResponse(HandleUnsuccessfulResponseArgs args) { ++Calls; return(args.Response.StatusCode.Equals(HttpStatusCode.ServiceUnavailable)); }