Ejemplo n.º 1
0
        /// <summary>
        /// 获得返回
        /// </summary>
        /// <param name="status"></param>
        /// <param name="bodyString"></param>
        /// <param name="contentType"></param>
        /// <returns></returns>
        private DefaultFullHttpResponse GetResponse(HttpResponseStatus status, string bodyString = "", string contentType = "text/html; charset=UTF-8")
        {
            byte[] body = Encoding.UTF8.GetBytes(bodyString);
            DefaultFullHttpResponse response = GetResponse(status, body, contentType);

            return(response);
        }
        protected internal override bool handleResponse(IChannelHandlerContext ctx, object response)
        {
            if ((response is IFullHttpResponse) || (response is DefaultHttpResponse))
            {
                DefaultHttpResponse def = (DefaultHttpResponse)response;
                if (def != null)
                {
                    status = def.Status;

                    inboundHeaders = def.Headers;
                }
            }

            bool finished = response is ILastHttpContent;

            if (finished)
            {
                if (status == null)
                {
                    throw new HttpProxyConnectException(exceptionMessage("missing response"), inboundHeaders);
                }
                if (status.Code != 200)
                {
                    throw new HttpProxyConnectException(exceptionMessage("status: " + status), inboundHeaders);
                }
            }

            return(finished);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Create a new object to contain the response data
        /// </summary>
        /// <param name="streamId">The stream associated with the response</param>
        /// <param name="http2Headers">The initial set of HTTP/2 headers to create the response with</param>
        /// <param name="alloc">The <see cref="IByteBufferAllocator"/> to use to generate the content of the message</param>
        /// <param name="validateHttpHeaders"><c>true</c> to validate HTTP headers in the http-codec
        /// <para><c>false</c> not to validate HTTP headers in the http-codec</para></param>
        /// <returns>A new response object which represents headers/data</returns>
        /// <exception cref="Http2Exception">see <see cref="AddHttp2ToHttpHeaders(int, IHttp2Headers, IFullHttpMessage, bool)"/></exception>
        public static IFullHttpResponse ToFullHttpResponse(int streamId, IHttp2Headers http2Headers, IByteBufferAllocator alloc,
                                                           bool validateHttpHeaders)
        {
            HttpResponseStatus status = ParseStatus(http2Headers.Status);
            // HTTP/2 does not define a way to carry the version or reason phrase that is included in an
            // HTTP/1.1 status line.
            IFullHttpResponse msg = new DefaultFullHttpResponse(DotNettyHttpVersion.Http11, status, alloc.Buffer(),
                                                                validateHttpHeaders);

            try
            {
                AddHttp2ToHttpHeaders(streamId, http2Headers, msg, false);
            }
            catch (Http2Exception)
            {
                _ = msg.Release();
                throw;
            }
            catch (Exception t)
            {
                _ = msg.Release();
                ThrowHelper.ThrowStreamError_Http2ToHttp1HeadersConversionError(streamId, t);
            }
            return(msg);
        }
Ejemplo n.º 4
0
        public HttpServerResponse(Version httpVersion, HttpResponseStatus status)
        {
            _headers = new List <IHttpHeader>();

            HttpVersion    = httpVersion;
            ResponseStatus = status;
        }
Ejemplo n.º 5
0
        protected override bool HandleResponse(IChannelHandlerContext ctx, object response)
        {
            if (response is IHttpResponse)
            {
                if (_status != null)
                {
                    throw new HttpProxyConnectException(ExceptionMessage("too many responses"), /*headers=*/ null);
                }

                IHttpResponse res = (IHttpResponse)response;
                _status         = res.Status;
                _inboundHeaders = res.Headers;
            }

            bool finished = response is ILastHttpContent;

            if (finished)
            {
                if (_status == null)
                {
                    throw new HttpProxyConnectException(ExceptionMessage("missing response"), _inboundHeaders);
                }

                if (_status.Code != 200)
                {
                    throw new HttpProxyConnectException(ExceptionMessage("status: " + _status), _inboundHeaders);
                }
            }

            return(finished);
        }
Ejemplo n.º 6
0
        internal HttpServerResponse(Version httpVersion, HttpResponseStatus status)
        {
            _headers = new List<IHttpHeader>();

            HttpVersion = httpVersion;
            ResponseStatus = status;
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Process server response:
        /// <![CDATA[
        /// HTTP/1.1 101 Switching Protocols
        /// Upgrade: websocket
        /// Connection: Upgrade
        /// Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
        /// Sec-WebSocket-Protocol: chat
        /// ]]>
        /// </summary>
        /// <param name="response">HTTP response returned from the server for the request sent by beginOpeningHandshake00().</param>
        /// <exception cref="WebSocketHandshakeException">if handshake response is invalid.</exception>
        protected override void Verify(IFullHttpResponse response)
        {
            HttpResponseStatus status  = HttpResponseStatus.SwitchingProtocols;
            HttpHeaders        headers = response.Headers;

            if (!response.Status.Equals(status))
            {
                ThrowHelper.ThrowWebSocketHandshakeException_InvalidHandshakeResponseGS(response);
            }

            if (!headers.TryGet(HttpHeaderNames.Upgrade, out ICharSequence upgrade) ||
                !HttpHeaderValues.Websocket.ContentEqualsIgnoreCase(upgrade))
            {
                ThrowHelper.ThrowWebSocketHandshakeException_InvalidHandshakeResponseU(upgrade);
            }

            if (!headers.ContainsValue(HttpHeaderNames.Connection, HttpHeaderValues.Upgrade, true))
            {
                _ = headers.TryGet(HttpHeaderNames.Connection, out upgrade);
                ThrowHelper.ThrowWebSocketHandshakeException_InvalidHandshakeResponseConn(upgrade);
            }

            if (!headers.TryGet(HttpHeaderNames.SecWebsocketAccept, out ICharSequence accept) ||
                !accept.Equals(_expectedChallengeResponseString))
            {
                ThrowHelper.ThrowWebSocketHandshakeException_InvalidChallenge(accept, _expectedChallengeResponseString);
            }
        }
        public void ParseLineAsciiStringCustomCodeAndPhrase()
        {
            HttpResponseStatus customStatus = HttpResponseStatus.ParseLine(new AsciiString("612 FOO"));

            Assert.Equal(612, customStatus.Code);
            Assert.Equal("FOO", customStatus.ReasonPhrase);
        }
Ejemplo n.º 9
0
        protected override void Verify(IFullHttpResponse response)
        {
            HttpResponseStatus status  = HttpResponseStatus.SwitchingProtocols;
            HttpHeaders        headers = response.Headers;

            if (!response.Status.Equals(status))
            {
                throw new WebSocketHandshakeException($"Invalid handshake response getStatus: {response.Status}");
            }

            if (headers.TryGet(HttpHeaderNames.Upgrade, out ICharSequence upgrade) ||
                !HttpHeaderValues.Websocket.ContentEqualsIgnoreCase(upgrade))
            {
                throw new WebSocketHandshakeException($"Invalid handshake response upgrade: {upgrade}");
            }

            if (!headers.ContainsValue(HttpHeaderNames.Connection, HttpHeaderValues.Upgrade, true))
            {
                headers.TryGet(HttpHeaderNames.Connection, out upgrade);
                throw new WebSocketHandshakeException($"Invalid handshake response connection: {upgrade}");
            }

            if (headers.TryGet(HttpHeaderNames.SecWebsocketAccept, out ICharSequence accept) ||
                !accept.Equals(this.expectedChallengeResponseString))
            {
                throw new WebSocketHandshakeException($"Invalid challenge. Actual: {accept}. Expected: {this.expectedChallengeResponseString}");
            }
        }
Ejemplo n.º 10
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="result"></param>
 // mbr - 2009-08-26 - added RespondingUrl...
 internal HttpResult(object rawResult, HttpResponseStatus responseStatus, HttpStatusCode status, Uri respondingUrl,
                     WebException exception)
 {
     _rawResult      = rawResult;
     _responseStatus = responseStatus;
     _status         = status;
     _respondingUrl  = respondingUrl;
     _exception      = exception;
 }
Ejemplo n.º 11
0
        private byte[] GetErrorBody(int errorCode)
        {
            var data = File.ReadAllText(Path.Combine(DirectoryRoot, "pages", "error.html"));

            data = data.Replace("{CODE}", errorCode.ToString());
            data = data.Replace("{CODE-DESCRIPTION}", HttpResponseStatus.Get(errorCode));
            data = data.Replace("{SERVER}", ServerName + " / " + Environment.OSVersion);
            return(Encoding.UTF8.GetBytes(data));
        }
Ejemplo n.º 12
0
        public void StatusInformationalTransferEncoding()
        {
            EmbeddedChannel channel = new EmbeddedChannel(new HttpResponseEncoder());

            for (int code = 100; code < 200; code++)
            {
                HttpResponseStatus status = HttpResponseStatus.ValueOf(code);
                AssertEmptyResponse(channel, status, HttpHeaderNames.TransferEncoding, code != 101);
            }
            Assert.False(channel.Finish());
        }
Ejemplo n.º 13
0
        public void StatusInformational()
        {
            EmbeddedChannel channel = new EmbeddedChannel(new HttpResponseEncoder());

            for (int code = 100; code < 200; code++)
            {
                HttpResponseStatus status = HttpResponseStatus.ValueOf(code);
                AssertEmptyResponse(channel, status, null, false);
            }
            Assert.False(channel.Finish());
        }
Ejemplo n.º 14
0
        /// <summary>
        /// 获得返回
        /// </summary>
        /// <param name="status"></param>
        /// <param name="bodyString"></param>
        /// <param name="contentType"></param>
        /// <returns></returns>
        private DefaultFullHttpResponse GetResponse(HttpResponseStatus status, string bodyString = "", string contentType = "text/html; charset=UTF-8")
        {
            IByteBuffer body     = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(bodyString));
            var         response = new DefaultFullHttpResponse(HttpVersion.Http11, status, body);

            response.Headers.Set(HttpHeaderNames.AccessControlAllowOrigin, "*");
            response.Headers.Set(HttpHeaderNames.ContentType, $"{contentType}");
            response.Headers.Set(HttpHeaderNames.ContentLength, body.ReadableBytes);
            response.Headers.Set(HttpHeaderNames.Date, DateTime.Now);
            response.Headers.Set(HttpHeaderNames.Server, "Materal.ConDep");
            return(response);
        }
Ejemplo n.º 15
0
        /// <summary>
        /// 获得返回
        /// </summary>
        /// <param name="status"></param>
        /// <param name="body"></param>
        /// <param name="contentType"></param>
        /// <returns></returns>
        private DefaultFullHttpResponse GetResponse(HttpResponseStatus status, byte[] body, string contentType = "text/html; charset=UTF-8")
        {
            IByteBuffer bodyBuffer = Unpooled.WrappedBuffer(body);
            var         response   = new DefaultFullHttpResponse(HttpVersion.Http11, status, bodyBuffer);

            response.Headers.Set(HttpHeaderNames.AccessControlAllowOrigin, "*");
            response.Headers.Set(HttpHeaderNames.ContentType, $"{contentType}");
            response.Headers.Set(HttpHeaderNames.ContentLength, bodyBuffer.ReadableBytes);
            response.Headers.Set(HttpHeaderNames.Date, DateTime.Now);
            response.Headers.Set(HttpHeaderNames.Server, "Materal.MicroFront");
            return(response);
        }
Ejemplo n.º 16
0
			protected internal virtual void SendError(ChannelHandlerContext ctx, string message
				, HttpResponseStatus status)
			{
				HttpResponse response = new DefaultHttpResponse(HttpVersion.Http11, status);
				response.SetHeader(HttpHeaders.Names.ContentType, "text/plain; charset=UTF-8");
				// Put shuffle version into http header
				response.SetHeader(ShuffleHeader.HttpHeaderName, ShuffleHeader.DefaultHttpHeaderName
					);
				response.SetHeader(ShuffleHeader.HttpHeaderVersion, ShuffleHeader.DefaultHttpHeaderVersion
					);
				response.SetContent(ChannelBuffers.CopiedBuffer(message, CharsetUtil.Utf8));
				// Close the connection as soon as the error message is sent.
				ctx.GetChannel().Write(response).AddListener(ChannelFutureListener.Close);
			}
Ejemplo n.º 17
0
        public HttpResponse(HttpResponseStatus status, string contentType = DEFAULT_CONTENT_TYPE, string charset = DEFAULT_CHARSET)
        {
            try
            {
                Encoding = Encoding.GetEncoding(charset);
            }
            catch { Encoding = Encoding.UTF8; }

            Cookies = new HttpCookies();

            Headers = new HttpResponseHeaders();
            Headers[HttpResponseHeaders.Date] = DateTime.Now.ToUniversalTime().ToString("r");
            Headers[HttpResponseHeaders.ContentType] = string.Format("{0}; charset={1}", contentType, charset);

            Status = status;
        }
Ejemplo n.º 18
0
        private static void AssertEmptyResponse(EmbeddedChannel channel, HttpResponseStatus status,
                                                AsciiString headerName, bool headerStripped)
        {
            var response = new DefaultHttpResponse(HttpVersion.Http11, status);

            if (HttpHeaderNames.ContentLength.ContentEquals(headerName))
            {
                response.Headers.Set(headerName, "0");
            }
            else if (HttpHeaderNames.TransferEncoding.ContentEquals(headerName))
            {
                response.Headers.Set(headerName, HttpHeaderValues.Chunked);
            }

            Assert.True(channel.WriteOutbound(response));
            Assert.True(channel.WriteOutbound(EmptyLastHttpContent.Default));

            var           buffer       = channel.ReadOutbound <IByteBuffer>();
            StringBuilder responseText = new StringBuilder();

            responseText.Append(HttpVersion.Http11.ToString()).Append(' ').Append(status.ToString()).Append("\r\n");
            if (!headerStripped && headerName != null)
            {
                responseText.Append(headerName).Append(": ");

                if (HttpHeaderNames.ContentLength.ContentEquals(headerName))
                {
                    responseText.Append('0');
                }
                else
                {
                    responseText.Append(HttpHeaderValues.Chunked.ToString());
                }
                responseText.Append("\r\n");
            }
            responseText.Append("\r\n");

            Assert.Equal(responseText.ToString(), buffer.ToString(Encoding.ASCII));

            buffer.Release();

            buffer = channel.ReadOutbound <IByteBuffer>();
            buffer.Release();
        }
Ejemplo n.º 19
0
        /// <summary>
        /// 基础返回
        /// </summary>
        /// <param name="status">状态吗</param>
        /// <param name="body"></param>
        /// <param name="headers"></param>
        private IFullHttpResponse GetHttpResponse(HttpResponseStatus status, byte[] body, Dictionary <AsciiString, object> headers)
        {
            DefaultFullHttpResponse result;

            if (body != null && body.Length > 0)
            {
                IByteBuffer bodyBuffer = Unpooled.WrappedBuffer(body);
                result = new DefaultFullHttpResponse(HttpVersion.Http11, status, bodyBuffer);
            }
            else
            {
                result = new DefaultFullHttpResponse(HttpVersion.Http11, status);
            }
            foreach ((AsciiString key, object value) in headers)
            {
                result.Headers.Set(key, value);
            }
            return(result);
        }
Ejemplo n.º 20
0
        protected override void Encode(IChannelHandlerContext ctx, IResponseMessage msg, List <object> output)
        {
            var buf      = msg.ToBodyBuffer();
            var status   = HttpResponseStatus.ValueOf(Convert.ToInt32(msg.Headers.Get(Constants.ResponseStatusCode)));
            var response = new DefaultFullHttpResponse(HttpVersion.Http11, status, buf, false);

            HttpHeaders headers = response.Headers;

            headers.Set(HttpHeaderNames.Server, AsciiString.Cached(Options.Name));
            headers.Set(HttpHeaderNames.Date, this.date);
            headers.Set(HttpHeaderNames.ContentLength, AsciiString.Cached($"{msg.Headers.Get(Constants.Headers.ContentLength)}"));

            if (Convert.ToInt32(msg.Headers.Get(Constants.Headers.ContractId)) == (int)ContractType.HandShake)
            {
                headers.Set(HttpHeaderNames.ContentType, AsciiString.Cached("text/plain"));
            }
            else
            {
                headers.Set(HttpHeaderNames.ContentType, AsciiString.Cached(msg.Headers.Get(Constants.Headers.ContentType)));
            }
            output.Add(response);
        }
Ejemplo n.º 21
0
        static void SendHttpResponse(IChannelHandlerContext ctx, IFullHttpRequest req, IFullHttpResponse res)
        {
            // Generate an error page if response getStatus code is not OK (200).
            HttpResponseStatus responseStatus = res.Status;

            if (responseStatus.Code != 200)
            {
                ByteBufferUtil.WriteUtf8(res.Content, responseStatus.ToString());
                HttpUtil.SetContentLength(res, res.Content.ReadableBytes);
            }

            // Send the response and close the connection if necessary.
            var keepAlive = HttpUtil.IsKeepAlive(req) && responseStatus.Code == 200;

            HttpUtil.SetKeepAlive(res, keepAlive);
            var future = ctx.WriteAndFlushAsync(res);

            if (!keepAlive)
            {
                future.CloseOnComplete(ctx.Channel);
            }
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Apply HTTP/2 rules while translating status code to <see cref="HttpResponseStatus"/>
        /// </summary>
        /// <param name="status">The status from an HTTP/2 frame</param>
        /// <returns>The HTTP/1.x status</returns>
        /// <exception cref="Http2Exception">If there is a problem translating from HTTP/2 to HTTP/1.x</exception>
        public static HttpResponseStatus ParseStatus(ICharSequence status)
        {
            HttpResponseStatus result = null;

            try
            {
                result = HttpResponseStatus.ParseLine(status);
                if (result == HttpResponseStatus.SwitchingProtocols)
                {
                    ThrowHelper.ThrowConnectionError_InvalidHttp2StatusCode(result.Code);
                }
            }
            catch (Http2Exception)
            {
                throw;
            }
            catch (Exception t)
            {
                ThrowHelper.ThrowConnectionError_UnrecognizedHttpStatusCode(t, status);
            }
            return(result);
        }
Ejemplo n.º 23
0
 public static HttpServerResponse Create(Version httpVersion, HttpResponseStatus status)
 {
     return new HttpServerResponse(httpVersion, status);
 }
Ejemplo n.º 24
0
 public static HttpServerResponse Create(HttpResponseStatus status)
 {
     return Create(new Version(1, 1), status);
 }
Ejemplo n.º 25
0
        public ByteResponse Execute(string str, string clientIp)
        {
            HttpRequest  requestObject = null;
            HttpResponse httpResponse  = null;

            try
            {
                requestObject = new HttpRequest(str);
            }
            catch
            {
                httpResponse = new NotFound().HttpResponse;
            }

            var virtualHost = VirtualHostList.GetVirtualHost(requestObject != null ? requestObject.Host : "");
            var request     = new Request(requestObject, virtualHost);

            var accessLogHandler = new AccessLogHandler(Path.Combine(DirectoryRoot, "logs", virtualHost.AccessLog), clientIp, requestObject != null ? requestObject.UserAgent : "");

            if (httpResponse == null)
            {
                httpResponse = ChainControllerHandler.Execute(request).HttpResponse;
            }

            accessLogHandler.WriteInfo(request.Object.Method + " /" + request.Object.Uri.Url + " " + HttpResponseStatus.Get(httpResponse.HttpStatusCode));

            httpResponse.Headers.Add("Server", HttpServer.HttpServerName);
            httpResponse.Headers.Add("Date", new HttpDate(DateTime.Now).ToString());

            if (httpResponse.Content.IncludeBody && httpResponse.Content.Data == null)
            {
                httpResponse.Content.Data = GetErrorBody(httpResponse.HttpStatusCode);
            }

            return(new ByteResponse(httpResponse.GetBytes(), request.Object.KeepAlive));
        }
Ejemplo n.º 26
0
 public static HttpServerResponse Create(Version httpVersion, HttpResponseStatus status)
 {
     return(new HttpServerResponse(httpVersion, status));
 }
Ejemplo n.º 27
0
 /// <summary>
 /// 获得Http返回
 /// </summary>
 /// <param name="status"></param>
 /// <param name="body"></param>
 /// <param name="headers"></param>
 /// <returns></returns>
 protected IFullHttpResponse GetHttpResponse(HttpResponseStatus status, string body, Dictionary <AsciiString, object> headers)
 {
     byte[] bodyData = string.IsNullOrEmpty(body) ? new byte[0] : Encoding.UTF8.GetBytes(body);
     return(GetHttpResponse(status, bodyData, headers));
 }
Ejemplo n.º 28
0
 /// <summary>
 /// 获得Http返回
 /// </summary>
 /// <param name="status"></param>
 /// <param name="headers"></param>
 /// <returns></returns>
 protected IFullHttpResponse GetHttpResponse(HttpResponseStatus status, Dictionary <AsciiString, object> headers)
 {
     return(GetHttpResponse(status, string.Empty, headers));
 }
Ejemplo n.º 29
0
        /// <summary>
        /// 获得Http返回
        /// </summary>
        /// <param name="status"></param>
        /// <param name="body"></param>
        /// <returns></returns>
        protected IFullHttpResponse GetHttpResponse(HttpResponseStatus status, byte[] body)
        {
            Dictionary <AsciiString, object> headers = GetDefaultHeaders("application/octet-stream");

            return(GetHttpResponse(status, body, headers));
        }
Ejemplo n.º 30
0
        /// <summary>
        /// 获得Http返回
        /// </summary>
        /// <param name="status"></param>
        /// <param name="body"></param>
        /// <returns></returns>
        protected IFullHttpResponse GetHttpResponse(HttpResponseStatus status, string body)
        {
            Dictionary <AsciiString, object> headers = GetDefaultHeaders("text/plain;charset=UTF-8");

            return(GetHttpResponse(status, body, headers));
        }
Ejemplo n.º 31
0
        /// <summary>
        /// 获得Http返回
        /// </summary>
        /// <param name="status"></param>
        /// <returns></returns>
        protected IFullHttpResponse GetHttpResponse(HttpResponseStatus status)
        {
            Dictionary <AsciiString, object> headers = GetDefaultHeaders();

            return(GetHttpResponse(status, headers));
        }
Ejemplo n.º 32
0
 public static HttpServerResponse Create(HttpResponseStatus status)
 {
     return(Create(new Version(1, 1), status));
 }
Ejemplo n.º 33
0
        public void PipelineKeepAlive(bool isKeepAliveResponseExpected, HttpVersion httpVersion, HttpResponseStatus responseStatus, string sendKeepAlive, int setSelfDefinedMessageLength, ICharSequence setResponseConnection)
        {
            var channel      = new EmbeddedChannel(new HttpServerKeepAliveHandler());
            var firstRequest = new DefaultFullHttpRequest(httpVersion, HttpMethod.Get, "/v1/foo/bar");

            HttpUtil.SetKeepAlive(firstRequest, true);
            var secondRequest = new DefaultFullHttpRequest(httpVersion, HttpMethod.Get, "/v1/foo/bar");

            HttpUtil.SetKeepAlive(secondRequest, RequestKeepAlive.Equals(sendKeepAlive));
            var finalRequest = new DefaultFullHttpRequest(httpVersion, HttpMethod.Get, "/v1/foo/bar");

            HttpUtil.SetKeepAlive(finalRequest, false);
            var response          = new DefaultFullHttpResponse(httpVersion, responseStatus);
            var informationalResp = new DefaultFullHttpResponse(httpVersion, Processing);

            HttpUtil.SetKeepAlive(response, true);
            HttpUtil.SetContentLength(response, 0);
            HttpUtil.SetKeepAlive(informationalResp, true);

            Assert.True(channel.WriteInbound(firstRequest, secondRequest, finalRequest));

            var requestForwarded = channel.ReadInbound <object>();

            Assert.Equal(firstRequest, requestForwarded);
            ReferenceCountUtil.Release(requestForwarded);

            channel.WriteAndFlushAsync(response.Duplicate().Retain()).Wait(TimeSpan.FromSeconds(1));
            var firstResponse = channel.ReadOutbound <IHttpResponse>();

            Assert.True(channel.Open);
            Assert.True(HttpUtil.IsKeepAlive(firstResponse));
            ReferenceCountUtil.Release(firstResponse);

            requestForwarded = channel.ReadInbound <object>();
            Assert.Equal(secondRequest, requestForwarded);
            ReferenceCountUtil.Release(requestForwarded);

            channel.WriteAndFlushAsync(informationalResp).Wait(TimeSpan.FromSeconds(1));
            var writtenInfoResp = channel.ReadOutbound <IHttpResponse>();

            Assert.True(channel.Open);
            Assert.True(HttpUtil.IsKeepAlive(writtenInfoResp));
            ReferenceCountUtil.Release(writtenInfoResp);

            if (!CharUtil.IsNullOrEmpty(setResponseConnection))
            {
                response.Headers.Set(HttpHeaderNames.Connection, setResponseConnection);
            }
            else
            {
                response.Headers.Remove(HttpHeaderNames.Connection);
            }
            SetupMessageLength(setSelfDefinedMessageLength, response);
            channel.WriteAndFlushAsync(response.Duplicate().Retain()).Wait(TimeSpan.FromSeconds(1));
            var secondResponse = channel.ReadOutbound <IHttpResponse>();

            Assert.Equal(isKeepAliveResponseExpected, channel.Open);
            Assert.Equal(isKeepAliveResponseExpected, HttpUtil.IsKeepAlive(secondResponse));
            ReferenceCountUtil.Release(secondResponse);

            requestForwarded = channel.ReadInbound <object>();
            Assert.Equal(finalRequest, requestForwarded);
            ReferenceCountUtil.Release(requestForwarded);

            if (isKeepAliveResponseExpected)
            {
                channel.WriteAndFlushAsync(response).Wait(TimeSpan.FromSeconds(1));
                var finalResponse = channel.ReadOutbound <IHttpResponse>();
                Assert.False(channel.Open);
                Assert.False(HttpUtil.IsKeepAlive(finalResponse));
            }
            ReferenceCountUtil.Release(response);
            Assert.False(channel.FinishAndReleaseAll());
        }
Ejemplo n.º 34
0
 public HttpStatusException(HttpResponseStatus responseCode)
     : base(responseCode.ToResponseHeaderText())
 {
     ResponseCode = responseCode;
 }
Ejemplo n.º 35
0
			protected internal virtual void SendError(ChannelHandlerContext ctx, HttpResponseStatus
				 status)
			{
				this.SendError(ctx, string.Empty, status);
			}