public void Decode100ContinueHttp2HeadersAsFullHttpResponse() { EmbeddedChannel ch = new EmbeddedChannel(new Http2StreamFrameToHttpObjectCodec(false)); IHttp2Headers headers = new DefaultHttp2Headers(); headers.Scheme = HttpScheme.Http.Name; headers.Status = HttpResponseStatus.Continue.CodeAsText; Assert.True(ch.WriteInbound(new DefaultHttp2HeadersFrame(headers, false))); IFullHttpResponse response = ch.ReadInbound <IFullHttpResponse>(); try { Assert.Equal(HttpResponseStatus.Continue, response.Status); Assert.Equal(HttpVersion.Http11, response.ProtocolVersion); } finally { response.Release(); } Assert.Null(ch.ReadInbound <object>()); Assert.False(ch.Finish()); }
protected async Task DoRequestAsync(List <Uri> uris, int requestCount) { foreach (var uri in uris) { var sw = Stopwatch.StartNew(); var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2)); var tasks = Enumerable.Range(0, requestCount).Select(async m => { IFullHttpResponse response = null; try { var request = new DefaultFullHttpRequest(DNHttpVersion.Http11, DNHttpMethod.Get, uri.OriginalString); response = await _executor.ExecuteAsync(request, cts.Token).ConfigureAwait(false); Assert.AreEqual(200, response.Status.Code); } catch { } finally { response.SafeRelease(); } }).ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); sw.Stop(); Debug.WriteLine($"{uri.OriginalString}:{sw.Elapsed}"); } }
/// <summary> /// 获得Response /// </summary> private async Task <IFullHttpResponse> GetResponseAsync(IFullHttpRequest request, BaseController baseController, MethodInfo action) { IFullHttpResponse result = null; string bodyParams = GetBodyParams(request); Dictionary <string, string> urlParams = GetUrlParams(request); ParameterInfo[] parameters = action.GetParameters(); object[] @params = null; if (parameters.Length > 0) { @params = new object[parameters.Length]; for (var i = 0; i < parameters.Length; i++) { if (!string.IsNullOrEmpty(bodyParams) && parameters[i].ParameterType.IsClass && parameters[i].ParameterType != typeof(string)) { @params[i] = bodyParams.JsonToT <object>(parameters[i].ParameterType); continue; } if (urlParams.ContainsKey(parameters[i].Name)) { @params[i] = urlParams[parameters[i].Name].ConvertTo(parameters[i].ParameterType); continue; } if (@params[i] == null) { //ResultModel resultModel = ResultModel.Fail($"参数{parameters[i].Name}错误"); result = GetHttpResponse(HttpResponseStatus.BadRequest, $"参数{parameters[i].Name}错误)"); break; } } } result = result ?? await GetResponseAsync(baseController, action, @params); return(result); }
/// <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); } }
protected override void Verify(IFullHttpResponse response) { if (!response.Status.Equals(HttpResponseStatus.SwitchingProtocols)) { ThrowHelper.ThrowWebSocketHandshakeException_InvalidHandshakeResponseGS(response); } HttpHeaders headers = response.Headers; if (!headers.TryGet(HttpHeaderNames.Upgrade, out ICharSequence upgrade) || !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); } IByteBuffer challenge = response.Content; if (!challenge.Equals(_expectedChallengeResponseBytes)) { ThrowHelper.ThrowWebSocketHandshakeException_InvalidChallenge(); } }
/// <summary> /// 处理 /// </summary> /// <param name="request"></param> /// <param name="response"></param> public void Handler(IFullHttpRequest request, IFullHttpResponse response) { if (!IsMatch(request.Method.Name)) { response.SetStatus(HttpResponseStatus.BadRequest); } }
/// <summary> /// 获得Response /// </summary> /// <param name="request"></param> /// <param name="baseController"></param> /// <param name="action"></param> /// <param name="globalFilters"></param> /// <returns></returns> protected virtual async Task <IFullHttpResponse> GetResponseAsync(IFullHttpRequest request, BaseController baseController, ActionInfo action, IFilter[] globalFilters) { IFullHttpResponse response = action.HandlerMethod(request); if (response.Status.Code != HttpResponseStatus.OK.Code) { return(response); } response = await action.HandlerAuthorityFilterAsync(request, globalFilters); if (response.Status.Code != HttpResponseStatus.OK.Code) { return(response); } response = await action.HandlerActionBeforeFilterAsync(request, globalFilters); if (response.Status.Code != HttpResponseStatus.OK.Code) { return(response); } response = await HandlerParamsAsync(request, baseController, action); await action.HandlerActionAfterFilterAsync(request, response, globalFilters); return(response); }
/// <summary> /// 处理控制器过滤器 /// </summary> /// <param name="response"></param> /// <param name="globalFilters"></param> /// <returns></returns> public async Task HandlerControllerAfterFilterAsync(IFullHttpResponse response, params IFilter[] globalFilters) { List <Attribute> attributes = GetType().GetCustomAttributes().ToList(); List <IControllerAfterFilter> filters = attributes.OfType <IControllerAfterFilter>().ToList(); if (globalFilters != null && globalFilters.Length > 0) { filters.AddRange(globalFilters.OfType <IControllerAfterFilter>()); } foreach (IControllerAfterFilter filter in filters) { filter.HandlerFilter(this, Request, ref response); if (response.Status.Code != HttpResponseStatus.OK.Code) { return; } } List <IControllerAfterAsyncFilter> asyncFilters = attributes.OfType <IControllerAfterAsyncFilter>().ToList(); if (globalFilters != null && globalFilters.Length > 0) { asyncFilters.AddRange(globalFilters.OfType <IControllerAfterAsyncFilter>()); } foreach (IControllerAfterAsyncFilter filter in asyncFilters) { await filter.HandlerFilterAsync(this, Request, ref response); if (response.Status.Code != HttpResponseStatus.OK.Code) { return; } } }
/// <summary> /// 处理Action过滤器 /// </summary> /// <param name="request"></param> /// <param name="globalFilters"></param> /// <returns></returns> public async Task <IFullHttpResponse> HandlerActionBeforeFilterAsync(IFullHttpRequest request, params IFilter[] globalFilters) { IFullHttpResponse response = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK); List <Attribute> attributes = Action.GetCustomAttributes().ToList(); List <IActionBeforeFilter> filters = attributes.OfType <IActionBeforeFilter>().ToList(); if (globalFilters != null && globalFilters.Length > 0) { filters.AddRange(globalFilters.OfType <IActionBeforeFilter>()); } foreach (IActionBeforeFilter filter in filters) { filter.HandlerFilter(BaseController, this, request, ref response); if (response.Status.Code != HttpResponseStatus.OK.Code) { return(response); } } List <IActionBeforeAsyncFilter> asyncFilters = attributes.OfType <IActionBeforeAsyncFilter>().ToList(); if (globalFilters != null && globalFilters.Length > 0) { asyncFilters.AddRange(globalFilters.OfType <IActionBeforeAsyncFilter>()); } foreach (IActionBeforeAsyncFilter filter in asyncFilters) { await filter.HandlerFilterAsync(BaseController, this, request, ref response); if (response.Status.Code != HttpResponseStatus.OK.Code) { return(response); } } return(response); }
protected override void Verify(IFullHttpResponse response) { if (!response.Status.Equals(HttpResponseStatus.SwitchingProtocols)) { throw new WebSocketHandshakeException($"Invalid handshake response getStatus: {response.Status}"); } HttpHeaders headers = response.Headers; if (!headers.TryGet(HttpHeaderNames.Upgrade, out ICharSequence upgrade) || !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}"); } IByteBuffer challenge = response.Content; if (!challenge.Equals(this.expectedChallengeResponseBytes)) { throw new WebSocketHandshakeException("Invalid challenge"); } }
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}"); } }
private async Task <HttpResponseMessage> InternalExecuteAsync(HttpRequestMessage message, Uri proxyUri, CancellationToken token) { var targetUri = message.RequestUri; //TODO 过滤不支持的http版本 var request = await message.ToFullHttpRequestAsync(false).ConfigureAwait(false); IFullHttpResponse response = null; HttpResponseMessage outterResponse; try { response = await RequestExecutor.InternalExecuteAsync(request, targetUri, proxyUri, token).ConfigureAwait(false); outterResponse = response.ToHttpResponseMessage(); } finally { response.SafeRelease(); } outterResponse.Version = message.Version; outterResponse.RequestMessage = message; return(outterResponse); }
/// <summary> /// 获取文本返回 /// </summary> /// <param name="stream"></param> /// <returns></returns> private IFullHttpResponse GetTextResponse(object actionResult) { Dictionary <AsciiString, object> headers = GetDefaultHeaders("text/plain;charset=utf-8"); IFullHttpResponse result = GetHttpResponse(HttpResponseStatus.OK, actionResult.ToString(), headers); return(result); }
/// <summary> /// 获取Json返回 /// </summary> /// <param name="stream"></param> /// <returns></returns> private IFullHttpResponse GetJsonResponse(object actionResult) { Dictionary <AsciiString, object> headers = GetDefaultHeaders("application/json;charset=utf-8"); IFullHttpResponse result = GetHttpResponse(HttpResponseStatus.OK, actionResult.ToJson(), headers); return(result); }
/// <summary> /// Performs the opening handshake /// When call this method you <c>MUST NOT</c> retain the <see cref="IFullHttpRequest"/> which is passed in. /// </summary> /// <param name="channel">Channel</param> /// <param name="req">HTTP Request</param> /// <param name="responseHeaders">Extra headers to add to the handshake response or <code>null</code> if no extra headers should be added</param> /// <param name="completion">the <see cref="IPromise"/> to be notified when the opening handshake is done</param> public void Handshake(IChannel channel, IFullHttpRequest req, HttpHeaders responseHeaders, IPromise completion) { #if DEBUG if (Logger.DebugEnabled) { Logger.WebSocketVersionServerHandshake(channel, _version); } #endif IFullHttpResponse response = NewHandshakeResponse(req, responseHeaders); IChannelPipeline p = channel.Pipeline; if (p.Get <HttpObjectAggregator>() is object) { _ = p.Remove <HttpObjectAggregator>(); } if (p.Get <HttpContentCompressor>() is object) { _ = p.Remove <HttpContentCompressor>(); } if (p.Get <CorsHandler>() is object) { _ = p.Remove <CorsHandler>(); } if (p.Get <HttpServerExpectContinueHandler>() is object) { _ = p.Remove <HttpServerExpectContinueHandler>(); } if (p.Get <HttpServerKeepAliveHandler>() is object) { _ = p.Remove <HttpServerKeepAliveHandler>(); } IChannelHandlerContext ctx = p.Context <HttpRequestDecoder>(); string encoderName; if (ctx is null) { // this means the user use an HttpServerCodec ctx = p.Context <HttpServerCodec>(); if (ctx is null) { _ = completion.TrySetException(ThrowHelper.GetInvalidOperationException_NoHttpDecoderAndServerCodec()); return; } encoderName = ctx.Name; _ = p.AddBefore(encoderName, "wsencoder", NewWebSocketEncoder()); _ = p.AddBefore(encoderName, "wsdecoder", NewWebsocketDecoder()); } else { _ = p.Replace(ctx.Name, "wsdecoder", NewWebsocketDecoder()); encoderName = p.Context <HttpResponseEncoder>().Name; _ = p.AddBefore(encoderName, "wsencoder", NewWebSocketEncoder()); } _ = channel.WriteAndFlushAsync(response).ContinueWith(RemoveHandlerAfterWriteAction, (completion, p, encoderName), TaskContinuationOptions.ExecuteSynchronously); }
/// <summary> /// 处理HttpMethodAttribute /// </summary> /// <param name="request"></param> /// <returns></returns> public IFullHttpResponse HandlerMethod(IFullHttpRequest request) { IFullHttpResponse response = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK); var attribute = Action.GetCustomAttribute <HttpMethodAttribute>(); attribute?.Handler(request, response); return(response); }
protected virtual void SendResponse(IChannelHandlerContext ctx, string streamId, int latency, IFullHttpResponse response, IFullHttpRequest request) { HttpUtil.SetContentLength(response, response.Content.ReadableBytes); StreamId(response, streamId); ctx.Executor.Schedule(() => ctx.WriteAndFlushAsync(response), TimeSpan.FromMilliseconds(latency)); }
public void Handshake(IChannel channel, IFullHttpRequest req, HttpHeaders responseHeaders, TaskCompletionSource completion) { if (Logger.DebugEnabled) { Logger.Debug("{} WebSocket version {} server handshake", channel, this.version); } IFullHttpResponse response = this.NewHandshakeResponse(req, responseHeaders); IChannelPipeline p = channel.Pipeline; if (p.Get <HttpObjectAggregator>() != null) { p.Remove <HttpObjectAggregator>(); } if (p.Get <HttpContentCompressor>() != null) { p.Remove <HttpContentCompressor>(); } IChannelHandlerContext ctx = p.Context <HttpRequestDecoder>(); string encoderName; if (ctx == null) { // this means the user use a HttpServerCodec ctx = p.Context <HttpServerCodec>(); if (ctx == null) { completion.TrySetException(new InvalidOperationException("No HttpDecoder and no HttpServerCodec in the pipeline")); return; } p.AddBefore(ctx.Name, "wsdecoder", this.NewWebsocketDecoder()); p.AddBefore(ctx.Name, "wsencoder", this.NewWebSocketEncoder()); encoderName = ctx.Name; } else { p.Replace(ctx.Name, "wsdecoder", this.NewWebsocketDecoder()); encoderName = p.Context <HttpResponseEncoder>().Name; p.AddBefore(encoderName, "wsencoder", this.NewWebSocketEncoder()); } channel.WriteAndFlushAsync(response).ContinueWith(t => { if (t.Status == TaskStatus.RanToCompletion) { p.Remove(encoderName); completion.TryComplete(); } else { completion.TrySetException(t.Exception); } }); }
internal static StringBuilder AppendFullResponse(StringBuilder buf, IFullHttpResponse res) { AppendFullCommon(buf, res); AppendInitialLine(buf, res); AppendHeaders(buf, res.Headers); AppendHeaders(buf, res.TrailingHeaders); RemoveLastNewLine(buf); return(buf); }
/// <summary> /// 获得Options返回 /// </summary> /// <param name="methodName"></param> /// <returns></returns> protected virtual IFullHttpResponse GetOptionsResponse(string methodName) { Dictionary <AsciiString, object> headers = HttpResponseHelper.GetDefaultHeaders(); headers.Add(HttpHeaderNames.AccessControlAllowHeaders, "authorization,access-control-allow-origin,content-type"); headers.Add(HttpHeaderNames.AccessControlAllowMethods, $"{methodName.ToUpper()}"); IFullHttpResponse response = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK, headers); return(response); }
/// <summary> /// 处理请求 /// </summary> /// <param name="ctx"></param> /// <param name="request"></param> /// <returns></returns> protected virtual async Task HandlerRequestAsync(IChannelHandlerContext ctx, IFullHttpRequest request) { IFullHttpResponse response = await GetFileResponseAsync(request); if (!CanNext || response.Status.Code == HttpResponseStatus.OK.Code) { await SendHttpResponseAsync(ctx, request, response); StopHandler(); } }
/// <summary> /// 获取流返回 /// </summary> /// <param name="stream"></param> /// <returns></returns> private async Task <IFullHttpResponse> GetStreamResponseAsync(Stream stream) { var bytes = new byte[stream.Length]; await stream.ReadAsync(bytes, 0, bytes.Length); stream.Close(); stream.Dispose(); Dictionary <AsciiString, object> headers = GetDefaultHeaders("application/octet-stream"); IFullHttpResponse result = GetHttpResponse(HttpResponseStatus.OK, bytes, headers); return(result); }
public void TestDuplicateHandshakeResponseHeaders() { WebSocketServerHandshaker serverHandshaker = NewHandshaker("ws://example.com/chat", "chat", WebSocketDecoderConfig.Default); IFullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Get, "/chat"); request.Headers .Set(HttpHeaderNames.Host, "example.com") .Set(HttpHeaderNames.Origin, "example.com") .Set(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket) .Set(HttpHeaderNames.Connection, HttpHeaderValues.Upgrade) .Set(HttpHeaderNames.SecWebsocketKey, "dGhlIHNhbXBsZSBub25jZQ==") .Set(HttpHeaderNames.SecWebsocketOrigin, "http://example.com") .Set(HttpHeaderNames.SecWebsocketProtocol, "chat, superchat") .Set(HttpHeaderNames.SecWebsocketVersion, WebSocketVersion().ToHttpHeaderValue()); HttpHeaders customResponseHeaders = new DefaultHttpHeaders(); // set duplicate required headers and one custom customResponseHeaders .Set(HttpHeaderNames.Connection, HttpHeaderValues.Upgrade) .Set(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket) .Set(AsciiString.Of("custom"), AsciiString.Of("header")); if (WebSocketVersion() != Http.WebSockets.WebSocketVersion.V00) { customResponseHeaders.Set(HttpHeaderNames.SecWebsocketAccept, "12345"); } IFullHttpResponse response = null; try { response = serverHandshaker.NewHandshakeResponse(request, customResponseHeaders); HttpHeaders responseHeaders = response.Headers; Assert.Equal(1, responseHeaders.GetAll(HttpHeaderNames.Connection).Count); Assert.Equal(1, responseHeaders.GetAll(HttpHeaderNames.Upgrade).Count); Assert.True(responseHeaders.ContainsValue(AsciiString.Of("custom"), AsciiString.Of("header"), true)); if (WebSocketVersion() != Http.WebSockets.WebSocketVersion.V00) { Assert.False(responseHeaders.ContainsValue(HttpHeaderNames.SecWebsocketAccept, AsciiString.Of("12345"), false)); } } finally { request.Release(); if (response != null) { response.Release(); } } }
public void HttpUpgradeRequest() { EmbeddedChannel ch = this.CreateChannel(new MockOutboundHandler(this)); IChannelHandlerContext handshakerCtx = ch.Pipeline.Context <WebSocketServerProtocolHandshakeHandler>(); WriteUpgradeRequest(ch); IFullHttpResponse response = this.responses.Dequeue(); Assert.Equal(SwitchingProtocols, response.Status); response.Release(); Assert.NotNull(WebSocketServerProtocolHandler.GetHandshaker(handshakerCtx.Channel)); }
/// <summary> /// 处理权限过滤器 /// </summary> /// <param name="request"></param> /// <param name="globalFilters"></param> /// <returns></returns> public async Task <IFullHttpResponse> HandlerAuthorityFilterAsync(IFullHttpRequest request, params IFilter[] globalFilters) { Type controllerType = BaseController.GetType(); IFullHttpResponse response = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK); var allowAuthorityAttribute = Action.GetCustomAttribute <AllowAuthorityAttribute>(); if (allowAuthorityAttribute != null) { return(response); } allowAuthorityAttribute = controllerType.GetCustomAttribute <AllowAuthorityAttribute>(); if (allowAuthorityAttribute != null) { return(response); } List <Attribute> controllerAttributes = controllerType.GetCustomAttributes().ToList(); List <Attribute> actionAttributes = Action.GetCustomAttributes().ToList(); List <IAuthorityFilter> filters = actionAttributes.OfType <IAuthorityFilter>().ToList(); filters.AddRange(controllerAttributes.OfType <IAuthorityFilter>()); if (globalFilters != null && globalFilters.Length > 0) { filters.AddRange(globalFilters.OfType <IAuthorityFilter>()); } foreach (IAuthorityFilter filter in filters) { filter.HandlerFilter(BaseController, this, request, ref response); if (response.Status.Code != HttpResponseStatus.OK.Code) { return(response); } } List <IAuthorityAsyncFilter> asyncFilters = actionAttributes.OfType <IAuthorityAsyncFilter>().ToList(); asyncFilters.AddRange(controllerAttributes.OfType <IAuthorityAsyncFilter>()); if (globalFilters != null && globalFilters.Length > 0) { asyncFilters.AddRange(globalFilters.OfType <IAuthorityAsyncFilter>()); } foreach (IAuthorityAsyncFilter filter in asyncFilters) { await filter.HandlerFilterAsync(BaseController, this, request, ref response); if (response.Status.Code != HttpResponseStatus.OK.Code) { return(response); } } return(response); }
public override async Task HandlerAsync(IChannelHandlerContext ctx, IByteBufferHolder byteBufferHolder) { try { await base.HandlerAsync <IFullHttpRequest>(ctx, byteBufferHolder, HandlerRequestAsync); } catch (Exception e) { ShowException?.Invoke(e); var headers = GetDefaultHeaders("text/plain;charset=utf-8"); IFullHttpResponse response = GetHttpResponse(HttpResponseStatus.InternalServerError, e.Message, headers); await SendHttpResponseAsync(ctx, response); } }
public override async Task HandlerAsync(IChannelHandlerContext ctx, IByteBufferHolder byteBufferHolder) { try { await HandlerAsync <IFullHttpRequest>(ctx, byteBufferHolder, HandlerRequestAsync); } catch (Exception exception) { OnException?.Invoke(exception); Dictionary <AsciiString, object> headers = HttpResponseHelper.GetDefaultHeaders("text/plain;charset=utf-8"); IFullHttpResponse response = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.InternalServerError, exception.Message, headers); await SendHttpResponseAsync(ctx, byteBufferHolder, response); } }
/// <summary> /// 处理请求 /// </summary> /// <param name="ctx"></param> /// <param name="request"></param> /// <returns></returns> protected virtual async Task HandlerRequestAsync(IChannelHandlerContext ctx, IFullHttpRequest request) { IFullHttpResponse response = null; IFilter[] globalFilters = _controllerBus.GetGlobalFilters(); if (!request.Uri.StartsWith("/api/")) { if (CanNext) { return; } response = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.NotFound); } else { string[] urls = request.Uri.Split('/'); if (urls.Length < 4) { return; } string controllerKey = urls[2]; try { BaseController baseController = _controllerBus.GetController(controllerKey); baseController.Request = request; string actionKey = urls[3].Split('?')[0]; ActionInfo action = baseController.GetAction(actionKey); if (!HandlerOptions(ctx, request, action, ref response)) { response = await baseController.HandlerControllerBeforeFilterAsync(globalFilters); if (response.Status.Code == HttpResponseStatus.OK.Code) { response = await GetResponseAsync(request, baseController, action, globalFilters); await baseController.HandlerControllerAfterFilterAsync(response, globalFilters); } } } catch (MateralDotNettyServerException exception) { ResultModel resultModel = ResultModel.Fail(exception.Message); response = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.NotFound, resultModel.ToJson()); } } await SendHttpResponseAsync(ctx, request, response); StopHandler(); }
public void WebSocketServerProtocolHandshakeHandlerReplacedBeforeHandshake() { EmbeddedChannel ch = CreateChannel(new MockOutboundHandler(this)); IChannelHandlerContext handshakerCtx = ch.Pipeline.Context <WebSocketServerProtocolHandshakeHandler>(); ch.Pipeline.AddLast(new ReplacedBeforeHandshakeHandler()); WriteUpgradeRequest(ch); IFullHttpResponse response = _responses.Dequeue(); Assert.Equal(SwitchingProtocols, response.Status); response.Release(); Assert.NotNull(WebSocketServerProtocolHandler.GetHandshaker(handshakerCtx.Channel)); Assert.False(ch.Finish()); }
public void SubsequentHttpRequestsAfterUpgradeShouldReturn403() { EmbeddedChannel ch = this.CreateChannel(); WriteUpgradeRequest(ch); IFullHttpResponse response = this.responses.Dequeue(); Assert.Equal(SwitchingProtocols, response.Status); response.Release(); ch.WriteInbound(new DefaultFullHttpRequest(Http11, HttpMethod.Get, "/test")); response = this.responses.Dequeue(); Assert.Equal(Forbidden, response.Status); response.Release(); }