static async Task Main(string[] args)
{
PreparedHeaderSet preparedHeaders =
new PreparedHeaderSetBuilder()
.AddHeader("User-Agent", "NetworkToolkit")
.AddHeader("Accept", "text/html")
.Build();
await using ConnectionFactory connectionFactory = new SocketConnectionFactory();
await using Connection connection = await connectionFactory.ConnectAsync(new DnsEndPoint ("microsoft.com", 80));
await using HttpConnection httpConnection = new Http1Connection(connection, HttpPrimitiveVersion.Version11);
int requestCounter = 0;
await SingleRequest();
await SingleRequest();
async Task SingleRequest()
{
await using ValueHttpRequest request = (await httpConnection.CreateNewRequestAsync(HttpPrimitiveVersion.Version11, HttpVersionPolicy.RequestVersionExact)).Value;
request.ConfigureRequest(contentLength: 0, hasTrailingHeaders: false);
request.WriteRequest(HttpMethod.Get, new Uri("http://microsoft.com"));
request.WriteHeader(preparedHeaders);
request.WriteHeader("X-Example-RequestNo", requestCounter++.ToString());
await request.CompleteRequestAsync();
await request.DrainAsync();
}
}
static async Task Main(string[] args)
{
await using ConnectionFactory connectionFactory = new SocketConnectionFactory();
await using Connection connection = await connectionFactory.ConnectAsync(new DnsEndPoint ("microsoft.com", 80));
await using HttpConnection httpConnection = new Http1Connection(connection);
await using (ValueHttpRequest request = (await httpConnection.CreateNewRequestAsync(HttpPrimitiveVersion.Version11, HttpVersionPolicy.RequestVersionExact)).Value)
{
request.ConfigureRequest(contentLength: 0, hasTrailingHeaders: false);
request.WriteRequest(HttpMethod.Get, new Uri("http://microsoft.com"));
request.WriteHeader("Accept", "text/html");
await request.CompleteRequestAsync();
await request.ReadToFinalResponseAsync();
Console.WriteLine($"Final response code: {request.StatusCode}");
if (await request.ReadToHeadersAsync())
{
await request.ReadHeadersAsync(new PrintingHeadersSink(), state : null);
}
else
{
Console.WriteLine("No headers received.");
}
if (await request.ReadToContentAsync())
{
long totalLen = 0;
var buffer = new byte[4096];
int readLen;
do
{
while ((readLen = await request.ReadContentAsync(buffer)) != 0)
{
totalLen += readLen;
}
}while (await request.ReadToNextContentAsync());
Console.WriteLine($"Received {totalLen} byte response.");
}
else
{
Console.WriteLine("No content received.");
}
if (await request.ReadToTrailingHeadersAsync())
{
await request.ReadHeadersAsync(new PrintingHeadersSink(), state : null);
}
else
{
Console.WriteLine("No trailing headers received.");
}
}
}
public static void WriteHeaders(this ValueHttpRequest request, TestHeadersSink headers)
{
foreach (KeyValuePair <string, List <string> > header in headers)
{
foreach (string headerValue in header.Value)
{
request.WriteHeader(header.Key, headerValue);
}
}
}
static async Task Main(string[] args)
{
Environment.SetEnvironmentVariable("DOTNET_SYSTEM_THREADING_POOLASYNCVALUETASKS", "1");
await using ConnectionFactory connectionFactory = new MemoryConnectionFactory();
await using ConnectionListener listener = await connectionFactory.ListenAsync();
await using SimpleHttp1Server server = new(listener, triggerBytes, responseBytes);
await using Connection connection = await connectionFactory.ConnectAsync(listener.EndPoint !);
await using HttpConnection httpConnection = new Http1Connection(connection, HttpPrimitiveVersion.Version11);
if (!Debugger.IsAttached)
{
Console.WriteLine("Press any key to continue, once profiler is attached...");
Console.ReadKey();
}
for (int i = 0; i < 1000000; ++i)
{
await using ValueHttpRequest request = (await httpConnection.CreateNewRequestAsync(HttpPrimitiveVersion.Version11, HttpVersionPolicy.RequestVersionExact))
?? throw new Exception("HttpConnection failed to return a request");
request.ConfigureRequest(contentLength: 0, hasTrailingHeaders: false);
request.WriteRequest(HttpRequest.GetMethod, authority, pathAndQuery);
request.WriteHeader(preparedRequestHeaders);
foreach ((byte[] name, byte[] value) in dynamicRequestHeaders)
{
request.WriteHeader(name, value);
}
await request.CompleteRequestAsync();
while (await request.ReadAsync() != HttpReadType.EndOfStream)
{
// do nothing, just draining.
}
}
}
public async Task Pipelining_Success()
{
const int PipelineLength = 10;
await RunMultiStreamTest(
async (client, serverUri) =>
{
var tasks = new Task[PipelineLength];
for (int i = 0; i < tasks.Length; ++i)
{
tasks[i] = MakeRequest(i);
}
await tasks.WhenAllOrAnyFailed(10_000);
async Task MakeRequest(int requestNo)
{
await using ValueHttpRequest request = (await client.CreateNewRequestAsync(Version, HttpVersionPolicy.RequestVersionExact)).Value;
request.ConfigureRequest(contentLength: 0, hasTrailingHeaders: false);
request.WriteRequest(HttpMethod.Get, serverUri);
request.WriteHeader("X-Request-No", requestNo.ToString(CultureInfo.InvariantCulture));
await request.CompleteRequestAsync();
TestHeadersSink headers = await request.ReadAllHeadersAsync();
Assert.Equal(requestNo.ToString(CultureInfo.InvariantCulture), headers.GetSingleValue("X-Response-No"));
}
},
async server =>
{
var streams = new (HttpTestStream, HttpTestFullRequest)[PipelineLength];
for (int i = 0; i < streams.Length; ++i)
{
HttpTestStream stream = await server.AcceptStreamAsync();
HttpTestFullRequest request = await stream.ReceiveFullRequestAsync();
Assert.Equal(i.ToString(CultureInfo.InvariantCulture), request.Headers.GetSingleValue("X-Request-No"));
streams[i] = (stream, request);
}
for (int i = 0; i < streams.Length; ++i)
{
(HttpTestStream stream, HttpTestFullRequest request) = streams[i];
var responseHeaders = new TestHeadersSink()
{
{ "X-Response-No", i.ToString(CultureInfo.InvariantCulture) }
};
await stream.SendResponseAsync(headers: responseHeaders);
await stream.DisposeAsync();
}
});
private async Task ClientSendHelperAsync(ValueHttpRequest client, Uri serverUri, int testIdx, TestHeadersSink requestHeaders, List <string> requestContent, TestHeadersSink?requestTrailingHeaders)
{
long contentLength = requestContent.Sum(x => (long)x.Length);
client.ConfigureRequest(contentLength, hasTrailingHeaders: requestTrailingHeaders != null);
client.WriteRequest(HttpMethod.Post, serverUri);
client.WriteHeader("Content-Length", contentLength.ToString(CultureInfo.InvariantCulture));
client.WriteHeader("Test-Index", testIdx.ToString(CultureInfo.InvariantCulture));
client.WriteHeaders(requestHeaders);
foreach (string content in requestContent)
{
await client.WriteContentAsync(content);
}
if (requestTrailingHeaders != null)
{
client.WriteTrailingHeaders(requestTrailingHeaders);
}
await client.CompleteRequestAsync();
}
public override async ValueTask ProcessAsync(HttpMessage message)
{
var pipelineRequest = message.Request;
var host = pipelineRequest.Uri.Host;
HttpMethod method = MapMethod(pipelineRequest.Method);
Connection connection = await connectionFactory.ConnectAsync(new DnsEndPoint(host, 80));
HttpConnection httpConnection = new Http1Connection(connection, HttpPrimitiveVersion.Version11);
await using (ValueHttpRequest request = (await httpConnection.CreateNewRequestAsync(HttpPrimitiveVersion.Version11, HttpVersionPolicy.RequestVersionExact)).Value) {
RequestContent pipelineContent = pipelineRequest.Content;
long contentLength = 0;
if (pipelineContent != null)
{
if (!pipelineContent.TryComputeLength(out contentLength))
{
throw new NotImplementedException();
}
}
request.ConfigureRequest(contentLength: contentLength, hasTrailingHeaders: false);
request.WriteRequest(method, pipelineRequest.Uri.ToUri());
var pipelineHeaders = pipelineRequest.Headers;
foreach (var header in pipelineHeaders)
{
request.WriteHeader(header.Name, header.Value);
}
checked {
if (contentLength != 0)
{
using var ms = new MemoryStream((int)contentLength); // TODO: can the buffer be disposed here?
await pipelineContent.WriteToAsync(ms, message.CancellationToken);
await request.WriteContentAsync(ms.GetBuffer().AsMemory(0, (int)ms.Length));
}
}
await request.CompleteRequestAsync();
var response = new NoAllocResponse();
message.Response = response;
await request.ReadToFinalResponseAsync();
response.SetStatus((int)request.StatusCode);
if (await request.ReadToHeadersAsync())
{
await request.ReadHeadersAsync(response, state : null);
}
if (await request.ReadToContentAsync())
{
var buffer = new byte[4096];
int readLen;
do
{
while ((readLen = await request.ReadContentAsync(buffer)) != 0)
{
if (readLen < 4096)
{
response.ContentStream = new MemoryStream(buffer, 0, readLen);
}
else
{
throw new NotImplementedException();
}
}
}while (await request.ReadToNextContentAsync());
}
if (await request.ReadToTrailingHeadersAsync())
{
await request.ReadHeadersAsync(response, state : null);
}
}
}
protected internal override void WriteHeader(int version, ReadOnlySpan <byte> name, ReadOnlySpan <byte> value)
{
ThrowIfDisposed(version);
_request.WriteHeader(name, value);
}