private async void SocketClient_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var fiberRw = await GetFiberRw(socketAsync);
try
{
if (fiberRw == null)
{
client.SetConnected(false, "ssl error");
return;
}
IWrite = fiberRw;
if (!isConnect)
{
await SendVerify(); //发送KEY和sessionid验证
await fiberRw.ReadInt32(); //丢弃长度,因为这个Socket框架不需要,留给C++ go java等语言和其他SOCKET框架用
switch (await fiberRw.ReadInt32())
{
case 1000: //key check
{
var iserror = await fiberRw.ReadBoolean();
if (!iserror)
{
Log.Trace(await fiberRw.ReadString());
isConnect = true;
client.SetConnected();
await ReadIng(fiberRw);
}
else
{
var msg = await fiberRw.ReadString();
Log.Info(msg);
client.SetConnected(false, msg);
}
}
break;
}
}
client.ShutdownBoth(true);
}
catch (Exception er)
{
if (!client.IsConnect)
{
client.SetConnected(false, er.Message);
}
else
{
Log.Error(er);
client.ShutdownBoth(true);
}
}
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
// USE SSL
var res = await socketAsync.GetFiberRwSSL <string>(certificate, "localhost");
if (res.IsError)
{
Console.WriteLine(res.ErrMsg);
client.ShutdownBoth(true);
return;
}
var fiberRw = res.FiberRw;
// var fiberRw = await socketAsync.GetFiberRw();
client.SetConnected();
while (true)
{
try
{
await DataOnByLine(fiberRw);
}
catch
{
break;
}
}
client.ShutdownBoth();
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var res = await socketAsync.GetFiberRwSSL(null, ""); //我们在这地方使用SSL加密
if (res.IsError)
{
Console.WriteLine(res.ErrMsg);
client.ShutdownBoth();
return;
}
client.SetConnected();
for (; ;) //我们可以在这里处理数据或者在上面
{
try
{
await ReadCommand(res.FiberRw);
}
catch (Exception er)
{
Console.WriteLine(er);
break;
}
}
client.ShutdownBoth();
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var fiberRw = await socketAsync.GetFiberRw();
if (fiberRw == null)
{
client.ShutdownBoth(true);
return;
}
client.SetConnected();
for (; ;) //我们可以在这里处理数据或者在上面
{
try
{
await ReadCommand(fiberRw);
}
catch (Exception er)
{
Console.WriteLine(er);
break;
}
}
client.ShutdownBoth(true);
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
// USE SSL+GZIP
var res = await socketAsync.GetFiberRwSSL <string>(certificate, "localhost", (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 (res.IsError)
{
Console.WriteLine(res.ErrMsg);
client.ShutdownBoth(true);
return;
}
var fiberRw = res.FiberRw;
//var fiberRw = await socketAsync.GetFiberRw((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();
client.SetConnected();
var testspeed = Stopwatch.StartNew();
var i = 0L;
while (true)
{
try
{
i++;
await DataOnByLine(fiberRw);
if (i % 10000 == 0)
{
Console.WriteLine(testspeed.ElapsedMilliseconds + " ms");
testspeed.Restart();
}
//Console.WriteLine("OK");
}
catch
{
break;
}
}
client.ShutdownBoth();
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var fiberRw = await socketAsync.GetFiberRw((input, output) => //我们在这地方使用GZIP 压缩发送流 解压读取流
{
var gzip_input = new GZipStream(input, CompressionMode.Decompress, false); //将读取流解压
var gzip_output = new GZipStream(output, CompressionMode.Compress, false); //将输出流压缩
return(new GetFiberRwResult(gzip_input, gzip_output)); //这里顺序不要搞反 (input,output)的顺序
});
if (fiberRw == null)
{
client.ShutdownBoth(true);
return;
}
client.SetConnected();
for (; ;) //我们可以在这里处理数据或者在上面
{
try
{
await ReadCommand(fiberRw);
}
catch (Exception er)
{
Console.WriteLine(er);
break;
}
}
client.ShutdownBoth(true);
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var res = await socketAsync.GetFiberRwSSL(null, "localhost");
var fiberRw = res.FiberRw;
client.SetConnected();
while (true)
{
try
{
string a = await fiberRw.ReadString();
Console.WriteLine(a);
}
catch
{
break;
}
}
client.ShutdownBoth(true);
}
/// <summary>
/// 返回FiberRw
/// </summary>
/// <param name="socketAsync"></param>
/// <returns></returns>
protected virtual async Task <IFiberRw?> GetFiberRw(ISockAsyncEventAsClient socketAsync)
{
if (is_use_ssl) //SSL Config
{
var result = decodeType switch
{
CompressType.None => await socketAsync.GetFiberRwSSL(Certificate !),
CompressType.gzip => await socketAsync.GetFiberRwSSL(Certificate !, init : (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(Certificate !, init : (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 (result.IsError)
{
if (result.ErrMsg != null)
{
Log.Error(result.ErrMsg);
}
return(null);
}
else
{
return(result.FiberRw);
}
}
else
{
return(decodeType switch
{
CompressType.None => await socketAsync.GetFiberRw(),
CompressType.gzip => await socketAsync.GetFiberRw((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((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()
});
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
//USE SSL+GZIP
//var res = await socketAsync.GetFiberRwSSL<string>(null, "localhost", (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
//});
//if (res.IsError)
//{
// Console.WriteLine(res.ErrMsg);
// client.ShutdownBoth(true);
// return;
//}
//var fiberRw = res.FiberRw;
var fiberRw = await socketAsync.GetFiberRw();
client.SetConnected();
while (true)
{
try
{
await DataOnByLine(fiberRw);
}
catch
{
break;
}
}
client.ShutdownBoth(true);
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var res = await socketAsync.GetFiberRwSSL(async stream =>
{
var sslstream = new SslStream(stream, false, (sender, certificate, chain, errors) => true,
(sender, host, certificates, certificate, issuers)
=> certificate);
try
{
await sslstream.AuthenticateAsClientAsync("localhost");
}
catch (Exception er)
{
Console.WriteLine(er.Message);
return(null);
}
return(sslstream);
});
var fiberRw = res.FiberRw;
client.SetConnected();
while (true)
{
try
{
string a = await fiberRw.ReadString();
Console.WriteLine(a);
}
catch
{
break;
}
}
client.ShutdownBoth(true);
}
/// <summary>
/// 返回FiberRw
/// </summary>
/// <param name="socketAsync"></param>
/// <returns></returns>
protected virtual async Task <IFiberRw> GetFiberRw(ISockAsyncEventAsClient socketAsync)
{
if (is_use_ssl) //SSL Config
{
var result = await socketAsync.GetFiberRwSSL(Certificate);
if (result.IsError)
{
Log.Error(result.ErrMsg);
return(null);
}
else
{
return(result.FiberRw);
}
}
else
{
return(await socketAsync.GetFiberRw());
}
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var res = await socketAsync.GetFiberRwSSL(null, "", (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 (res.IsError)
{
Console.WriteLine(res.ErrMsg);
client.ShutdownBoth();
return;
}
client.SetConnected();
for (; ;) //我们可以在这里处理数据或者在上面
{
try
{
await ReadCommand(res.FiberRw);
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er);
break;
}
}
socketAsync.Disconnect();
}
private static async void Client_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var fiberRw = await socketAsync.GetFiberRw((input,output) => //我们在这地方使用GZIP 压缩发送流 解压读取流
{
var lz4_input = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Decode(input);
var lz4_output = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Encode(output);
return new GetFiberRwResult(lz4_input, lz4_output); //这里顺序不要搞反 (input,output)的顺序
});
if(fiberRw==null)
{
client.ShutdownBoth(true);
return;
}
client.SetConnected();
for (; ; ) //我们可以在这里处理数据或者在上面
{
try
{
await ReadCommand(fiberRw);
}
catch (Exception er)
{
Console.WriteLine(er);
break;
}
}
client.ShutdownBoth(true);
}
private void SocketClient_Disconnect(ISocketClient client, ISockAsyncEventAsClient socketAsync, string msg)
{
Log.Info($"{ConnectOption.Host}:{ConnectOption.Port}->{msg}");
Close();
Disconnect?.Invoke(client, socketAsync, msg);
}
private async void SocketClient_BinaryInput(ISocketClient client, ISockAsyncEventAsClient socketAsync)
{
var fiberRw = await GetFiberRw(socketAsync);
try
{
if (fiberRw == null)
{
client.SetConnected(false, "ssl error");
return;
}
IWrite = fiberRw;
if (!isConnect)
{
await SendVerify(); //发送KEY和sessionid验证
using ReadBytes read = new ReadBytes(fiberRw);
await read.Init();
switch (read.ReadInt32())
{
case 1000: //key check
{
var iserror = read.ReadBoolean();
if (!iserror)
{
Log.Trace(read.ReadString());
if (read.Memory.Length >= 1)
{
if (read.ReadByte() == 1)
{
Mode = 1;
}
}
isConnect = true;
client.SetConnected();
await GetSessionId();
await ReadIng(fiberRw);
}
else
{
var msg = read.ReadString();
Log.Info(msg);
client.SetConnected(false, msg);
}
}
break;
}
}
client.ShutdownBoth();
}
catch (Exception er)
{
if (!client.IsConnect)
{
client.SetConnected(false, er.Message);
}
else
{
Log.Error(er);
client.ShutdownBoth();
}
}
}
