public ReactiveMessageReceiverCreator(IMessageIdCache messageIdCache,
IStacksSerializer packetSerializer, ReactiveClientModelBuilder <T> mb)
{
this.messageIdCache = messageIdCache;
this.packetSerializer = packetSerializer;
this.mb = mb;
}
public MessageClient(IFramedClient framedClient,
IStacksSerializer packetSerializer,
IMessageHandler messageHandler)
: this(new MessageIdCache(),
framedClient, packetSerializer, messageHandler)
{
}
public ActorServerProxyTemplate(T actorImplementation, IPEndPoint bindEndPoint, ActorServerProxyOptions options)
{
isStopped = false;
executor = new ActionBlockExecutor();
serializer = new ProtoBufStacksSerializer();
clients = new List <FramedClient>();
handlers = new Dictionary <string, Action <FramedClient, long, MemoryStream> >();
actorSessions = new Dictionary <IFramedClient, IActorSession>();
obsHandlers = new Dictionary <string, object>();
this.actorImplementation = actorImplementation;
this.options = options;
clientActorConnected = new Subject <IActorSession>();
clientActorDisconnected = new Subject <ClientActorDisconnectedData>();
clientTimestamps = new Dictionary <FramedClient, DateTime>();
clientErrors = new Dictionary <FramedClient, Exception>();
pingTimer = new Timer(OnPingTimer, null, 10000, 10000);
protocolHandlers = new Dictionary <int, Action <FramedClient, MemoryStream> >();
protocolHandlers[ActorProtocol.HandshakeId] = HandleHandshakeMessage;
protocolHandlers[ActorProtocol.PingId] = HandlePingMessage;
server = new SocketServer(executor, bindEndPoint);
server.Connected.Subscribe(ClientConnected);
server.Start();
}
public MessageClientBase(IFramedClient client, IMessageIdCache messageIdCache,
IStacksSerializer packetSerializer)
{
this.framedClient = client;
this.messageIdCache = messageIdCache;
this.packetSerializer = packetSerializer;
}
public MessageClient(IFramedClient framedClient,
IStacksSerializer packetSerializer,
IMessageHandler messageHandler)
: this(new MessageIdCache(),
framedClient, packetSerializer, messageHandler)
{
}
public MessageClient(IFramedClient framedClient,
IStacksSerializer packetSerializer,
IMessageHandler messageHandler,
Func <MessageIdRegistration, MessageIdRegistration> registration)
: this(registration(new MessageIdRegistration()).CreateCache(),
framedClient, packetSerializer, messageHandler)
{
}
public MessageClient(IFramedClient framedClient,
IStacksSerializer packetSerializer,
IMessageHandler messageHandler,
Func<MessageIdRegistration, MessageIdRegistration> registration)
: this(registration(new MessageIdRegistration()).CreateCache(),
framedClient, packetSerializer, messageHandler)
{
}
private MessageClient(IMessageIdCache messageIdCache,
IFramedClient framedClient,
IStacksSerializer packetSerializer,
IMessageHandler messageHandler)
: base(framedClient, messageIdCache, packetSerializer)
{
this.packetSerializationHandler = new StacksSerializationHandler(
messageIdCache,
this,
packetSerializer,
messageHandler);
this.framedClient.Received.Subscribe(PacketReceived);
}
private MessageClient(IMessageIdCache messageIdCache,
IFramedClient framedClient,
IStacksSerializer packetSerializer,
IMessageHandler messageHandler)
: base(framedClient, messageIdCache, packetSerializer)
{
this.packetSerializationHandler = new StacksSerializationHandler(
messageIdCache,
this,
packetSerializer,
messageHandler);
this.framedClient.Received.Subscribe(PacketReceived);
}
public ActorRemoteMessageClient(IFramedClient client)
{
framedClient = client;
packetSerializer = new ProtoBufStacksSerializer();
framedClient.Received.Subscribe(PacketReceived);
framedClient.Connected.Subscribe(OnConnected);
framedClient.Disconnected.Subscribe(OnDisconnected);
handshakeCompleted = new AsyncSubject <Unit>();
disconnectedSubject = new AsyncSubject <Exception>();
protocolHandlers = new Dictionary <int, Action <IntPtr, MemoryStream> >();
protocolHandlers[Proto.ActorProtocol.HandshakeId] = HandleHandshakeMessage;
protocolHandlers[Proto.ActorProtocol.PingId] = HandlePingMessage;
pingTimer = new Timer(OnPingTimer, null, Timeout.Infinite, Timeout.Infinite);
}
public ActorClientProxyTemplate(IPEndPoint endPoint)
{
this.endPoint = endPoint;
this.disconnected = false;
this.disconnectedSubject = new AsyncSubject <Exception>();
serializer = new ProtoBufStacksSerializer();
replyHandlersByRequest = new Dictionary <long, Action <MemoryStream, Exception> >();
obsHandlers = new Dictionary <string, Action <MemoryStream> >();
exec = new ActionBlockExecutor();
exec.Error += ExecutionError;
client = new ActorRemoteMessageClient(
new FramedClient(
new SocketClient(exec)));
client.MessageReceived += MessageReceived;
client.ObsMessageReceived += ObsMessageReceived;
client.Disconnected.Subscribe(HandleDisconnection);
}
public StacksSerializationHandler(
IMessageIdCache messageIdCache,
IMessageClient client,
IStacksSerializer serializer,
IMessageHandler messageHandler)
{
Ensure.IsNotNull(messageIdCache, "messageIdCache");
Ensure.IsNotNull(client, "client");
Ensure.IsNotNull(serializer, "serializer");
Ensure.IsNotNull(messageHandler, "messageHandler");
this.messageIdCache = messageIdCache;
this.client = client;
this.serializerHandlerByMessageId = new Dictionary <int, Action <MemoryStream> >();
this.messageHandler = messageHandler;
this.serializer = serializer;
this.serializer.Initialize();
ParseMessageHandler();
}
public ReactiveMessageClient(IFramedClient framedClient,
IStacksSerializer packetSerializer,
Action <ReactiveClientModelBuilder <T> > modelBuilder)
: base(framedClient, new MessageIdCache(), packetSerializer)
{
Ensure.IsNotNull(framedClient, "framedClient");
Ensure.IsNotNull(packetSerializer, "packetSerializer");
var mb = new ReactiveClientModelBuilder <T>();
if (modelBuilder != null)
{
modelBuilder(mb);
}
this.messageReceiverCreator = new ReactiveMessageReceiverCreator <T>(base.messageIdCache, packetSerializer, mb);
this.Packets = this.messageReceiverCreator.CreateReceiverImplementation(out deserializeByMessageId);
this.framedClient.Received.Subscribe(PacketReceived);
}
public TimeoutTests()
{
serializer = new ProtoBufStacksSerializer();
}
public ReactiveMessageClient(IFramedClient framedClient,
IStacksSerializer packetSerializer)
: this(framedClient, packetSerializer, null)
{
}
public TimeoutTests()
{
serializer = new ProtoBufStacksSerializer();
}
