private static async Task PongServer(IPipelineConnection connection)
{
while (true)
{
var result = await connection.Input.ReadAsync();
var inputBuffer = result.Buffer;
if (inputBuffer.IsEmpty && result.IsCompleted)
{
connection.Input.Advance(inputBuffer.End);
break;
}
if (inputBuffer.Length < 4)
{
connection.Input.Advance(inputBuffer.Start, inputBuffer.End);
}
else
{
bool isPing = inputBuffer.Equals(_ping);
if (isPing)
{
await connection.Output.WriteAsync(_pong);
}
else
{
break;
}
connection.Input.Advance(inputBuffer.End);
}
}
}
public SecurePipelineConnection(IPipelineConnection pipeline, PipelineFactory factory, SecurePipelineListener listener)
{
_listener = listener;
_lowerConnection = pipeline;
_outputPipe = factory.Create();
_inputPipe = factory.Create();
_handshakePipe = factory.Create();
_handshakeOutpipe = factory.Create();
StartReading();
}
static async Task <Tuple <int, int, int> > PingClient(IPipelineConnection connection, int messagesToSend)
{
int count = 0;
var watch = Stopwatch.StartNew();
int sendCount = 0, replyCount = 0;
for (int i = 0; i < messagesToSend; i++)
{
await connection.Output.WriteAsync(_ping);
sendCount++;
bool havePong = false;
while (true)
{
var result = await connection.Input.ReadAsync();
var inputBuffer = result.Buffer;
if (inputBuffer.IsEmpty && result.IsCompleted)
{
connection.Input.Advance(inputBuffer.End);
break;
}
if (inputBuffer.Length < 4)
{
connection.Input.Advance(inputBuffer.Start, inputBuffer.End);
}
else
{
havePong = inputBuffer.Equals(_ping);
if (havePong)
{
count++;
}
connection.Input.Advance(inputBuffer.End);
break;
}
}
if (havePong)
{
replyCount++;
}
else
{
break;
}
}
connection.Input.Complete();
connection.Output.Complete();
watch.Stop();
return(Tuple.Create(sendCount, replyCount, (int)watch.ElapsedMilliseconds));
}
private async Task Echo(IPipelineConnection connection)
{
while (true)
{
var result = await connection.Input.ReadAsync();
var request = result.Buffer;
if (request.IsEmpty && result.IsCompleted)
{
connection.Input.Advance(request.End);
break;
}
int len = request.Length;
var response = connection.Output.Alloc();
response.Append(request);
await response.FlushAsync();
connection.Input.Advance(request.End);
}
}
private static async Task ProcessClient <TContext>(IHttpApplication <TContext> application, IPipelineConnection pipelineConnection)
{
var connection = new HttpConnection <TContext>(application, pipelineConnection.Input, pipelineConnection.Output);
await connection.ProcessAllRequests();
}
public void Initialize(IPipelineConnection connection)
{
_textOutput = new PipelineTextOutput(connection.Output, EncodingData.InvariantUtf8);
}
public static IPipelineConnection MakePipeline(IPipelineConnection connection)
{
// Do something fancy here to wrap the connection, SSL etc
return(connection);
}
public static Stream GetStream(this IPipelineConnection connection)
{
return(new PipelineConnectionStream(connection));
}
public PipelineConnectionStream(IPipelineConnection connection)
{
_connection = connection;
}
public static async Task HandleConnection(IPipelineConnection connection)
{
var httpParser = new HttpRequestParser();
while (true)
{
// Wait for data
var result = await connection.Input.ReadAsync();
var input = result.Buffer;
Console.WriteLine("Http data received");
try
{
if (input.IsEmpty && result.IsCompleted)
{
// No more data
break;
}
// Parse the input http request
var parseResult = httpParser.ParseRequest(ref input);
switch (parseResult)
{
case HttpRequestParser.ParseResult.Incomplete:
Console.WriteLine("Incomplete parsed");
if (result.IsCompleted)
{
// Didn't get the whole request and the connection ended
throw new EndOfStreamException();
}
// Need more data
continue;
case HttpRequestParser.ParseResult.Complete:
Console.WriteLine("Parsing completed");
break;
case HttpRequestParser.ParseResult.BadRequest:
Console.WriteLine("Parsing bad request");
throw new Exception();
default:
break;
}
//// Writing directly to pooled buffers
//var output = connection.Output.Alloc();
//var formatter = new OutputFormatter<WritableBuffer>(output, EncodingData.InvariantUtf8);
//formatter.Append("HTTP/1.1 200 OK");
//formatter.Append("\r\nContent-Length: 13");
//formatter.Append("\r\nContent-Type: text/plain");
//formatter.Append("\r\n\r\n");
//formatter.Append("Hello, World!");
//await output.FlushAsync();
if (httpParser.Method.Length == 3 && httpParser.Method.StartsWith(_getMethod))
{
var path = httpParser.Path.GetUtf8String();
var cacheItem = _cache.GetCacheItem(path);
if (cacheItem != null)
{
var output = connection.Output.Alloc();
var formatter = new OutputFormatter <WritableBuffer>(output, EncodingData.InvariantUtf8);
formatter.Append("HTTP/1.1 200 OK");
formatter.Append("\r\nContent-Length: ");
formatter.Append(cacheItem.Content.Length);
formatter.Append("\r\nContent-Type: ");
output.Write(cacheItem.ContentType);
formatter.Append("\r\n\r\n");
output.Write(cacheItem.Content);
Console.WriteLine($"{path}-HTTP / 1.1 200 OK");
await output.FlushAsync();
}
else
{
var output = connection.Output.Alloc();
var formatter = new OutputFormatter <WritableBuffer>(output, EncodingData.InvariantUtf8);
formatter.Append("HTTP/1.1 404 NOT FOUND");
formatter.Append("\r\nContent-Length: 0");
formatter.Append("\r\n\r\n");
Console.WriteLine($"{path}-HTTP / 1.1 404 NOT FOUND");
await output.FlushAsync();
}
}
else
{
var output = connection.Output.Alloc();
var formatter = new OutputFormatter <WritableBuffer>(output, EncodingData.InvariantUtf8);
formatter.Append("HTTP/1.1 404 NOT FOUND");
formatter.Append("\r\nContent-Length: 0");
formatter.Append("\r\n\r\n");
await output.FlushAsync();
}
if (httpParser.RequestHeaders["Connection"] == "close")
{
connection.Output.Complete();
}
httpParser.Reset();
}
finally
{
// Consume the input
connection.Input.Advance(input.Start, input.End);
}
}
}
private async Task Echo(IPipelineConnection connection)
{
while (true)
{
var result = await connection.Input.ReadAsync();
var request = result.Buffer;
if (request.IsEmpty && result.IsCompleted)
{
connection.Input.Advance(request.End);
break;
}
int len = request.Length;
var response = connection.Output.Alloc();
response.Append(request);
await response.FlushAsync();
connection.Input.Advance(request.End);
}
}
private static async Task PongServer(IPipelineConnection connection)
{
while (true)
{
var result = await connection.Input.ReadAsync();
var inputBuffer = result.Buffer;
if (inputBuffer.IsEmpty && result.IsCompleted)
{
connection.Input.Advance(inputBuffer.End);
break;
}
if (inputBuffer.Length < 4)
{
connection.Input.Advance(inputBuffer.Start, inputBuffer.End);
}
else
{
bool isPing = inputBuffer.Equals(_ping);
if (isPing)
{
await connection.Output.WriteAsync(_pong);
}
else
{
break;
}
connection.Input.Advance(inputBuffer.End);
}
}
}
static async Task<Tuple<int, int, int>> PingClient(IPipelineConnection connection, int messagesToSend)
{
int count = 0;
var watch = Stopwatch.StartNew();
int sendCount = 0, replyCount = 0;
for (int i = 0; i < messagesToSend; i++)
{
await connection.Output.WriteAsync(_ping);
sendCount++;
bool havePong = false;
while (true)
{
var result = await connection.Input.ReadAsync();
var inputBuffer = result.Buffer;
if (inputBuffer.IsEmpty && result.IsCompleted)
{
connection.Input.Advance(inputBuffer.End);
break;
}
if (inputBuffer.Length < 4)
{
connection.Input.Advance(inputBuffer.Start, inputBuffer.End);
}
else
{
havePong = inputBuffer.Equals(_ping);
if (havePong)
{
count++;
}
connection.Input.Advance(inputBuffer.End);
break;
}
}
if (havePong)
{
replyCount++;
}
else
{
break;
}
}
connection.Input.Complete();
connection.Output.Complete();
watch.Stop();
return Tuple.Create(sendCount, replyCount, (int)watch.ElapsedMilliseconds);
}
public SecurePipelineConnection CreateSecureClientPipeline(IPipelineConnection pipeline)
{
return(new SecurePipelineConnection(pipeline, _factory, this));
}
