static void DisconnectHandler(string message, ISockAsyncEventAsServer socketAsync, int erorr)
{
Console.WriteLine($"{message}");
socketAsync.UserToken = null; //在这里我们转换成userinfo 然后做一些用户断开后的操作
socketAsync.AcceptSocket?.Close();
socketAsync.AcceptSocket?.Dispose();
}
protected virtual async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
var fiberRw = await GetFiberRw(socketAsync);
if (fiberRw == null)
{
socketAsync.Disconnect();
return;
}
for (; ;)
{
try
{
if (!await DataOnByLine(fiberRw))
{
break;
}
}
catch (System.Net.Sockets.SocketException) { break; }
catch (Exception er)
{
this.Log.Error("read error", er);
break;
}
}
socketAsync.Disconnect();
}
static async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
var(fiberW, errMsg) = await socketAsync.GetFiberRwSSL <UserInfo>(certificate); //获取一个异步基础流
if (fiberW is null) //如果获取失败 那么断开连接
{
Console.WriteLine(errMsg);
socketAsync.Disconnect();
return;
}
for (; ;) //循环读取处理数据表 类似于 协程
{
try
{
await ReadCommand(fiberW);
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString()); //出现异常 打印，并且结束循环，断开连接
break;
}
}
socketAsync.Disconnect();
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
//USE SSL+GZIP
var(fiberRw, errMsg) = await socketAsync.GetFiberRwSSL <string>(certificate, (input, output) =>
{
//var gzip_input = new GZipStream(input, CompressionMode.Decompress, true);
//var gzip_output = new GZipStream(output, CompressionMode.Compress, true);
//return new GetFiberRwResult(gzip_input, gzip_output); //return gzip mode
var lz4_input = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Decode(input, leaveOpen: true);
var lz4_output = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Encode(output, leaveOpen: true);
return(new GetFiberRwResult(lz4_input, lz4_output)); //return lz4 mode
});
if (fiberRw is null)
{
Console.WriteLine(errMsg);
socketAsync.Disconnect();
return;
}
//var fiberRw = await socketAsync.GetFiberRw<string>((input, output) =>
//{
// var lz4_input = K4os.Compression.LZ4.Streams.LZ4Stream.Decode(input, leaveOpen: true);
// var lz4_output = K4os.Compression.LZ4.Streams.LZ4Stream.Encode(output, leaveOpen: true);
// return new GetFiberRwResult(lz4_input, lz4_output); //return lz4 mode
//});
//var fiberRw = await socketAsync.GetFiberRw<string>();
fiberRw.UserToken = "my is ttk";
for (; ;)
{
try
{
//提供2种数据 读取写入方式
ReadBytes readBytes = await new ReadBytes(fiberRw).Init();
DataOn(ref readBytes, fiberRw);
await DataOnByLine(fiberRw);
}
catch (System.IO.IOException)
{
break;
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
break;
}
}
socketAsync.Disconnect();
}
static async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
var fiberW = await socketAsync.GetFiberRw <UserInfo>((input, output) => //我们在这地方使用GZIP 压缩发送流 解压读取流
{
var gzip_input = new GZipStream(input, CompressionMode.Decompress); //将读取流解压
var gzip_output = new GZipStream(output, CompressionMode.Compress); //将输出流压缩
return(new GetFiberRwResult(gzip_input, gzip_output)); //这里顺序不要搞反 (input,output)的顺序
});
if (fiberW is null) //如果获取失败 那么断开连接
{
socketAsync.Disconnect();
return;
}
for (; ;) //循环读取处理数据表 类似于 协程
{
try
{
await ReadCommand(fiberW);
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString()); //出现异常 打印，并且结束循环，断开连接
break;
}
}
socketAsync.Disconnect();
}
protected override void DisconnectHandler(string message, ISockAsyncEventAsServer socketAsync, int erorr)
{
base.DisconnectHandler(message, socketAsync, erorr);
this.Log.TraceFormat("IP Disconnect:{0}", socketAsync?.AcceptSocket?.RemoteEndPoint);
socketAsync.UserToken = null;
socketAsync.AcceptSocket.Dispose();
}
/// <summary>
/// 返回FiberRw
/// </summary>
/// <param name="socketAsync"></param>
/// <returns></returns>
protected virtual async Task <IFiberRw <AsyncToken>?> GetFiberRw(ISockAsyncEventAsServer socketAsync)
{
if (is_use_ssl) //SSL Config
{
// var (fiber, msg) = await socketAsync.GetFiberRwSSL<AsyncToken>(Certificate!);
var(fiber, msg) = decodeType switch
{
CompressType.None => await socketAsync.GetFiberRwSSL <AsyncToken>(Certificate !),
CompressType.gzip => await socketAsync.GetFiberRwSSL <AsyncToken>(Certificate !, (input, output) =>
{
var gzip_input = new GZipStream(input, CompressionMode.Decompress, true);
var gzip_output = new GZipStream(output, CompressionMode.Compress, true);
return(new GetFiberRwResult(gzip_input, gzip_output)); //return gzip mode
}),
CompressType.lz4 => await socketAsync.GetFiberRwSSL <AsyncToken>(Certificate !, (input, output) =>
{
var lz4_input = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Decode(input, leaveOpen: true);
var lz4_output = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Encode(output, leaveOpen: true);
return(new GetFiberRwResult(lz4_input, lz4_output)); //return lz4 mode
}),
_ => throw new NotImplementedException()
};
if (fiber is null)
{
if (msg != null)
{
Log.Error(msg);
}
return(null);
}
else
{
return(fiber);
}
}
else
{
return(decodeType switch
{
CompressType.None => await socketAsync.GetFiberRw <AsyncToken>(),
CompressType.gzip => await socketAsync.GetFiberRw <AsyncToken>((input, output) =>
{
var gzip_input = new GZipStream(input, CompressionMode.Decompress, true);
var gzip_output = new GZipStream(output, CompressionMode.Compress, true);
return new GetFiberRwResult(gzip_input, gzip_output); //return gzip mode
}),
CompressType.lz4 => await socketAsync.GetFiberRw <AsyncToken>((input, output) =>
{
var lz4_input = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Decode(input, leaveOpen: true);
var lz4_output = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Encode(output, leaveOpen: true);
return new GetFiberRwResult(lz4_input, lz4_output); //return lz4 mode
}),
_ => throw new NotImplementedException()
});
protected override void DisconnectHandler(string message, ISockAsyncEventAsServer socketAsync, int erorr)
{
base.DisconnectHandler(message, socketAsync, erorr);
this.Log.TraceFormat("IP Disconnect:{IPAddress}", socketAsync?.AcceptSocket?.RemoteEndPoint?.ToString() ?? "null");
if (socketAsync != null)
{
socketAsync.UserToken = null;
socketAsync.AcceptSocket?.Dispose();
}
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
//USE SSL+GZIP
var(fiberRw, errMsg) = await socketAsync.GetFiberRwSSL <string>(certificate, (input, output) =>
{
var gzip_input = new GZipStream(input, CompressionMode.Decompress, true);
var gzip_output = new GZipStream(output, CompressionMode.Compress, true);
return(new GetFiberRwResult(gzip_input, gzip_output)); //return gzip mode
});
// var (fiberRw, errMsg) = await socketAsync.GetFiberRwSSL<string>(certificate);
if (fiberRw is null)
{
Console.WriteLine(errMsg);
socketAsync.Disconnect();
return;
}
// var fiberRw = await socketAsync.GetFiberRw<string>();
fiberRw.UserToken = "my is ttk";
byte[] data = new byte[4096];
for (; ;)
{
try
{
var x = System.Diagnostics.Stopwatch.StartNew();
var memory = await fiberRw.ReadLine(data);
x.Stop();
var str = System.Text.Encoding.Default.GetString(memory.Span);
Console.WriteLine(x.ElapsedTicks + ":" + str);
fiberRw.Write("200\r\n", false);
await fiberRw.FlushAsync();
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
break;
}
}
socketAsync.Disconnect();
}
protected virtual void DisconnectHandler(string message, ISockAsyncEventAsServer socketAsync, int erorr)
{
try
{
if (socketAsync.UserToken is AsyncToken token)
{
var time = TimeHelper.GetTime();
DisconnectRemoveList.Enqueue(new TimeKey(token.SessionId, time));
token.Disconnect();
}
}
catch (Exception er)
{
Log.Error(er, "Disconnect error:{message} errorid:{error}", message, erorr);
}
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
var(fiberRw, errMsg) = await socketAsync.GetFiberRwSSL <string>(certificate);
Console.WriteLine("SSL OK");
if (fiberRw is null)
{
Console.WriteLine(errMsg);
socketAsync.Disconnect();
return;
}
fiberRw.UserToken = "my is ttk";
for (; ;)
{
try
{
using (var data = await fiberRw.ReadMemory())
{
int?x = await fiberRw.ReadInt32();
Console.WriteLine(data.Value.Length);
Console.WriteLine(x);
fiberRw.Write("ok");
await fiberRw.Flush();
}
break;
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
break;
}
}
socketAsync.AcceptSocket.Shutdown(System.Net.Sockets.SocketShutdown.Both);
}
static async void DisconnectHandler(string message, ISockAsyncEventAsServer socketAsync, int erorr)
{
Console.WriteLine($"{message}");
if (socketAsync.UserToken is UserInfo user)
{
UserList.RemoveAll(p => p.UserToken == user);
foreach (var item in UserList.AsReadOnly())
{
item.Write(4000);
item.Write(user.UserName);
await item.Flush();
}
}
socketAsync.UserToken = null; //在这里我们转换成userinfo 然后做一些用户断开后的操作
socketAsync.AcceptSocket?.Close();
socketAsync.AcceptSocket?.Dispose();
}
/// <summary>
/// 返回FiberRw
/// </summary>
/// <param name="socketAsync"></param>
/// <returns></returns>
protected virtual async Task <IFiberRw <AsyncToken> > GetFiberRw(ISockAsyncEventAsServer socketAsync)
{
if (is_use_ssl) //SSL Config
{
var(fiber, msg) = await socketAsync.GetFiberRwSSL <AsyncToken>(Certificate);
if (fiber is null)
{
Log.Error(msg);
return(null);
}
else
{
return(fiber);
}
}
else
{
return(await socketAsync.GetFiberRw <AsyncToken>());
}
}
static async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
var(fiberW, errMsg) = await socketAsync.GetFiberRwSSL <UserInfo>(certificate, (input, output) => //在GZIP的基础上在通过SSL 加密
{
var gzip_input = new GZipStream(input, CompressionMode.Decompress, true); //注意第三个参数
var gzip_output = new GZipStream(output, CompressionMode.Compress, true);
return(new GetFiberRwResult(gzip_input, gzip_output));
}); //我们在这地方使用SSL加密
if (fiberW is null) //如果获取失败 那么断开连接
{
Console.WriteLine(errMsg);
socketAsync.Disconnect();
return;
}
for (; ;) //循环读取处理数据表 类似于 协程
{
try
{
await ReadCommand(fiberW);
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString()); //出现异常 打印，并且结束循环，断开连接
break;
}
}
socketAsync.Disconnect();
}
static bool ConnectionFilter(ISockAsyncEventAsServer socketAsync)
{
Console.WriteLine($"{socketAsync?.AcceptSocket?.RemoteEndPoint} connect"); //打印连接
return(true);
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
// var (fiberRw, errMsg) = await socketAsync.GetFiberRwSSL<string>(certificate);
var(fiberRw, errMsg) = await socketAsync.GetFiberRwSSL <string>(async (stream) =>
{
var sslstream = new SslStream(stream, false);
try
{
await sslstream.AuthenticateAsServerAsync(certificate, false, SslProtocols.Tls, true);
}
catch (Exception er)
{
Console.WriteLine(er.Message);
return(null);
}
return(sslstream);
});
if (fiberRw is null)
{
Console.WriteLine(errMsg);
socketAsync.Disconnect();
return;
}
Console.WriteLine("SSL OK");
fiberRw.UserToken = "my is ttk";
for (; ;)
{
try
{
using (var data = await fiberRw.ReadMemory())
{
int?x = await fiberRw.ReadInt32();
Console.WriteLine(data.Value.Length);
Console.WriteLine(x);
fiberRw.Write("ok");
await fiberRw.FlushAsync();
}
break;
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
break;
}
}
socketAsync.AcceptSocket.Shutdown(System.Net.Sockets.SocketShutdown.Both);
}
private bool ConnectionFilter(ISockAsyncEventAsServer socketAsync)
{
this.Log.Trace($"IP Connect:{socketAsync?.AcceptSocket?.RemoteEndPoint}");
return(true);
}
private bool ConnectionFilter(ISockAsyncEventAsServer socketAsync)
{
this.Log.TraceFormat("IP Connect:{IPaddress}", socketAsync?.AcceptSocket?.RemoteEndPoint?.ToString() ?? "null");
return(true);
}
