public void QueueTooManyClients() { var queue = new ConcurrentQueue <ClientConnection>(); var socket = new MockSocket(); var client0 = new ClientConnection(socket, ClientId.Next(), 100); var client1 = new ClientConnection(socket, ClientId.Next(), 100); var client2 = new ClientConnection(socket, ClientId.Next(), 100); var client3 = new ClientConnection(socket, ClientId.Next(), 100); socket.ExpectConnected(() => true); socket.ExpectSend(data => { Console.WriteLine(BitConverter.ToString(data.ToArray())); Console.WriteLine(BitConverter.ToString(MessageCreationHelper.NoMoreSpaceForClientsMessage)); Assert.Equal(MessageCreationHelper.NoMoreSpaceForClientsMessage, data.ToArray()); return(data.Length); }); socket.ExpectClose(); var dispatcher = new Dispatcher(queue, 3, BoundedInbox.Create(), new BoundedInbox[64], BoundedInbox.Create()); queue.Enqueue(client0); queue.Enqueue(client1); queue.Enqueue(client2); queue.Enqueue(client3); dispatcher.DequeueNewClients(); socket.ExpectAllDone(); }
public void RemoveDeadClients() { var queue = new ConcurrentQueue <ClientConnection>(); var socket = new MockSocket(); var client = new ClientConnection(socket, ClientId.Next(), 100); // First normal loop socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Second loop where client is disconnected and therefore deleted socket.ExpectConnected(() => false); // No actions for the third loop which should be empty var dispatcher = new Dispatcher(queue, 3, BoundedInbox.Create(), new BoundedInbox[64], BoundedInbox.Create()); queue.Enqueue(client); dispatcher.DequeueNewClients(); // Normal listen (nothing happens though) dispatcher.ListenToConnections(); // Client is disconnected dispatcher.ListenToConnections(); // Empty loop dispatcher.ListenToConnections(); socket.ExpectAllDone(); }
public void TestOpenFirstBlock() { _controller = new ControllerThread(_chain, default(OptimizedLineage), _inbox = BoundedInbox.Create(), _outbox = BoundedInbox.Create()); var messageAllocation = new Span <byte>(new byte[OpenBlock.SizeInBytes]); var openBlock = new OpenBlock(1, 5, BlockAlias.GenesisParent); // Serialize message to put it into the inbox MessageSerializers.ClientSerializeOpenBlock(openBlock, messageAllocation); _inbox.TryWrite(messageAllocation); _controller.DoWork(); var result = _outbox.Peek(); Assert.Equal(MessageType.OpenedBlock, ClientServerMessage.GetMessageType(result)); var response = MessageSerializers.ClientDeserializeOpenedBlock(result); Assert.Equal(1U, response.RequestId); Assert.Equal(5U, response.ClientId); Assert.Equal(_1, response.Alias); var tmpId = response.UncommittedBlockId; Console.WriteLine(tmpId); }
public void Setup() { var sharedInboxDispatcherController = BoundedInbox.Create(); var sharedOutboxDispatcherController = BoundedInbox.Create(); var clientQueue = new ConcurrentQueue <ClientConnection>(); _dispatcher = new Dispatcher(clientQueue, 3, sharedOutboxDispatcherController, new BoundedInbox[4], sharedInboxDispatcherController); _chain = new SimpleBlockchain(); _controllerThread = new ControllerThread(_chain, default(OptimizedLineage), sharedInboxDispatcherController, sharedOutboxDispatcherController); _clientConn = new ClientConnection(_socket, ClientId.Next(), ClientServerMessage.MaxSizeInBytes); clientQueue.Enqueue(_clientConn); _dispatcher.DequeueNewClients(); // TODO there should really be three threads, one for each component. However, I do not know how to test this. }
public void Setup() { var id = _chain.OpenFirstBlock().Alias; _chain.CommitBlock(id, BlockId.Genesis); id = _chain.OpenBlock(_1).Alias; _chain.CommitBlock(id, new BlockId(new Hash256(0x11111111UL, 0x22222222UL, 0x33333333UL, 0x44444444UL))); id = _chain.OpenBlock(_2).Alias; _chain.CommitBlock(id, new BlockId(new Hash256(0xFFFFFFFFUL, 0xEEEEEEEEUL, 0xDDDDDDDDUL, 0xCCCCCCCCUL))); // Second child for block 2 id = _chain.OpenBlock(_2).Alias; _chain.CommitBlock(id, new BlockId(new Hash256(0x1111111122UL, 0x2222222233UL, 0x3333333344UL, 0x4444444455UL))); // main chain prolonged id = _chain.OpenBlock(_3).Alias; _chain.CommitBlock(id, new BlockId(new Hash256(0x1111111122UL, 0x2222222233UL, 0x3333333344UL, 0x4444444455UL))); // side chain prolonged id = _chain.OpenBlock(_4).Alias; _chain.CommitBlock(id, new BlockId(new Hash256(0x1111111122UL, 0x2222222233UL, 0x3333333344UL, 0x4444444455UL))); // fork on end of main chain id = _chain.OpenBlock(_5).Alias; _chain.CommitBlock(id, new BlockId(new Hash256(0x1111111122UL, 0x2222222233UL, 0x3333333344UL, 0x4444444455UL))); id = _chain.OpenBlock(_5).Alias; _chain.CommitBlock(id, new BlockId(new Hash256(0x1111111122UL, 0x2222222233UL, 0x3333333344UL, 0x4444444455UL))); var chainStrategy = new BlockchainStrategies(); var opti = new OptimizedLineage(chainStrategy.GetQuasiOrphans(_chain), _2); _controller = new ControllerThread(_chain, opti, _inbox = BoundedInbox.Create(), _outbox = BoundedInbox.Create()); }
public void SixtyFourInboxes() { new Dispatcher(new ConcurrentQueue <ClientConnection>(), 3, BoundedInbox.Create(), new BoundedInbox[64], BoundedInbox.Create()); }
public void ReadMultipleMessagesFromClient() { var queue = new ConcurrentQueue <ClientConnection>(); var socket = new MockSocket(); var client1 = new ClientConnection(socket, ClientId.Next(), 100); var client2 = new ClientConnection(socket, ClientId.Next(), 100); var dispatcher = new Dispatcher(queue, 3, BoundedInbox.Create(), new BoundedInbox[2], BoundedInbox.Create()); // Client1 messages socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 600); socket.ExpectReceive(data => { data.Clear(); // Three messages, of sizes 200, 300 and 100 BitConverter.GetBytes(200).CopyTo(data); BitConverter.GetBytes(300).CopyTo(data.Slice(200)); BitConverter.GetBytes(100).CopyTo(data.Slice(500)); return(600); }); // Reading second message socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Reading third message socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Exiting loop socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Client2 messages socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 100); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(70).CopyTo(data); BitConverter.GetBytes(30).CopyTo(data.Slice(70)); return(100); }); // Reading second message socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Exiting loop socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Some more messages for Client1 socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 60); socket.ExpectReceive(data => { data.Clear(); // Two messages, of sizes 10 and 40 BitConverter.GetBytes(25).CopyTo(data); BitConverter.GetBytes(35).CopyTo(data.Slice(25)); return(60); }); // Reading second message socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Exiting loop socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // No more messages for Client2 socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); queue.Enqueue(client1); queue.Enqueue(client2); dispatcher.DequeueNewClients(); // Client1 reading 3 messages, Client2 two dispatcher.ListenToConnections(); // Client1 reading 2 more messages, Client2 none dispatcher.ListenToConnections(); socket.ExpectAllDone(); }
public void SendAnswers() { var queue = new ConcurrentQueue <ClientConnection>(); var socket = new MockSocket(); var outbox = BoundedInbox.Create(); var client1 = new ClientConnection(socket, ClientId.Next(), 100); var client2 = new ClientConnection(socket, ClientId.Next(), 100); queue.Enqueue(client1); queue.Enqueue(client2); var dispatcher = new Dispatcher(queue, 3, outbox, new BoundedInbox[2], BoundedInbox.Create()); // Try sending message to one client, doesn't succeed socket.ExpectConnected(() => true); socket.ExpectSend(data => 0); // Try sending message to the other client, doesn't succeed socket.ExpectConnected(() => true); socket.ExpectSend(data => 0); // Try sending message to first client, socket gets closed socket.ExpectConnected(() => true); socket.ExpectClose(); // Try sending message to second client, socket gets closed socket.ExpectConnected(() => true); socket.ExpectClose(); var firstMessage = new byte[100]; BitConverter.GetBytes(100).CopyTo(new Span <byte>(firstMessage)); client2.ConnectionId.WriteTo( // send back to client2 firstMessage.AsSpan(ClientServerMessage.ClientIdStart, ClientServerMessage.ClientIdSizeInBytes)); var secondMessage = new byte[100]; BitConverter.GetBytes(100).CopyTo(new Span <byte>(secondMessage)); client1.ConnectionId.WriteTo( // send back to client1 secondMessage.AsSpan(ClientServerMessage.ClientIdStart, ClientServerMessage.ClientIdSizeInBytes)); var thirdMessage = new byte[50]; BitConverter.GetBytes(50).CopyTo(new Span <byte>(thirdMessage)); client1.ConnectionId.WriteTo( // send back to client1 thirdMessage.AsSpan(ClientServerMessage.ClientIdStart, ClientServerMessage.ClientIdSizeInBytes)); var fourthMessage = new byte[50]; BitConverter.GetBytes(50).CopyTo(new Span <byte>(fourthMessage)); client2.ConnectionId.WriteTo( // send back to client2 fourthMessage.AsSpan(ClientServerMessage.ClientIdStart, ClientServerMessage.ClientIdSizeInBytes)); // Write messages into dispatcher buffer for both clients Assert.True(outbox.TryWrite(firstMessage)); Assert.True(outbox.TryWrite(secondMessage)); dispatcher.DequeueNewClients(); // Try sending the answers, fails dispatcher.SendResponses(); Assert.True(outbox.TryWrite(thirdMessage)); Assert.True(outbox.TryWrite(fourthMessage)); dispatcher.SendResponses(); socket.ExpectAllDone(); }
public void ZeroInboxes() { Assert.Throws <ArgumentException>(() => new Dispatcher(new ConcurrentQueue <ClientConnection>(), 3, BoundedInbox.Create(), new BoundedInbox[0], BoundedInbox.Create())); }
public void FillShardedInboxes() { var queue = new ConcurrentQueue <ClientConnection>(); var socket = new MockSocket(); var client1 = new ClientConnection(socket, ClientId.Next(), 100); var client2 = new ClientConnection(socket, ClientId.Next(), 100); BoundedInbox[] threadInboxes = { BoundedInbox.Create(), BoundedInbox.Create() }; var dispatcher = new Dispatcher(queue, 3, BoundedInbox.Create(), threadInboxes, BoundedInbox.Create()); // Client1 sharded message socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => LargeMessageSize); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(LargeMessageSize).CopyTo(data); data[ClientServerMessage.ShardedIndStart] = 0xFF; // 0xFF: all bits set to one, so "sharded" is set to 1 for sure data[ClientServerMessage.PayloadStart] = 0x01; return(LargeMessageSize); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Client2 sharded message socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => LargeMessageSize); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(LargeMessageSize).CopyTo(data); data[12] = 0xFF; return(LargeMessageSize); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Client1 sharded message, fills up first sharded inbox socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => LargeMessageSize); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(LargeMessageSize).CopyTo(data); data[ClientServerMessage.ShardedIndStart] = 0xFF; // 0xFF: all bits set to one, so "sharded" is set to 1 for sure data[ClientServerMessage.PayloadStart] = 0x00; return(LargeMessageSize); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Client2 sharded message, fills up second sharded inbox socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => LargeMessageSize); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(LargeMessageSize).CopyTo(data); data[ClientServerMessage.ShardedIndStart] = 0xFF; // 0xFF: all bits set to one, so "sharded" is set to 1 for sure data[ClientServerMessage.PayloadStart] = 0x01; return(LargeMessageSize); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Read and get error message server busy writing into second sharded inbox socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 20); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(20).CopyTo(data); data[ClientServerMessage.ShardedIndStart] = 0xFF; data[ClientServerMessage.PayloadStart] = 0x01; return(20); }); socket.ExpectConnected(() => true); socket.ExpectSend(data => { Assert.Equal(ClientServerMessage.PayloadStart, data.Length); Assert.Equal(data[13], (byte)MessageType.ServerBusy); return(ClientServerMessage.PayloadStart); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Read and get error message server busy writing into first sharded inbox socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 20); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(20).CopyTo(data); data[ClientServerMessage.ShardedIndStart] = 0xFF; // 0xFF: all bits set to one, so "sharded" is set to 1 for sure data[ClientServerMessage.PayloadStart] = 0x00; return(20); }); socket.ExpectConnected(() => true); socket.ExpectSend(data => { Assert.Equal(ClientServerMessage.PayloadStart, data.Length); Assert.Equal(MessageType.ServerBusy, ClientServerMessage.GetMessageType(data)); return(ClientServerMessage.PayloadStart); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); queue.Enqueue(client1); queue.Enqueue(client2); dispatcher.DequeueNewClients(); // Client1 into sharded inbox 1, Client2 into sharded inbox 2 dispatcher.ListenToConnections(); // Client1 filling up sharded inbox 2, Client2 filling up sharded inbox 1 dispatcher.ListenToConnections(); // Errors when trying to write into any inbox dispatcher.ListenToConnections(); socket.ExpectAllDone(); }
public void FillControllerInbox() { var queue = new ConcurrentQueue <ClientConnection>(); var socket = new MockSocket(); var client1 = new ClientConnection(socket, ClientId.Next(), 100); var client2 = new ClientConnection(socket, ClientId.Next(), 100); // Client1 empty inbox socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Client2 unsharded message socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => LargeMessageSize); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(LargeMessageSize).CopyTo(data); return(LargeMessageSize); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Client1 unsharded message, fills up ControllerInbox socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => LargeMessageSize); socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(LargeMessageSize).CopyTo(data); return(LargeMessageSize); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); // Client2 unsharded message, gets BufferFull response socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => ClientServerMessage.PayloadStart); // minimal valid message size socket.ExpectReceive(data => { data.Clear(); BitConverter.GetBytes(ClientServerMessage.PayloadStart).CopyTo(data); return(ClientServerMessage.PayloadStart); }); socket.ExpectConnected(() => true); socket.ExpectSend(data => { Assert.Equal(ClientServerMessage.PayloadStart, data.Length); Assert.Equal(data[13], (int)MessageType.ServerBusy); return(ClientServerMessage.PayloadStart); }); socket.ExpectConnected(() => true); socket.ExpectAvailable(() => 0); var dispatcher = new Dispatcher(queue, 3, BoundedInbox.Create(), new BoundedInbox[64], BoundedInbox.Create()); queue.Enqueue(client1); queue.Enqueue(client2); dispatcher.DequeueNewClients(); // Client1 empty inbox, Client2 LargeMessageSize bytes unsharded dispatcher.ListenToConnections(); // Client1 LargeMessageSize bytes unsharded, Client2 10 bytes, error message dispatcher.ListenToConnections(); socket.ExpectAllDone(); }