/// <summary>
/// サーバメソッド呼び出し（サーバのレスポンスを待つ）
/// </summary>
/// <param name="serverMethodName"></param>
/// <param name="data"></param>
/// <returns></returns>
internal async Task <byte[]> Send(string serverMethodName, byte[] data)
{
using (await TCPReceiveLock.LockAsync())
{
if (serverSocket == null || serverSocket.Connected == false || Connected == false)
{
return(null);
}
lock (ServerCallMethodName)
{
ServerCallMethodName = serverMethodName;
}
SocketyPacket packet = new SocketyPacket {
MethodName = serverMethodName, clientInfo = ClientInfo, PackData = data, Toekn = AuthenticationToken
};
RecieveSyncEvent.Reset();
ServerResponse = null;
var d = MessagePackSerializer.Serialize(packet);
var sizeb = BitConverter.GetBytes(d.Length);
try
{
stream.Write(sizeb, 0, sizeof(int));
stream.Write(d, 0, d.Length);
}
catch { }
finally
{
RecieveSyncEvent.WaitOne();
}
}
return(ServerResponse);
}
private async Task SendHeartBeat()
{
try
{
using (await TCPReceiveLock.LockAsync())
{
var packet = new SocketyPacket()
{
SocketyPacketType = SocketyPacket.SOCKETY_PAKCET_TYPE.HaertBeat
};
var d = MessagePackSerializer.Serialize(packet);
var sizeb = BitConverter.GetBytes(d.Length);
stream.Write(sizeb, 0, sizeof(int));
stream.Write(d, 0, d.Length);
}
}
catch (IOException ex)
{
Logger.LogInformation("SendHeartBeat:DisConnect");
//await ConnectionLost();
}
catch (Exception ex)
{
throw ex;
}
}
internal void SendNonReturn(string ClientMethodName, byte[] data)
{
try
{
lock (lockObject)
{
var packet = new SocketyPacket()
{
MethodName = ClientMethodName, PackData = data
};
var d = MessagePackSerializer.Serialize(packet);
if (serverSocket != null)
{
PacketSize size = PacketSize.Create(d.Length);
var sizeb = size.GetBytes();
commnicateStream.Write(sizeb, 0, sizeb.Length);
commnicateStream.Write(d, 0, d.Length);
}
}
}
catch (IOException ex)
{
//Logger.LogError($"SendNonReturn:{ex.ToString()}");
return;
}
catch (Exception ex)
{
throw ex;
}
}
private void SendHeartBeat()
{
try
{
lock (lockObject)
{
var packet = new SocketyPacket()
{
SocketyPacketType = SocketyPacket.SOCKETY_PAKCET_TYPE.HaertBeat
};
var d = MessagePackSerializer.Serialize(packet);
PacketSize size = PacketSize.Create(d.Length);
var sizeb = size.GetBytes();
commnicateStream.Write(sizeb, 0, sizeb.Length);
commnicateStream.Write(d, 0, d.Length);
}
}
catch (IOException ex)
{
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// SocketyPacket.MethodNameのメソッド呼び出し
/// </summary>
/// <param name="packet"></param>
private void InvokeMethod(SocketyPacket packet)
{
Type t = Parent.GetType();
var method = t.GetMethod(packet.MethodName);
if (method == null)
{
throw new Exception("not found Method");
}
if (packet.PackData != null)
{
Task.Run(() => method.Invoke(Parent, new object[] { packet.PackData }));
}
else
{
Task.Run(() => method.Invoke(Parent, null));
}
}
private MethodInfo GetMethod(SocketyPacket packet)
{
Type t = UserClass.GetType();
if (packet.SocketyPacketType == SocketyPacket.SOCKETY_PAKCET_TYPE.HaertBeat)
{
return(null);
}
var method = t.GetMethod(packet.MethodName);
if (method == null)
{
throw new Exception("not found Method");
}
return(method);
}
public void Start(IPEndPoint localEndPoint, CancellationTokenSource _stoppingCts, T parent, ServerSetting _serverSetting = null, int HeartBeatTimeOut = 2000)
{
Parent = parent;
stoppingCts = _stoppingCts;
serverSetting = _serverSetting;
if (serverSetting == null)
{
serverSetting = new ServerSetting {
UseSSL = false
};
}
SocketySetting.HEART_BEAT_LOST_TIME = HeartBeatTimeOut;
// メイン接続のTCP/IPを作成
MainListener = new TcpListener(localEndPoint.Address, localEndPoint.Port);
MainListener.Start();
Task.Run(async() =>
{
//クライアント接続スレッド
while (!stoppingCts.IsCancellationRequested)
{
try
{
Logger.LogInformation("Waiting for a connection...");
TcpClient handler = await MainListener.AcceptTcpClientAsync();
//接続方法をクライアントに伝える
SendConnectSetting(handler.GetStream(), serverSetting);
Stream CommunicateStream;
SocketyCryptService cryptService = null;
if (serverSetting.UseSSL == true)
{
Logger.LogInformation("UseSSL");
//SSL設定
SslStream sslStream = new SslStream(handler.GetStream());
sslStream.AuthenticateAsServer(serverSetting.Certificate, false, System.Security.Authentication.SslProtocols.Tls12, true);
CommunicateStream = sslStream as Stream;
string SumKey = AES_IV + AES_Key;
var packet = new SocketyPacket()
{
SocketyPacketType = SocketyPacket.SOCKETY_PAKCET_TYPE.KeyExchange, PackData = Encoding.UTF8.GetBytes(AES_IV + AES_Key)
};
var packetData = MessagePackSerializer.Serialize(packet);
//鍵を送る
var packetDataSized = BitConverter.GetBytes(packetData.Length);
CommunicateStream.Write(packetDataSized, 0, packetDataSized.Length);
CommunicateStream.Write(packetData, 0, packetData.Length);
cryptService = new SocketyCryptService(AES_IV, AES_Key);
}
else
{
Logger.LogInformation("NonSSL");
//平文
CommunicateStream = handler.GetStream();
}
//クライアント情報を受信
var clientInfo = ClientInfoReceive(CommunicateStream);
if (ClientInfoManagement(clientInfo) == true)
{
Logger.LogInformation($"ClientInfo ClientID:{clientInfo.ClientID} Name:{clientInfo.Name}");
}
else
{
Logger.LogInformation($"ReConnect ClientInfo ClientID:{clientInfo.ClientID} Name:{clientInfo.Name}");
}
// クライアントが接続したので、受付スレッドを開始する
var clientHub = new ClientHub <T>(_handler: handler,
_stream: CommunicateStream,
_clientInfo: clientInfo,
userClass: Parent,
logger: Logger,
_filters: SocketyFilters,
CryptService: cryptService);
clientHub.ConnectionReset = ConnectionReset;
clientHub.Run();
SocketClient <T> .GetInstance().AddClientHub(clientHub);
}
catch (Exception ex)
{
if (stoppingCts.IsCancellationRequested == true)
{
return;
}
Console.WriteLine(ex.ToString());
}
}
});
}
/// <summary>
/// TCP受信用スレッド
/// </summary>
private void ReceiveProcess()
{
byte[] sizeb = new byte[8];
while (true)
{
if (ThreadCancellationToken.Token.IsCancellationRequested)
{
System.Diagnostics.Debug.WriteLine("ReceiveProcess Kill");
TcpReceiveThreadFinishEvent.Set();
return;
}
try
{
//データサイズ受信
int bytesRec = stream.Read(sizeb, 0, sizeb.Length);
var packetSize = PacketSize.FromBytes(sizeb);
if (packetSize != null && packetSize.Size < SocketySetting.MAX_BUFFER)
{
//データ領域確保
var buffer = new byte[packetSize.Size];
int DataSize = 0;
do
{
if (ThreadCancellationToken.Token.IsCancellationRequested == true)
{
System.Diagnostics.Debug.WriteLine("ReceiveProcess Kill2");
TcpReceiveThreadFinishEvent.Set();
return;
}
if (serverSocket.Connected == false || Connected == false)
{
System.Diagnostics.Debug.WriteLine("Break");
TcpReceiveThreadFinishEvent.Set();
return;
}
else
{
//データ受信
bytesRec = stream.Read(buffer, DataSize, packetSize.Size - DataSize);
DataSize += bytesRec;
}
} while (packetSize.Size > DataSize);
if (bytesRec > 0)
{
SocketyPacket packet = null;
try
{
packet = MessagePackSerializer.Deserialize <SocketyPacket>(buffer);
}
catch
{
System.Diagnostics.Debug.WriteLine("MessagePack Fail");
packet = null;
}
if (packet != null)
{
lock (RecieveSyncEvent)
{
if (packet.SocketyPacketType == SocketyPacket.SOCKETY_PAKCET_TYPE.HaertBeat)
{
ReceiveHeartBeat();
}
else
{
if (string.IsNullOrEmpty(ServerCallMethodName) != true && ServerCallMethodName == packet.MethodName)
{
///サーバのレスポンスを待つタイプの場合は待ちイベントをセットする
ServerResponse = packet.PackData;
RecieveSyncEvent.Set();
}
else
{
///非同期なので、クライアントメソッドを呼ぶ
InvokeMethod(packet);
}
}
}
}
}
else
{
Thread.Sleep(100);
}
}
else
{
Logger.LogError("PacketSize Error");
}
}
catch (IOException ex)
{
Logger.LogInformation(ex.ToString());
}
catch (Exception ex)
{
Logger.LogInformation(ex.ToString());
}
Thread.Sleep(10);
}
}
private byte[] InvokeMethod(MethodInfo method, SocketyPacket packet)
{
byte[] ret = (byte[])method.Invoke(UserClass, new object[] { ClientInfo, packet.PackData });
return(ret);
}
