public HttpRequestRequest (HttpRequestHandler handler, Uri uri)
: base (uri)
{
Handler = handler;
TestRunner = handler.TestRunner;
finishedTcs = new TaskCompletionSource<bool> ();
ME = $"{GetType ().Name}({TestRunner.EffectiveType})";
switch (TestRunner.EffectiveType) {
case HttpRequestTestType.PostChunked:
Content = new HttpRequestContent (TestRunner, this);
Method = "POST";
SendChunked ();
break;
case HttpRequestTestType.EntityTooBig:
case HttpRequestTestType.PostContentLength:
case HttpRequestTestType.ClientAbortsPost:
Content = new HttpRequestContent (TestRunner, this);
Method = "POST";
break;
case HttpRequestTestType.SimpleGZip:
case HttpRequestTestType.LargeGZipRead:
case HttpRequestTestType.GZipWithLength:
RequestExt.AutomaticDecompression = true;
break;
}
}
protected virtual async Task <IHttpResponse <TResult> > TransferDataBuilderResult <TResult>(object payload, Action <HttpRequestContent <object> > contentOptions)
{
var requestContent = new HttpRequestContent <object>(payload);
contentOptions?.Invoke(requestContent);
return(await HttpContent.HttpResponseAsync <TResult>(requestContent));
}
/// <summary>
/// Instantiates a new <see cref="DefaultHttpRequest"/>.
/// </summary>
/// <param name="method"> The HTTP method to use. </param>
/// <param name="uri"> The target url. </param>
/// <param name="content"> The content. </param>
public DefaultHttpRequest(HttpRequestMethod method, Uri uri, HttpRequestContent content)
{
Guard.IsNotNull(uri);
Method = method;
Uri = uri;
Content = content;
}
public virtual HttpRequestContent GetOrCreateHttpContent(IJsonSerializer serializer)
{
if (HttpContent == null && Content != null)
{
HttpContent = Content.CreateHttpContent(serializer, Options);
}
return(HttpContent);
}
public virtual HttpRequestContent GetOrCreateHttpContent(IRestApiClient client)
{
if (_httpContent == null && Content != null)
{
_httpContent = Content.CreateHttpContent(client, Options);
}
return(_httpContent);
}
/// <summary>
/// Instantiates a new <see cref="DefaultHttpRequest"/>.
/// </summary>
/// <param name="method"> The HTTP method to use. </param>
/// <param name="uri"> The target url. </param>
/// <param name="content"> The content. </param>
public DefaultHttpRequest(HttpRequestMethod method, Uri uri, HttpRequestContent content)
{
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
Method = method;
Uri = uri;
Content = content;
}
protected internal override async Task<HttpResponse> HandleRequest (
TestContext ctx, HttpOperation operation, HttpConnection connection, HttpRequest request,
RequestFlags effectiveFlags, CancellationToken cancellationToken)
{
switch (TestRunner.EffectiveType) {
case HttpRequestTestType.LargeHeader:
case HttpRequestTestType.LargeHeader2:
case HttpRequestTestType.SendResponseAsBlob:
case HttpRequestTestType.CloseRequestStream:
case HttpRequestTestType.ReadTimeout:
case HttpRequestTestType.SimpleGZip:
case HttpRequestTestType.TestResponseStream:
case HttpRequestTestType.LargeChunkRead:
case HttpRequestTestType.LargeGZipRead:
case HttpRequestTestType.GZipWithLength:
case HttpRequestTestType.ResponseStreamCheckLength2:
case HttpRequestTestType.ResponseStreamCheckLength:
case HttpRequestTestType.GetNoLength:
ctx.Assert (request.Method, Is.EqualTo ("GET"), "method");
break;
case HttpRequestTestType.ServerAbortsPost:
ctx.Assert (request.Method, Is.EqualTo ("POST"), "method");
break;
case HttpRequestTestType.RedirectNoLength:
case HttpRequestTestType.PutChunked:
case HttpRequestTestType.PutChunkDontCloseRequest:
case HttpRequestTestType.ServerAbortsRedirect:
break;
case HttpRequestTestType.EntityTooBig:
await EntityTooBig ().ConfigureAwait (false);
return null;
case HttpRequestTestType.PostChunked:
return await HandlePostChunked (
ctx, operation, connection, request, effectiveFlags, cancellationToken).ConfigureAwait (false);
case HttpRequestTestType.PostContentLength:
await PostContentLength ().ConfigureAwait (false);
break;
case HttpRequestTestType.ClientAbortsPost:
await ClientAbortsPost ().ConfigureAwait (false);
return null;
case HttpRequestTestType.ImplicitHost:
var hostAndPort = TestRunner.Uri.GetComponents (UriComponents.HostAndPort, UriFormat.Unescaped);
ctx.Assert (request.Headers["Host"], Is.EqualTo (hostAndPort), "host");
break;
case HttpRequestTestType.CustomHost:
ctx.Assert (request.Headers["Host"], Is.EqualTo ("custom"), "host");
break;
case HttpRequestTestType.CustomHostWithPort:
ctx.Assert (request.Headers["Host"], Is.EqualTo ("custom:8888"), "host");
break;
case HttpRequestTestType.CustomHostDefaultPort:
var defaultPort = TestRunner.Server.UseSSL ? 443 : 80;
ctx.Assert (request.Headers["Host"], Is.EqualTo ($"custom:{defaultPort}"), "host");
break;
default:
throw ctx.AssertFail (TestRunner.EffectiveType);
}
RemoteEndPoint = connection.RemoteEndPoint;
HttpResponse response;
HttpRequestContent content;
ListenerOperation redirect;
switch (TestRunner.EffectiveType) {
case HttpRequestTestType.LargeHeader:
response = new HttpResponse (HttpStatusCode.OK, Content);
response.AddHeader ("LargeTest", ConnectionHandler.GetLargeText (100));
return response;
case HttpRequestTestType.LargeHeader2:
response = new HttpResponse (HttpStatusCode.OK, Content);
response.AddHeader ("LargeTest", ConnectionHandler.GetLargeText (100));
response.WriteAsBlob = true;
return response;
case HttpRequestTestType.SendResponseAsBlob:
return new HttpResponse (HttpStatusCode.OK, Content) {
WriteAsBlob = true
};
case HttpRequestTestType.ReadTimeout:
content = new HttpRequestContent (TestRunner, currentRequest);
return new HttpResponse (HttpStatusCode.OK, content);
case HttpRequestTestType.RedirectNoLength:
redirect = operation.RegisterRedirect (ctx, Target);
response = HttpResponse.CreateRedirect (HttpStatusCode.Redirect, redirect);
response.NoContentLength = true;
return response;
case HttpRequestTestType.ServerAbortsRedirect:
if (isSecondRequest)
throw ctx.AssertFail ("Should never happen.");
var cloned = new HttpRequestHandler (this);
cloned.isSecondRequest = true;
redirect = operation.RegisterRedirect (ctx, cloned);
response = HttpResponse.CreateRedirect (HttpStatusCode.Redirect, redirect);
return response;
case HttpRequestTestType.ServerAbortsPost:
return new HttpResponse (HttpStatusCode.BadRequest, Content);
case HttpRequestTestType.SimpleGZip:
var gzipContent = new GZipContent (ConnectionHandler.TheQuickBrownFoxBuffer);
return new HttpResponse (HttpStatusCode.OK, gzipContent);
case HttpRequestTestType.TestResponseStream:
response = new HttpResponse (HttpStatusCode.OK, Content);
response.WriteAsBlob = true;
return response;
case HttpRequestTestType.LargeChunkRead:
response = new HttpResponse (HttpStatusCode.OK, Content);
response.WriteBodyAsBlob = true;
return response;
case HttpRequestTestType.LargeGZipRead:
gzipContent = new GZipContent ((ChunkedContent)Content);
response = new HttpResponse (HttpStatusCode.OK, gzipContent);
return response;
case HttpRequestTestType.GZipWithLength:
gzipContent = new GZipContent ((StringContent)Content);
response = new HttpResponse (HttpStatusCode.OK, gzipContent);
return response;
case HttpRequestTestType.ResponseStreamCheckLength2:
case HttpRequestTestType.ResponseStreamCheckLength:
response = new HttpResponse (HttpStatusCode.OK, Content);
return response;
case HttpRequestTestType.GetNoLength:
content = new HttpRequestContent (TestRunner, currentRequest);
return new HttpResponse (HttpStatusCode.OK, content);
default:
return HttpResponse.CreateSuccess (ME);
}
async Task EntityTooBig ()
{
await request.ReadHeaders (ctx, cancellationToken).ConfigureAwait (false);
await ctx.AssertException<IOException> (() => request.Read (ctx, cancellationToken), "client doesn't send any body");
}
async Task ClientAbortsPost ()
{
await request.ReadHeaders (ctx, cancellationToken).ConfigureAwait (false);
await ctx.AssertException<IOException> (() => request.Read (ctx, cancellationToken), "client doesn't send any body");
}
async Task PostContentLength ()
{
await request.ReadHeaders (ctx, cancellationToken).ConfigureAwait (false);
ctx.Assert (request.ContentLength, Is.EqualTo (currentRequest.Content.Length), "request.ContentLength");
readyTcs.TrySetResult (true);
await request.Read (ctx, cancellationToken);
}
}
/// <summary>
/// 校验请求
/// </summary>
/// <param name="context"></param>
public async void ValidateResponse(HttpContext context, HttpRequestMessage request, HttpResponseMessage response, HttpRequestContent requestContent, HttpResponseContent responseContent, CookieCollection cookies)
{
if (!ApiConfiguration.Instance.EnableHttpZf)
{
return;
}
var session = (context.Client as NetClient).Session;
if (session == null)
{
return;
}
if (!(responseContent is ResponseStringContent) || !context.IsSuccess || response.ContentType.IndexOf("text/html") == -1)
{
return;
}
//检测dynamicjs
var service = AppContext.ExtensionManager.GlobalKernel.Resolve <IFingerprintService>();
if (!service.IsInitialized)
{
return;
}
var m = Regex.Match((responseContent as ResponseStringContent).Result, @"(/otn/HttpZF/[^""]*?)['""]", RegexOptions.Singleline | RegexOptions.IgnoreCase);
if (!m.Success)
{
return;
}
var jsUrl = m.GetGroupValue(1);
var host = new HostContext(session)
{
ResourceUrl = jsUrl
};
#pragma warning disable CS4014 // 由于此调用不会等待，因此在调用完成前将继续执行当前方法
Task.Factory.StartNew(() =>
{
if (ProcessFp(host))
{
return;
}
lock (_processingSessions)
{
if (_processingSessions.Contains(session))
{
return;
}
_processingSessions.Add(session);
}
do
{
if (!session.IsLogined)
{
return;
}
Thread.Sleep(5000);
} while (!ProcessFp(host));
lock (_processingSessions)
{
_processingSessions.Remove(session);
}
});
#pragma warning restore CS4014 // 由于此调用不会等待，因此在调用完成前将继续执行当前方法
}
public virtual Task <HttpWebRequest> ExecuteAsync(HttpRequestContent <object> payload)
{
throw new System.NotImplementedException();
}
