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();
}