public HttpPipelineControlResponse SendControlAction(string action, params string[] parameters) { HttpPipelineMessage message = new HttpPipelineMessage(); message.ControlAction = action; message.ControlParameters = parameters; return SendRequest(message); }
private HttpPipelineControlResponse SendRequest(HttpPipelineMessage message) { var messageJson = JsonConvert.SerializeObject(message); var request = (HttpWebRequest)HttpWebRequest.Create("http://localhost:" + Port + "/"); request.Method = "POST"; using (StreamWriter writer = new StreamWriter(request.GetRequestStream())) { writer.Write(messageJson); } var response = (HttpWebResponse)request.GetResponse(); using (StreamReader reader = new StreamReader(response.GetResponseStream())) { var responseBody = reader.ReadToEnd(); var responseObj = JsonConvert.DeserializeObject<HttpPipelineControlResponse>(responseBody, HttpPipelineMessage.CommonSettings); return responseObj; } }
public override Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { return(ProcessAsync(message, pipeline, true)); }
public override void OnSendingRequest(HttpPipelineMessage message) { Console.WriteLine(message.ToString()); }
public override async ValueTask ProcessAsync(HttpPipelineMessage message) { await _innerTransport.ProcessAsync(message); Record(message); }
public override async ValueTask ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { await ProcessAsync(message, async : true).ConfigureAwait(false); await ProcessNextAsync(message, pipeline).ConfigureAwait(false); }
public override void OnSendingRequest(HttpPipelineMessage message) { ExecutionCount++; }
private async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline, bool async) { int attempt = 0; List <Exception> exceptions = null; while (true) { Exception lastException = null; try { if (async) { await ProcessNextAsync(pipeline, message).ConfigureAwait(false); } else { ProcessNext(pipeline, message); } } catch (Exception ex) { if (exceptions == null) { exceptions = new List <Exception>(); } exceptions.Add(ex); lastException = ex; } TimeSpan delay; attempt++; var shouldRetry = attempt <= MaxRetries; if (lastException != null) { if (shouldRetry && message.ResponseClassifier.IsRetriableException(lastException)) { GetDelay(message, lastException, attempt, out delay); } else { // Rethrow a singular exception if (exceptions.Count == 1) { ExceptionDispatchInfo.Capture(lastException).Throw(); } throw new AggregateException($"Retry failed after {attempt} tries.", exceptions); } } else if (message.ResponseClassifier.IsErrorResponse(message.Response)) { if (shouldRetry && message.ResponseClassifier.IsRetriableResponse(message.Response)) { GetDelay(message, attempt, out delay); } else { return; } } else { return; } if (delay > TimeSpan.Zero) { if (async) { await WaitAsync(delay, message.Cancellation); } else { Wait(delay, message.Cancellation); } } HttpPipelineEventSource.Singleton.RequestRetrying(message.Request, attempt); } }
protected abstract void GetDelay(HttpPipelineMessage message, Exception exception, int attempted, out TimeSpan delay);
public HttpPipelineControlResponse SendObject(object o) { HttpPipelineMessage message = new HttpPipelineMessage(); message.PipedObjectJson = JsonConvert.SerializeObject(o, HttpPipelineMessage.CommonSettings); return SendRequest(message); }
public override void Process(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { ProcessNext(message, pipeline); this.InjectFaultAsync(message, pipeline, isAsync: false).EnsureCompleted(); }
public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { await ProcessNextAsync(message, pipeline).ConfigureAwait(false); await this.InjectFaultAsync(message, pipeline, isAsync : true).ConfigureAwait(false); }
private static async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline, bool async) { if (!s_eventSource.IsEnabled()) { if (async) { await ProcessNextAsync(pipeline, message).ConfigureAwait(false); } else { ProcessNext(pipeline, message); } return; } s_eventSource.Request(message.Request); Encoding requestTextEncoding = null; if (message.Request.TryGetHeader(HttpHeader.Names.ContentType, out var contentType) && IsTextContentType(contentType)) { requestTextEncoding = Encoding.UTF8; } if (message.Request.Content != null) { if (requestTextEncoding != null) { if (async) { await s_eventSource.RequestContentTextAsync(message.Request, requestTextEncoding, message.Cancellation); } else { s_eventSource.RequestContentText(message.Request, requestTextEncoding, message.Cancellation); } } else { if (async) { await s_eventSource.RequestContentAsync(message.Request, message.Cancellation); } else { s_eventSource.RequestContent(message.Request, message.Cancellation); } } } var before = Stopwatch.GetTimestamp(); if (async) { await ProcessNextAsync(pipeline, message).ConfigureAwait(false); } else { ProcessNext(pipeline, message); } var after = Stopwatch.GetTimestamp(); bool isError = message.ResponseClassifier.IsErrorResponse(message.Response); var textResponse = ResponseClassifier.IsTextResponse(message.Response, out Encoding responseTextEncoding); bool wrapResponseStream = s_eventSource.ShouldLogContent(isError) && message.Response.ContentStream?.CanSeek == false; if (wrapResponseStream) { message.Response.ContentStream = new LoggingStream( message.Response.ClientRequestId, s_eventSource, message.Response.ContentStream, isError, responseTextEncoding); } if (isError) { s_eventSource.ErrorResponse(message.Response); if (!wrapResponseStream && message.Response.ContentStream != null) { if (textResponse) { if (async) { await s_eventSource.ErrorResponseContentTextAsync(message.Response, responseTextEncoding, message.Cancellation).ConfigureAwait(false); } else { s_eventSource.ErrorResponseContentText(message.Response, responseTextEncoding, message.Cancellation); } } else { if (async) { await s_eventSource.ErrorResponseContentAsync(message.Response, message.Cancellation).ConfigureAwait(false); } else { s_eventSource.ErrorResponseContent(message.Response); } } } } s_eventSource.Response(message.Response); if (!wrapResponseStream && message.Response.ContentStream != null) { if (textResponse) { await s_eventSource.ResponseContentTextAsync(message.Response, responseTextEncoding, message.Cancellation).ConfigureAwait(false); } else { await s_eventSource.ResponseContentAsync(message.Response, message.Cancellation).ConfigureAwait(false); } } var elapsedMilliseconds = (after - before) * 1000 / s_frequency; if (elapsedMilliseconds > s_delayWarningThreshold) { s_eventSource.ResponseDelay(message.Response, elapsedMilliseconds); } }
public override async Task ProcessAsync(HttpPipelineMessage message) { await _innerTransport.ProcessAsync(message); _session.Record(CreateEntry(message.Request, message.Response)); }
protected override void GetDelay(HttpPipelineMessage message, Exception exception, int attempted, out TimeSpan delay) { delay = CalculateDelay(attempted); }
public override void OnSendingRequest(HttpPipelineMessage message) { message.Request.Headers.Add("application-name", _environment.ApplicationName); base.OnSendingRequest(message); }
public override void Process(HttpPipelineMessage message) { _innerTransport.Process(message); _session.Record(CreateEntry(message.Request, message.Response)); }
public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { await ProcessNextAsync(message, pipeline).ConfigureAwait(false); await BufferResponse(message, true).ConfigureAwait(false); }
public override void Process(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { ProcessAsync(message, pipeline, false).EnsureCompleted(); }
public override void Process(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { ProcessNext(message, pipeline); BufferResponse(message, false).EnsureCompleted(); }
public abstract Task ProcessAsync(HttpPipelineMessage message);
public override bool IsRetriableResponse(HttpPipelineMessage message) { return(message.Response.Status == 500); }
public override bool IsRetriableResponse(HttpPipelineMessage message) { return(Array.IndexOf(_retriableCodes, message.Response.Status) >= 0); }
public override bool IsErrorResponse(HttpPipelineMessage message) { return(IsRetriableResponse(message)); }
public override void Process(HttpPipelineMessage message) { _innerTransport.Process(message); Record(message); }
public void TryGetPropertyReturnsFalseIfNotExist() { HttpPipelineMessage message = new HttpPipelineMessage(new MockRequest(), new ResponseClassifier(), CancellationToken.None); Assert.False(message.TryGetProperty("someName", out _)); }
public override void OnSendingRequest(HttpPipelineMessage message) { message.Request.Headers.Add("User-Agent", "ConfiguraingPipelineSample"); }
public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { await ProcessAsync(message, async : true); await ProcessNextAsync(message, pipeline); }
public override void OnSendingRequest(HttpPipelineMessage message) { message.Request.Headers.Add(HttpHeader.Names.UserAgent, _header); }
public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { message.Request.AddHeader("User-Agent", "ConfiguraingPipelineSample"); await ProcessNextAsync(pipeline, message).ConfigureAwait(false); }
public override void Process(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { ProcessAsync(message, pipeline, false).GetAwaiter().GetResult(); }
public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline) { Console.WriteLine(message.ToString()); await ProcessNextAsync(pipeline, message).ConfigureAwait(false); }
public override void OnSendingRequest(HttpPipelineMessage message) { message.Request.Headers.Add(ClientRequestIdHeader, message.Request.ClientRequestId); message.Request.Headers.Add(EchoClientRequestId, "true"); }
private static object DeserializePipedObject(HttpPipelineMessage message) { object pipedObject; try { pipedObject = JsonConvert.DeserializeObject(message.PipedObjectJson, HttpPipelineMessage.CommonSettings); } catch(Exception ex) { pipedObject = JObject.Parse(message.PipedObjectJson); } return pipedObject; }