private void AnalyzeReceiveData(ShareClientData receiveData, Action <byte[]> reciever)
{
if (receiveData.Header.DataType == SendDataType.Close)
{
_Manager.Logger.Info("Request Close.");
Close();
}
else if (receiveData.Header.DataType == SendDataType.System)
{
_Manager.Logger.Info("Recive System Data.");
RecieveSystemData(receiveData);
}
else
{
try
{
if (receiveData.Header.SplitCount == 1)
{
reciever.Invoke(receiveData.DataPart);
}
else
{
ConnectReceiveData(receiveData, reciever);
}
}
catch (Exception ex)
{
var re = new ReceiveDataAnalyzeException(receiveData, "Fail Analyze ReceiveData.", ex);
_Manager.Logger.Error(re.Message, re);
throw re;
}
}
}
public ConnectAlgorithm(ShareClientData baseData)
{
spritCount = baseData.Header.SplitCount;
buffer = new ShareClientData[spritCount];
buffer[baseData.Header.SplitIndex] = baseData;
minCode = baseData.Header.AtomicCode - baseData.Header.SplitIndex;
maxCode = baseData.Header.AtomicCode + ((spritCount - 1) - baseData.Header.SplitIndex);
}
public bool AddMember(ShareClientData value)
{
if (maxCode < value.Header.AtomicCode || minCode >= value.Header.AtomicCode || IsComplete)
{
return(false);
}
buffer[value.Header.SplitIndex] = value;
count++;
return(true);
}
private void Send(IConnectionSocket socket, IPEndPoint remoteEndPoint, ShareClientData shareClientData)
{
try
{
socket.Send(remoteEndPoint, shareClientData.ToByte());
}
catch (Exception ex)
{
Throw(remoteEndPoint, $"Fail Send. {ex.Message}", ex);
}
_Logger.Send(remoteEndPoint, shareClientData.ToByte());
}
private async Task ReceiveData(Action <byte[]> reciever)
{
var ReceiveData = await _Socket.ReceiveAsync();
if (ReceiveData != null && ReceiveData.Length > 0)
{
var clientData = ShareClientData.FromBytes(ReceiveData);
if (clientData != null)
{
_Manager.SetRecieveDataSize(clientData.Size);
AnalyzeReceiveData(clientData, reciever);
}
}
}
protected void SendShareClientData(ShareClientData clientData)
{
if (stopApplicationData && clientData.Header.DataType == SendDataType.Application)
{
_Manager.Logger.Info($"Stop Application or ShareClientData Convert Fail or Type {clientData.Header.DataType}");
return;
}
var sendData = clientData.ToByte();
if (!_Manager.PreSendDataSize(sendData.Length))
{
_Manager.Logger.Info($"Dont't Allow Size of Send Byte : {sendData.Length}");
return;
}
int count = 0;
while (_Socket.IsOpen)
{
try
{
_Socket.Send(sendData);
Thread.Sleep(1);
break;
}
catch (Exception ex)
{
_Manager.Logger.Error($"Sokect Send Throw Exception, Socket IsOpen : {_Socket.IsOpen}", ex);
if (_Socket.IsOpen)
{
_Manager.Logger.Error($"Exception Throw Count : {count + 1 }, RetryCount: {_Manager.RetryCount}", ex);
if (++count > _Manager.RetryCount || _Manager.HandleException(ex))
{
var se = new ShareClientException(clientData.Header, ex.Message, ex);
_Manager.Logger.Error($"Throw Exception.", se);
throw se;
}
}
}
}
}
private Connection AcceptInternal(IConnectionSocket socket)
{
var recieveData = Recive(socket);
var recieveConnectionData = ShareClientData.FromBytes(recieveData.RecieveBytes);
if (recieveConnectionData == null)
{
_Logger.Info($"ShareClientData Convert Fail.");
return(null);
}
else if (recieveConnectionData.Header.DataType != SendDataType.System)
{
_Logger.Info($"ShareClientData Type {recieveConnectionData?.Header.DataType}.");
return(null);
}
var connectionData = ConnectionData.FromByte(recieveConnectionData.DataPart);
if (connectionData == null)
{
_Logger.Info($"ConnectionData Convert Fail.");
return(null);
}
var remoteEndPoint = recieveData.ReciveEndPoint;
var connectionResponse = _AcceptRequest.Invoke(remoteEndPoint, connectionData);
_Logger.Info($"AcceptRequest is {connectionResponse.IsConnect}.");
var responseData = new ShareClientData(ShareClientHeader.CreateSystem((uint)connectionResponse.Size), connectionResponse.ToByte());
Send(socket, remoteEndPoint, responseData);
Connection connection = null;
if (connectionResponse.IsConnect)
{
_Logger.Info($"Accept Succes.");
connection = new Connection(connectionResponse.ConnectionData.CleintSpec, socket.LocalEndPoint, remoteEndPoint);
}
return(connection);
}
private Connection ConnectInternal(IConnectionSocket socket, IPEndPoint connectEndPoint, ConnectionData connectionData)
{
_Logger.Info($"Start Connect. -> {connectEndPoint}");
var sendData = new ShareClientData(ShareClientHeader.CreateSystem((uint)connectionData.Size), connectionData.ToByte());
Send(socket, connectEndPoint, sendData);
var recieveData = Recive(socket);
var responseData = ShareClientData.FromBytes(recieveData.RecieveBytes);
if (responseData == null)
{
_Logger.Info($"ShareClientData Convert Fail.");
return(null);
}
else if (responseData.Header.DataType != SendDataType.System)
{
_Logger.Info($"ShareClientData Type is {responseData.Header.DataType}.");
return(null);
}
var connectionResponse = ConnectionResponse.FromByte(responseData.DataPart);
if (connectionResponse == null)
{
_Logger.Info($"Response DataPart is Nothing.");
return(null);
}
_ConnectResponse.Invoke(connectionResponse);
if (!connectionResponse.IsConnect)
{
_Logger.Info($"Reject Connect. -> {connectEndPoint}");
return(null);
}
_Logger.Info($"Succes Connect. -> {connectEndPoint}");
return(new Connection(connectionResponse.ConnectionData.CleintSpec, socket.LocalEndPoint, connectEndPoint));
}
private void ConnectReceiveData(ShareClientData receiveData, Action <byte[]> reciever)
{
for (var node = _SplitBuffer.First; node != null; node = node.Next)
{
var connect = node.Value;
if (connect.AddMember(receiveData))
{
if (connect.IsComplete)
{
reciever.Invoke(connect.GetConnectData());
_SplitBuffer.Remove(node);
}
return;
}
}
_SplitBuffer.AddLast(InternalConnectAlgorithm.Create(receiveData));
if (_SplitBuffer.Count > _ClientSpec.SplitBufferSize)
{
_SplitBuffer.RemoveFirst();
}
}
protected virtual void RecieveSystemData(ShareClientData receiveData)
{
//
}
public static IConnectAlgorithm Create(ShareClientData baseData)
{
return(new ConnectAlgorithm(baseData));
}
public ReceiveDataAnalyzeException(ShareClientData clientData, string msg, Exception inner) : base(clientData?.Header, msg, inner)
{
ClientData = clientData;
}
