private static async Task ProcessConnection <TContext>(IHttpApplication <TContext> application, MemoryPool <byte> memoryPool, Socket socket)
{
using (var ns = new NetworkStream(socket))
{
using (var connection = new StreamPipeConnection(new PipeOptions(memoryPool), ns))
{
await ProcessClient(application, connection);
}
}
}
protected override Task <IPipeConnection> GetConnection()
{
Socket s = new Socket(SocketType.Stream, ProtocolType.Tcp);
s.Connect(new IPEndPoint(IPAddress.Loopback, 5000));
var pipeConnection = new StreamPipeConnection(new PipeOptions(pool), new NetworkStream(s));
return(Task.FromResult((IPipeConnection)pipeConnection));
}
static async Task DoTheThingViaTcpClient(string host, int port, string password, bool useTls, X509Certificate cert)
{
try
{
using (var pool = new MemoryPool())
using (var client = new TcpClient())
{
await Console.Out.WriteLineAsync(ShowDetails?$"connecting to {host}:{port}..." : "connecting to host");
await client.ConnectAsync(host, port);
Stream stream = client.GetStream();
if (useTls)
{
await Console.Out.WriteLineAsync($"authenticating host...");
LocalCertificateSelectionCallback certSelector = null;
if (cert != null)
{
certSelector = delegate { return(cert); };
}
RemoteCertificateValidationCallback serverValidator = delegate { return(true); }; // WCGW?
var ssl = new SslStream(stream, false, serverValidator, certSelector);
await ssl.AuthenticateAsClientAsync(host);
if (ssl.LocalCertificate != null)
{
Console.WriteLine($"Local cert: {ssl.LocalCertificate.Subject}");
}
stream = ssl;
}
using (var pipe = new StreamPipeConnection(new PipeOptions(pool), stream))
{
await ExecuteWithTimeout(pipe, password);
}
}
}
catch (Exception ex)
{
while (ex != null)
{
await Console.Error.WriteLineAsync(ex.Message);
ex = ex.InnerException;
}
}
}
public async Task Run()
{
var pipeOptions = new PipeOptions(GetBufferPool());
var consoleOutput = StreamPipeConnection.CreateWriter(pipeOptions, Console.OpenStandardOutput());
var connection = await GetConnection();
while (true)
{
var buffer = connection.Output;
var output = buffer;
output.Append("GET / HTTP/1.1", SymbolTable.InvariantUtf8);
output.Append("\r\n\r\n", SymbolTable.InvariantUtf8);
await buffer.FlushAsync();
// Write the client output to the console
await CopyCompletedAsync(connection.Input, consoleOutput);
await Task.Delay(1000);
}
}
private async Task OpenConnection(IDuplexPipe application, Uri url, TaskCompletionSource <object> startTcs, CancellationToken cancellationToken)
{
Log.StartReceive(_logger);
var request = new HttpRequestMessage(HttpMethod.Get, url);
SendUtils.PrepareHttpRequest(request, _httpOptions);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/event-stream"));
HttpResponseMessage response;
try
{
response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
response.EnsureSuccessStatusCode();
startTcs.TrySetResult(null);
}
catch (Exception ex)
{
Log.TransportStopping(_logger);
startTcs.TrySetException(ex);
return;
}
using (var stream = await response.Content.ReadAsStreamAsync())
{
var pipeOptions = new PipeOptions(pauseWriterThreshold: 0, resumeWriterThreshold: 0);
var pipelineReader = StreamPipeConnection.CreateReader(pipeOptions, stream);
var readCancellationRegistration = cancellationToken.Register(
reader => ((PipeReader)reader).CancelPendingRead(), pipelineReader);
try
{
while (true)
{
var result = await pipelineReader.ReadAsync();
var input = result.Buffer;
if (result.IsCanceled || (input.IsEmpty && result.IsCompleted))
{
Log.EventStreamEnded(_logger);
break;
}
var consumed = input.Start;
var examined = input.End;
try
{
Log.ParsingSSE(_logger, input.Length);
var parseResult = _parser.ParseMessage(input, out consumed, out examined, out var buffer);
switch (parseResult)
{
case ServerSentEventsMessageParser.ParseResult.Completed:
Log.MessageToApp(_logger, buffer.Length);
await _application.Output.WriteAsync(buffer);
_parser.Reset();
break;
case ServerSentEventsMessageParser.ParseResult.Incomplete:
if (result.IsCompleted)
{
throw new FormatException("Incomplete message.");
}
break;
}
}
finally
{
pipelineReader.AdvanceTo(consumed, examined);
}
}
}
catch (OperationCanceledException)
{
Log.ReceiveCanceled(_logger);
}
finally
{
readCancellationRegistration.Dispose();
_transportCts.Cancel();
Log.ReceiveStopped(_logger);
}
}
}
private async Task OpenConnection(Channel <byte[], SendMessage> application, Uri url, CancellationToken cancellationToken)
{
_logger.StartReceive();
var request = new HttpRequestMessage(HttpMethod.Get, url);
SendUtils.PrepareHttpRequest(request, _httpOptions);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/event-stream"));
var response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
var stream = await response.Content.ReadAsStreamAsync();
var pipelineReader = StreamPipeConnection.CreateReader(new PipeOptions(_memoryPool), stream);
var readCancellationRegistration = cancellationToken.Register(
reader => ((IPipeReader)reader).CancelPendingRead(), pipelineReader);
try
{
while (true)
{
var result = await pipelineReader.ReadAsync();
var input = result.Buffer;
if (result.IsCancelled || (input.IsEmpty && result.IsCompleted))
{
_logger.EventStreamEnded();
break;
}
var consumed = input.Start;
var examined = input.End;
try
{
var parseResult = _parser.ParseMessage(input, out consumed, out examined, out var buffer);
switch (parseResult)
{
case ServerSentEventsMessageParser.ParseResult.Completed:
_application.Writer.TryWrite(buffer);
_parser.Reset();
break;
case ServerSentEventsMessageParser.ParseResult.Incomplete:
if (result.IsCompleted)
{
throw new FormatException("Incomplete message.");
}
break;
}
}
finally
{
pipelineReader.Advance(consumed, examined);
}
}
}
catch (OperationCanceledException)
{
_logger.ReceiveCanceled();
}
finally
{
readCancellationRegistration.Dispose();
_transportCts.Cancel();
stream.Dispose();
_logger.ReceiveStopped();
}
}
