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();
}
