public override async IAsyncEnumerable <IConnectionListener> BindAsync([EnumeratorCancellation] CancellationToken token = default)
{
IConnectionListener ipv6Listener = null;
IConnectionListener ipv4Listener = null;
var exceptions = new List <Exception>();
try { ipv6Listener = await _listenerFactory.BindAsync(new IPEndPoint(IPAddress.IPv6Loopback, _port), token); }
catch (Exception ex) when(!(ex is IOException))
{
exceptions.Add(ex);
}
if (ipv6Listener != null)
{
yield return(ipv6Listener);
}
try { ipv4Listener = await _listenerFactory.BindAsync(new IPEndPoint(IPAddress.Loopback, _port), token); }
catch (Exception ex) when(!(ex is IOException))
{
exceptions.Add(ex);
}
if (exceptions.Count == 2)
{
throw new IOException($"Failed to bind to {this}", new AggregateException(exceptions));
}
if (ipv4Listener != null)
{
yield return(ipv4Listener);
}
}
public async Task StartAsync <TContext>(IHttpApplication <TContext> application, CancellationToken cancellationToken)
{
try
{
// Kestrel does not support big-endian architectures. Kestrel
// 不支持大端模式的处理器
//https://www.cnblogs.com/little-white/p/3236548.html
if (!BitConverter.IsLittleEndian)
{
throw new PlatformNotSupportedException(CoreStrings.BigEndianNotSupported);
}
EndPoint endPoint;
if (ServerOptions.Host.StartsWith("unix://", StringComparison.Ordinal))
{
endPoint = new UnixDomainSocketEndPoint(ServerOptions.Host.Substring(ServerOptions.Host.IndexOf("unix://") + 1));
}
else if (ServerOptions.Host.Contains("localhost"))
{
endPoint = new IPEndPoint(IPAddress.Loopback, ServerOptions.Port);
}
else if (IPAddress.TryParse(ServerOptions.Host, out var ip))
{
endPoint = new IPEndPoint(ip, ServerOptions.Port);
}
else
{
endPoint = new IPEndPoint(IPAddress.IPv6Any, ServerOptions.Port);
}
async Task OnBind(EndPoint _endPoint)
{
// 构建委托:用于处理socket请求
var connectionBuilder = new ConnectionBuilder();
connectionBuilder.Use(next => { return(new HttpConnectionMiddleware <TContext>(application).OnConnectionAsync); });
var connectionDelegate = connectionBuilder.Build();
// Add the connection limit middleware
//if (Options.Limits.MaxConcurrentConnections.HasValue)
//{
// connectionDelegate = new ConnectionLimitMiddleware(connectionDelegate, Options.Limits.MaxConcurrentConnections.Value, Trace).OnConnectionAsync;
//}
// 构建服务端Socket: 用于进行监听客户端请求
var g = _transportFactory.BindAsync(_endPoint).Result;
var transport = await _transportFactory.BindAsync(_endPoint).ConfigureAwait(false);
// 通过 ThreadPool.UnsafeQueueUserWorkItem，分配任务: 服务端接收 socket请求连接，处理请求
var connectionDispatcher = new ConnectionDispatcher(connectionDelegate, ServiceContext);
var acceptLoopTask = connectionDispatcher.StartAcceptingConnections(transport);
}
await OnBind(endPoint);
}
catch (Exception ex)
{
Dispose();
throw;
}
throw new NotImplementedException();
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var listener = await _factory.BindAsync(new NamedPipeEndPoint("13f10fec-abcf-4f01-be97-2003f870600e"));
var connection = await listener.AcceptAsync(stoppingToken);
while (true)
{
var result = await connection.Transport.Input.ReadAsync(stoppingToken);
if (stoppingToken.IsCancellationRequested)
{
connection.Abort();
break;
}
if (result.IsCompleted)
{
break;
}
await connection.Transport.Output.WriteAsync(result.Buffer.ToArray());
connection.Transport.Input.AdvanceTo(result.Buffer.End);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var listener = await _factory.BindAsync(new IPEndPoint(IPAddress.Loopback, 5000), stoppingToken);
// In an actual server you call Accept in a loop
var connection = await listener.AcceptAsync(stoppingToken);
while (true)
{
var result = await connection.Transport.Input.ReadAsync(stoppingToken);
if (stoppingToken.IsCancellationRequested)
{
connection.Abort();
break;
}
if (result.IsCompleted)
{
break;
}
await connection.Transport.Output.WriteAsync(result.Buffer.ToArray());
connection.Transport.Input.AdvanceTo(result.Buffer.End);
// To demo the echo server I use `nc` under WSL
// `nc localhost 5000`
}
}
public async Task Execute(IJobExecutionContext context)
{
try
{
var bind = await connectionListenerFactory.BindAsync(new IPEndPoint(IPAddress.Loopback, 1080));
logger.LogInformation($"客户端正在监听1080端口");
while (true)
{
ConnectionContext browser = await bind.AcceptAsync();
ThreadPool.QueueUserWorkItem(new WaitCallback(async(obj) =>
{
try
{
await TcpHandlerAsync(browser);
}
catch (Exception ex)
{
logger.LogError(ex.InnerException?.Message ?? ex.Message);
}
}));
}
}
catch (Exception ex)
{
logger.LogCritical(ex.InnerException?.Message ?? ex.Message);
}
}
public async Task StartAsync(ILogger <Local> logger,
IConnectionListenerFactory listenerFactory,
string localListenAddress,
int localListenPort,
string remoteAddress,
int remotePort)
{
this.logger = logger;
this.remoteAddress = remoteAddress;
this.remotePort = remotePort;
try
{
var bind = await listenerFactory.BindAsync(new IPEndPoint(IPAddress.Parse(localListenAddress), localListenPort));
logger.LogInformation($"客户端正在监听{localListenPort}端口");
while (true)
{
ConnectionContext browser = await bind.AcceptAsync();
TcpHandlerAsync(browser);
}
}
catch (Exception ex)
{
logger.LogCritical(ex.Message);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_connectionListener = await _connectionListenerFactory.BindAsync(new IPEndPoint(IPAddress.Loopback, 6000), stoppingToken);
while (true)
{
ConnectionContext connection = await _connectionListener.AcceptAsync(stoppingToken);
// AcceptAsync will return null upon disposing the listener
if (connection == null)
{
break;
}
// In an actual server, ensure all accepted connections are disposed prior to completing
_ = Accept(connection);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
IConnectionListenerFactory listenerFactory = app.ApplicationServices.GetRequiredService <IConnectionListenerFactory>();
Task.Run(async() =>
{
try
{
var listener = await listenerFactory.BindAsync(new IPEndPoint(IPAddress.Any, 2019));
while (true)
{
ConnectionContext browser = await listener.AcceptAsync();
//处理浏览器
ProcessBrowserAsync(browser);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
});
}
public override async IAsyncEnumerable <IConnectionListener> BindAsync([EnumeratorCancellation] CancellationToken token = default)
{
yield return(await _listenerFactory.BindAsync(_endPoint, token));
}
