コード例 #1
0
 public HttpPipelineControlResponse SendControlAction(string action, params string[] parameters)
 {
     HttpPipelineMessage message = new HttpPipelineMessage();
     message.ControlAction = action;
     message.ControlParameters = parameters;
     return SendRequest(message);
 }
コード例 #2
0
        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;
            }
        }
コード例 #3
0
 public override Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
 {
     return(ProcessAsync(message, pipeline, true));
 }
コード例 #4
0
 public override void OnSendingRequest(HttpPipelineMessage message)
 {
     Console.WriteLine(message.ToString());
 }
コード例 #5
0
 public override async ValueTask ProcessAsync(HttpPipelineMessage message)
 {
     await _innerTransport.ProcessAsync(message);
     Record(message);
 }
コード例 #6
0
        public override async ValueTask ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
        {
            await ProcessAsync(message, async : true).ConfigureAwait(false);

            await ProcessNextAsync(message, pipeline).ConfigureAwait(false);
        }
コード例 #7
0
 public override void OnSendingRequest(HttpPipelineMessage message)
 {
     ExecutionCount++;
 }
コード例 #8
0
        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);
            }
        }
コード例 #9
0
 protected abstract void GetDelay(HttpPipelineMessage message, Exception exception, int attempted, out TimeSpan delay);
コード例 #10
0
 public HttpPipelineControlResponse SendObject(object o)
 {
     HttpPipelineMessage message = new HttpPipelineMessage();
     message.PipedObjectJson = JsonConvert.SerializeObject(o, HttpPipelineMessage.CommonSettings);
     return SendRequest(message);
 }
コード例 #11
0
 public override void Process(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
 {
     ProcessNext(message, pipeline);
     this.InjectFaultAsync(message, pipeline, isAsync: false).EnsureCompleted();
 }
コード例 #12
0
        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);
        }
コード例 #13
0
        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);
            }
        }
コード例 #14
0
        public override async Task ProcessAsync(HttpPipelineMessage message)
        {
            await _innerTransport.ProcessAsync(message);

            _session.Record(CreateEntry(message.Request, message.Response));
        }
コード例 #15
0
 protected override void GetDelay(HttpPipelineMessage message, Exception exception, int attempted, out TimeSpan delay)
 {
     delay = CalculateDelay(attempted);
 }
コード例 #16
0
 public override void OnSendingRequest(HttpPipelineMessage message)
 {
     message.Request.Headers.Add("application-name", _environment.ApplicationName);
     base.OnSendingRequest(message);
 }
コード例 #17
0
 public override void Process(HttpPipelineMessage message)
 {
     _innerTransport.Process(message);
     _session.Record(CreateEntry(message.Request, message.Response));
 }
コード例 #18
0
 public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
 {
     await ProcessNextAsync(message, pipeline).ConfigureAwait(false);
     await BufferResponse(message, true).ConfigureAwait(false);
 }
コード例 #19
0
 public override void Process(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
 {
     ProcessAsync(message, pipeline, false).EnsureCompleted();
 }
コード例 #20
0
 public override void Process(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
 {
     ProcessNext(message, pipeline);
     BufferResponse(message, false).EnsureCompleted();
 }
コード例 #21
0
 public abstract Task ProcessAsync(HttpPipelineMessage message);
コード例 #22
0
 public override bool IsRetriableResponse(HttpPipelineMessage message)
 {
     return(message.Response.Status == 500);
 }
コード例 #23
0
 public override bool IsRetriableResponse(HttpPipelineMessage message)
 {
     return(Array.IndexOf(_retriableCodes, message.Response.Status) >= 0);
 }
コード例 #24
0
 public override bool IsErrorResponse(HttpPipelineMessage message)
 {
     return(IsRetriableResponse(message));
 }
コード例 #25
0
 public override void Process(HttpPipelineMessage message)
 {
     _innerTransport.Process(message);
     Record(message);
 }
コード例 #26
0
        public void TryGetPropertyReturnsFalseIfNotExist()
        {
            HttpPipelineMessage message = new HttpPipelineMessage(new MockRequest(), new ResponseClassifier(), CancellationToken.None);

            Assert.False(message.TryGetProperty("someName", out _));
        }
コード例 #27
0
 public override void OnSendingRequest(HttpPipelineMessage message)
 {
     message.Request.Headers.Add("User-Agent", "ConfiguraingPipelineSample");
 }
コード例 #28
0
        public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
        {
            await ProcessAsync(message, async : true);

            await ProcessNextAsync(message, pipeline);
        }
コード例 #29
0
 public override void OnSendingRequest(HttpPipelineMessage message)
 {
     message.Request.Headers.Add(HttpHeader.Names.UserAgent, _header);
 }
コード例 #30
0
 public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
 {
     message.Request.AddHeader("User-Agent", "ConfiguraingPipelineSample");
     await ProcessNextAsync(pipeline, message).ConfigureAwait(false);
 }
コード例 #31
0
 public override void Process(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
 {
     ProcessAsync(message, pipeline, false).GetAwaiter().GetResult();
 }
コード例 #32
0
 public override async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
 {
     Console.WriteLine(message.ToString());
     await ProcessNextAsync(pipeline, message).ConfigureAwait(false);
 }
コード例 #33
0
 public override void OnSendingRequest(HttpPipelineMessage message)
 {
     message.Request.Headers.Add(ClientRequestIdHeader, message.Request.ClientRequestId);
     message.Request.Headers.Add(EchoClientRequestId, "true");
 }
コード例 #34
0
        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;
        }