private void HandleMessage(FramedClient client, long reqId, string messageName, MemoryStream ms)
{
Action <FramedClient, long, MemoryStream> handler;
if (!handlers.TryGetValue(messageName, out handler))
{
throw new Exception(
string.Format(
"Client {0} sent message for method {1}, which has no handler registered",
client.RemoteEndPoint,
messageName));
}
if (options.ActorSessionInjectionEnabled)
{
try
{
CallContext.LogicalSetData(ActorSession.ActorSessionCallContextKey, actorSessions[client]);
handler(client, reqId, ms);
}
finally
{
CallContext.FreeNamedDataSlot(ActorSession.ActorSessionCallContextKey);
}
}
else
{
handler(client, reqId, ms);
}
}
private void HandleClientReceivedData(FramedClient client, ArraySegment <byte> bs)
{
unsafe
{
fixed(byte *b = bs.Array)
{
var s = b + bs.Offset;
var header = *(ActorProtocolFlags *)s;
if (header == ActorProtocolFlags.StacksProtocol)
{
HandleProtocolMessage(client, bs, s);
}
else
{
if (header != ActorProtocolFlags.RequestReponse)
{
throw new Exception("Invalid actor protocol header. Expected request-response");
}
bs = HandleRequestMessage(client, bs, s);
}
}
}
}
protected void HandleResponse <R>(FramedClient client, long reqId, Task <R> actorResponse,
IReplyMessage <R> msgToSend)
{
if (actorResponse == null)
{
Send(client, reqId, msgToSend);
}
else
{
actorResponse.ContinueWith(t =>
{
try
{
msgToSend.SetResult(t.Result);
}
catch (AggregateException exc)
{
msgToSend.SetError(exc.InnerException.Message);
}
catch (Exception exc)
{
msgToSend.SetError(exc.Message);
}
Send(client, reqId, msgToSend);
});
}
}
public void Sending_packet_with_byte_array_should_call_raw_client_with_header_appended()
{
var c = new FramedClient(rawClient.Object);
c.SendPacket(new byte[] { 1, 2, 3 });
rawClient.Verify(r => r.Send(new byte[] { 7, 0, 0, 0, 1, 2, 3 }));
}
public void Sending_packet_with_array_segment_should_call_raw_client_with_header_appended()
{
var c = new FramedClient(rawClient.Object);
c.SendPacket(new ArraySegment <byte>(new byte[] { 0, 0, 5, 0, 0, 0, 54, 1, 2, 3 }, 6, 1));
rawClient.Verify(r => r.Send(new byte[] { 5, 0, 0, 0, 54 }));
}
public Base()
{
rawClientReceived = new Subject <ArraySegment <byte> >();
rawClient = new Mock <IRawByteClient>();
rawClient.Setup(r => r.Received).Returns(rawClientReceived);
framedClient = new FramedClient(rawClient.Object);
serializer = new Mock <IStacksSerializer>();
}
private void HandlePingMessage(FramedClient client, MemoryStream ms)
{
clientTimestamps[client] = DateTime.UtcNow;
var req = serializer.Deserialize <Ping>(ms);
AuxSendProtocolPacket(client, ActorProtocol.PingId,
new Ping
{
Timestamp = req.Timestamp
});
}
private void HandleHandshakeMessage(FramedClient client, MemoryStream ms)
{
var req = serializer.Deserialize <HandshakeRequest>(ms);
AuxSendProtocolPacket(client, ActorProtocol.HandshakeId,
new HandshakeResponse
{
RequestedProtocolVersion = req.ClientProtocolVersion,
ServerProtocolVersion = ActorProtocol.Version,
ProtocolMatch = req.ClientProtocolVersion == ActorProtocol.Version
});
}
private unsafe ArraySegment <byte> HandleRequestMessage(FramedClient client, ArraySegment <byte> bs, byte *s)
{
var reqId = *(long *)(s + 4);
var msgNameLength = *(int *)(s + 12);
var msgName = new string((sbyte *)s, 16, msgNameLength);
var pOffset = 16 + msgNameLength;
using (var ms = new MemoryStream(bs.Array, bs.Offset + pOffset, bs.Count - pOffset))
{
HandleMessage(client, reqId, msgName, ms);
}
return(bs);
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
client?.Dispose();
client = null;
}
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
public void Sending_preformatted_packet_should_not_add_additional_header()
{
var c = new FramedClient(rawClient.Object);
var data = new byte[] { 1, 2, 3, 4, 5, 6, 7 };
var buffer = c.PreparePacketBuffer(7);
Buffer.BlockCopy(data, 0, buffer.Packet.Array, buffer.Packet.Offset, data.Length);
c.SendPacket(buffer);
rawClient.Verify(r => r.Send(new byte[] { 11, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7 }));
Assert.Equal(11, buffer.Packet.Array.Length);
Assert.Equal(7, buffer.Packet.Count);
}
static void Main(string[] args)
{
ServerHelpers.CreateServerAndConnectedClient(out s, out c1, out c2);
c1.Disconnected.Subscribe(exn => { Console.WriteLine("C1 d/c " + exn); });
c2.Disconnected.Subscribe(exn => { Console.WriteLine("C2 d/c " + exn); });
fc1 = new FramedClient(c1);
fc2 = new FramedClient(c2);
Measure(8192, 8192);
Console.ReadLine();
Measure(8192, 8192 * 16);
Console.ReadLine();
}
private unsafe void HandleProtocolMessage(FramedClient client, ArraySegment <byte> bs, byte *s)
{
var pid = *(int *)(s + 4);
Action <FramedClient, MemoryStream> handler;
var hasHandler = protocolHandlers.TryGetValue(pid, out handler);
if (!hasHandler)
{
throw new Exception("Invalid actor protocol header.");
}
using (var ms = new MemoryStream(bs.Array, bs.Offset + 8, bs.Count - 8))
{
handler(client, ms);
}
}
private unsafe void AuxSendProtocolPacket <P>(FramedClient client, int packetId, P packet)
{
using (var ms = new MemoryStream())
{
ms.SetLength(8);
ms.Position = 8;
serializer.Serialize(packet, ms);
ms.Position = 0;
var buffer = ms.GetBuffer();
fixed(byte *buf = buffer)
{
*(ActorProtocolFlags *)buf = ActorProtocolFlags.StacksProtocol;
*(int *)(buf + 4) = packetId;
}
client.SendPacket(new ArraySegment <byte>(buffer, 0, (int)ms.Length));
}
}
private unsafe void Send <R>(FramedClient client, long requestId, IReplyMessage <R> packet)
{
using (var ms = new MemoryStream())
{
ms.SetLength(12);
ms.Position = 12;
serializer.Serialize(packet, ms);
ms.Position = 0;
var buffer = ms.GetBuffer();
fixed(byte *buf = buffer)
{
*(ActorProtocolFlags *)buf = ActorProtocolFlags.RequestReponse;
*(long *)(buf + 4) = requestId;
}
client.SendPacket(new ArraySegment <byte>(buffer, 0, (int)ms.Length));
}
}
protected void ReceiveBytesSegmentsAndAssertPackets(Action <int, ArraySegment <byte> > recvAsserts,
IEnumerable <ArraySegment <byte> > recvBytes)
{
int idx = 0;
var bytesRecv = new Subject <ArraySegment <byte> >();
rawClient.Setup(s => s.Received).Returns(bytesRecv);
var c = new FramedClient(rawClient.Object);
c.Received.Subscribe(bs =>
{
recvAsserts(idx++, bs);
});
foreach (var recv in recvBytes)
{
bytesRecv.OnNext(recv);
}
}
protected void ReceiveBytesAndAssertPacket(Action <ArraySegment <byte> > recvAsserts,
ArraySegment <byte> recvBytes)
{
bool called = false;
var bytesRecv = new Subject <ArraySegment <byte> >();
rawClient.Setup(s => s.Received).Returns(bytesRecv);
var c = new FramedClient(rawClient.Object);
c.Received.Subscribe(bs =>
{
called = true;
recvAsserts(bs);
});
bytesRecv.OnNext(recvBytes);
Assert.True(called);
}
public async void Client_should_be_disconnected_after_over_30_seconds_after_last_ping()
{
var disconnected = new ManualResetEventSlim();
server = ActorServerProxy.Create <TestActor>("tcp://*:0");
int port = server.BindEndPoint.Port;
client = new FramedClient(new SocketClient());
await client.Connect("tcp://localhost:" + port);
client.Received.Subscribe(x => Console.WriteLine("Received " + x.Count + " bytes. " +
"Header: " + BitConverter.ToInt32(x.Array, x.Offset) + " " +
"Id: " + BitConverter.ToInt32(x.Array, x.Offset + 4)));
client.Disconnected.Subscribe(_ => disconnected.Set());
SendHandshake();
SendPing();
Thread.Sleep(40000);
Assert.False(disconnected.IsSet);
disconnected.Wait(40000);
Assert.True(disconnected.IsSet);
}
private void ClientConnected(SocketClient socketClient)
{
if (isStopped)
{
return;
}
var client = new FramedClient(socketClient);
client.Disconnected.Subscribe(exn =>
{
Exception clientError;
clientErrors.TryGetValue(client, out clientError);
clients.Remove(client);
clientTimestamps.Remove(client);
clientErrors.Remove(client);
IActorSession isession;
if (actorSessions.TryGetValue(client, out isession))
{
actorSessions.Remove(client);
try
{
clientActorDisconnected.OnNext(
new ClientActorDisconnectedData(
isession,
clientError ?? exn));
}
catch
{
}
}
});
client.Received.Subscribe(bs =>
{
try
{
HandleClientReceivedData(client, bs);
}
catch (Exception exn)
{
clientErrors[client] = exn;
client.Close();
}
});
clients.Add(client);
clientTimestamps[client] = DateTime.UtcNow;
var session = new ActorSession(client);
actorSessions[client] = session;
try
{
clientActorConnected.OnNext(session);
}
catch
{
}
}
