public DynamicEndpoint(dynamic client)
{
this.client = client;
ITransportationLayer transport = client;
transport.ConnectionEstablished += () => ConnectionEstablished?.Invoke();
transport.ConnectionLost += () => ConnectionLost?.Invoke();
transport.ProviderDataReady += data => ProviderDataReady?.Invoke(data);
}
private void BeginReadAsync()
{
var token = cancellationTokenSource.Token;
async void StartRead()
{
while (online)
{
WebSocketReceiveResult result = null;
try
{
Log("awaiting new data");
result = await WsClient.ReceiveAsync(new ArraySegment <byte>(receiveBuffer), cancellationTokenSource.Token);
Log("new data coming");
}
catch (Exception e)
{
Log($"exception thrown when awaiting new data {e.Message}");
CloseAndRaise();
return;
}
if (result.MessageType == WebSocketMessageType.Close)
{
Log($"message type is [Close]");
CloseAndRaise();
}
else
{
using (MemoryStream stream = new MemoryStream())
{
stream.Write(receiveBuffer, 0, result.Count);
stream.Seek(0, SeekOrigin.Begin);
Log($"passing data to upstream processor");
ProviderDataReady?.Invoke(stream);
Log($"passing data to upstream processor, done");
}
}
}
Log($"read thread exiting, since it is not connected");
}
StartRead();
}
protected void BeginReadAsync()
{
var token = cancellationTokenSource.Token;
async void StartRead()
{
while (online)
{
int nRead = 0;
try
{
Log("awaiting new data");
nRead = await DataStream.ReadAsync(receiveBuffer, 0, bufferSize, cancellationTokenSource.Token);
Log("new data coming");
}
catch (Exception e)
{
Log($"exception thrown when awaiting new data {e.Message}");
CloseAndRaise();
return;
}
if (nRead == 0)
{
Log($"read 0 bytes");
CloseAndRaise();
}
else
{
using (MemoryStream stream = new MemoryStream())
{
stream.Write(receiveBuffer, 0, nRead);
stream.Seek(0, SeekOrigin.Begin);
Log($"passing data to upstream processor");
ProviderDataReady?.Invoke(stream);
Log($"passing data to upstream processor, done");
}
}
}
Log($"read thread exiting, since it is not connected");
}
StartRead();
}
public void Receive(Stream data)
{
if (packetLength == 0)
{
data.Read(lengthBuffer, 0, 4);
packetLength = BitConverter.ToInt32(lengthBuffer, 0);
Log($"new data: packet length = {packetLength}", "DS");
if (packetLength > bufferSize)
{
Log($"DataIntegrityError: packet length = {packetLength}", "DS", LogType.ERROR);
DataIntegrityError?.Invoke(new DataIntegrityError("receive buffer overflow"));
return;
}
if (packetLength <= 0)
{
Log($"DataIntegrityError: packet length = {packetLength}", "DS", LogType.ERROR);
DataIntegrityError?.Invoke(new DataIntegrityError("non-positive packet length"));
return;
}
}
if (bufferPointer < packetLength)
{
int dataLength = data.Read(receiveBuffer, bufferPointer, packetLength - bufferPointer);
bufferPointer += dataLength;
Log($"buffering data: packet length = {packetLength}, bufferPointer = {bufferPointer}", "DS");
}
if (bufferPointer == packetLength)
{
using (MemoryStream copy = new MemoryStream(receiveBuffer, 0, bufferPointer))
{
ClearBuffer();
object obj = null;
try
{
Log($"consuming data ...", "DS");
obj = formatter.Deserialize(copy);
}
catch
{
Log($"DataIntegrityError: non-serializable data", "DS", LogType.ERROR);
DataIntegrityError?.Invoke(
new DataIntegrityError("received non-serializable data"));
ClearBuffer();
return;
}
if (!(obj is AbstractProtocol))
{
Log($"DataIntegrityError: data is not [AbstractProtocol]", "DS", LogType.ERROR);
DataSymmetricityError?.Invoke(
new DataSymmetricityError("received data is not [AbstractProtocol]"));
ClearBuffer();
return;
}
ProviderDataReady?.Invoke((AbstractProtocol)obj);
copy.Close();
}
}
if (data.Position < data.Length)
{
Log($"data is too large, position = {data.Position}, size = {data.Length}", "DS");
Receive(data);
}
}
