public async Task OnConnectedAsync_StateUnderTest_ExpectedBehavior()
{
// Arrange
var mocker = new AutoMoqer();
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var sixtyNineProtocolHandler = mocker.Create <SixtyNineProtocolHandler>();
ConnectionContext connection = fixture.Build <DefaultConnectionContext>()
.With(x => x.ConnectionClosed, new CancellationToken(false)).WithAutoProperties().Create();
SixtyNineMessage expected = new InitMessage("megakek");
mocker.GetMock <SixtyNineReader>().Setup(x => x.TryParseMessage(It.IsAny <ReadOnlySequence <byte> >(),
ref It.Ref <SequencePosition> .IsAny, ref It.Ref <SequencePosition> .IsAny, out expected));
// Act
await sixtyNineProtocolHandler.OnConnectedAsync(
connection);
Thread.Sleep(100);
connection.ConnectionClosed = new CancellationToken(true);
// Assert
mocker.GetMock <IMessageHandler>()
.Verify(x => x.HandleMessage(It.IsAny <ConnectionContext>(), It.IsAny <InitMessage>()), Times.Once);
}
//Handles execution of initialisation messages.
private static void RunInitMessage(InitMessage initMessage)
{
if (instanceObject != null)
{
throw new Exception("Can only be initialised once!");
}
instanceObject = Activator.CreateInstance(initMessage.InstanceType, initMessage.Arguments);
}
public void GetBytesTest()
{
byte[] globalFeatures = { 0, 5 };
byte[] localFeatures = { 0, 6 };
InitMessage message = new InitMessage(globalFeatures, localFeatures);
byte[] actual = message.GetBytes();
Assert.Equal("00100002000500020006", actual.ToHex());
}
public SixtyNineSendibleMessage?HandleMessage(ConnectionContext connection, SixtyNineMessage message)
{
return(message switch
{
null => null,
InitMessage x => HandleInitMessage(x, connection),
CloseMessage => HandleCloseMessage(connection),
ErrorMessage x => x,
PayloadMessage x => x,
_ => new ErrorMessage(connection.ConnectionId, Encoding.UTF8.GetBytes("Invalid type"))
});
public void ParseTest()
{
InitMessage message = new InitMessage();
message.ParsePayload("0002000500020006".HexToByteArray());
byte[] expectedGlobalFeatures = { 0, 5 };
byte[] expectedLocalFeatures = { 0, 6 };
Assert.Equal(expectedLocalFeatures, message.Localfeatures);
Assert.Equal(expectedGlobalFeatures, message.Globalfeatures);
}
public void ParseTest()
{
TransportState transportState = new TransportState();
byte[] globalFeatures = { 0, 5 };
byte[] localFeatures = { 0, 6 };
InitMessage referenceMessage = new InitMessage(globalFeatures, localFeatures);
MessageReader messageReader = new MessageReader(transportState, new List <MessageDefinition> {
InitMessage.MessageDefinition
}, new List <IMessageValidator>());
Message message = messageReader.Parse(referenceMessage.GetBytes());
Assert.IsType <InitMessage>(message);
Assert.Equal(globalFeatures, ((InitMessage)message).Globalfeatures);
Assert.Equal(localFeatures, ((InitMessage)message).Localfeatures);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldDecodeAckFailure() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldDecodeAckFailure()
{
Neo4jPackV1 neo4jPack = new Neo4jPackV1();
InitMessage originalMessage = new InitMessage("My Driver", map("user", "neo4j", "password", "secret"));
PackedInputArray innput = new PackedInputArray(serialize(neo4jPack, originalMessage));
Neo4jPack_Unpacker unpacker = neo4jPack.NewUnpacker(innput);
// these two steps are executed before decoding in order to select a correct decoder
unpacker.UnpackStructHeader();
unpacker.UnpackStructSignature();
RequestMessage deserializedMessage = _decoder.decode(unpacker);
assertEquals(originalMessage, deserializedMessage);
}
public async ValueTask <bool> ProcessMessageAsync(InitMessage message, CancellationToken cancellation)
{
logger.LogDebug("Handshake Init received.");
if (PeerContext.InitComplete)
{
return(true);
}
// validate init message
PeerContext.OnInitMessageCompleted();
await SendMessageAsync(CreateInitMessage(), cancellation).ConfigureAwait(false);
return(true);// new ValueTask<bool>(true);
}
HandleInitMessage_WithNullSourceAndConnectionStoreDoesNotContainSource_ShouldAddNewConnectionContextAndReturnInitResponse()
{
// Arrange
var mocker = new AutoMoqer();
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var messageHandler = mocker.Resolve <MessageHandler>();
var socketMessage = new InitMessage(null);
var connectionContext = fixture.Create <DefaultConnectionContext>();
// Act
var result = messageHandler.HandleMessage(connectionContext, socketMessage);
// Assert
result.Destination.Should().BeEquivalentTo(connectionContext.ConnectionId);
result.PayloadType.Should().BeEquivalentTo(socketMessage.PayloadType);
result.Source.Should().BeNull();
result.Payload.Should().BeNull();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void testShouldDecodeAuthToken(java.util.Map<String,Object> authToken, boolean checkDecodingResult) throws Exception
protected internal override void TestShouldDecodeAuthToken(IDictionary <string, object> authToken, bool checkDecodingResult)
{
Neo4jPackV1 neo4jPack = new Neo4jPackV1();
InitMessage originalMessage = new InitMessage("My Driver", authToken);
PackedInputArray innput = new PackedInputArray(serialize(neo4jPack, originalMessage));
Neo4jPack_Unpacker unpacker = neo4jPack.NewUnpacker(innput);
// these two steps are executed before decoding in order to select a correct decoder
unpacker.UnpackStructHeader();
unpacker.UnpackStructSignature();
RequestMessage deserializedMessage = _decoder.decode(unpacker);
if (checkDecodingResult)
{
AssertInitMessageMatches(originalMessage, deserializedMessage);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.bolt.runtime.BoltStateMachineState process(org.neo4j.bolt.messaging.RequestMessage message, org.neo4j.bolt.runtime.StateMachineContext context) throws org.neo4j.bolt.runtime.BoltConnectionFatality
public override BoltStateMachineState Process(RequestMessage message, StateMachineContext context)
{
AssertInitialized();
if (message is InitMessage)
{
InitMessage initMessage = ( InitMessage )message;
string userAgent = initMessage.UserAgent();
IDictionary <string, object> authToken = initMessage.AuthToken();
if (processAuthentication(userAgent, authToken, context))
{
return(_readyState);
}
else
{
return(_failedState);
}
}
return(null);
}
private static void AssertInitMessageMatches(InitMessage expected, RequestMessage actual)
{
assertEquals(expected.UserAgent(), ((InitMessage)actual).userAgent());
assertAuthTokenMatches(expected.AuthToken(), ((InitMessage)actual).authToken());
}
private static void WriteInitMessage(InitMessage message, Utf8JsonWriter writer)
{
WritePayloadType(message, writer);
WriteSource(message, writer);
}
private void InitMessageHandler(InitMessage im)
{
accountsCount = im.AccountCount;
stopwatch.Start();
}
public async Task Handle(InitMessage message)
{
Console.WriteLine("SampleSaga stated");
}
public void Consume(InitMessage applicationsMessage, IMessageContext context)
{
Log.Information(GetType(), $"{GetType().Assembly.GetName()} Consumer init");
FlightControl.AddConsumer(typeof(DashboardData), this);
FlightControl.Post(DashBoardGw, new DashBoardRefresh());
}
/// <summary>
/// Handles a data message (The bulk of all messages received, containing player movements, block places, etc)
/// </summary>
private void HandleDataMessage(NetIncomingMessage im)
{
if (im == null)
{
throw new ArgumentNullException(nameof(im));
}
var type = (MessageTypes)im.ReadByte();
switch (type)
{
case MessageTypes.Init:
{
var msg = new InitMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.InitReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.InitEventArgs(msg));
break;
}
case MessageTypes.Banner:
{
var msg = new BannerMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.LobbyBannerReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.BannerEventArgs(msg.Banner));
break;
}
case MessageTypes.LevelData:
{
var msg = new LevelDataMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.LevelDataReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.LevelDataEventArgs(new Level(msg.Level,
networkManager.Client)));
break;
}
case MessageTypes.Chat:
{
var msg = new ChatMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.ChatReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.ChatEventArgs(msg.Message));
break;
}
case MessageTypes.PlayerJoin:
{
var msg = new PlayerJoinMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.PlayerJoinReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.PlayerJoinEventArgs(msg.Player));
break;
}
case MessageTypes.PingUpdate:
{
var msg = new PingUpdateMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.PingUpdateReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.PingUpdateEventArgs(msg.Pings));
break;
}
case MessageTypes.BlockPlace:
{
if (networkManager.Client.Level != null)
{
var msg = new BlockPlaceMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.BlockPlaceMessageReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.BlockPlacedEventArgs(networkManager.Client.Level,
msg.Point.X,
msg.Point.Y, msg.Layer, msg.Type));
}
break;
}
}
}
/// <summary>
/// Processes any incoming messages.
/// </summary>
private void ProcessNetworkMessages()
{
while (networkManager.NetClient.Status == NetPeerStatus.Running)
{
if (networkManager.NetClient == null)
{
continue;
}
// Block thread until next message
networkManager.NetClient.MessageReceivedEvent.WaitOne();
NetIncomingMessage im; // Holder for the incoming message
while ((im = networkManager.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.ConnectionLatencyUpdated:
networkManager.Client.Events.Network.Game.LatencyUpdated.Invoke(
new EventManager.NetEvents.GameServerEvents.LatencyUpdatedEventArgs(im.ReadSingle()));
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Debug.WriteLine(im.ToString());
break;
case NetIncomingMessageType.StatusChanged:
{
var status = (NetConnectionStatus)im.ReadByte();
switch (status)
{
case NetConnectionStatus.None:
{
networkManager.Client.Events.Network.Game.Disconnected.Invoke(
new EventManager.NetEvents.GameServerEvents.DisconnectEventArgs(
"Error connecting to the server."));
break;
}
// When connected to the server
case NetConnectionStatus.Connected:
{
// Must read the first byte of the hail message, which should correspond to the byte of the Init type
im.SenderConnection.RemoteHailMessage.ReadByte(); // Throw it away
var msg = new InitMessage(im.SenderConnection.RemoteHailMessage,
MessageContext.Client);
// Fire connect event
networkManager.Client.Events.Network.Game.Connected.Invoke(
new EventManager.NetEvents.GameServerEvents.ConnectEventArgs());
// And init message with actual data
networkManager.Client.Events.Network.Game.InitReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.InitEventArgs(msg));
break;
}
// When disconnected from the server
case NetConnectionStatus.Disconnected:
{
var reason = im.ReadString();
networkManager.Client.Events.Network.Game.Disconnected.Invoke(
new EventManager.NetEvents.GameServerEvents.DisconnectEventArgs(reason));
break;
}
case NetConnectionStatus.RespondedAwaitingApproval:
{
im.SenderConnection.Approve();
break;
}
}
break;
}
// Data messages are sent by a connected server. (Such as a game server)
case NetIncomingMessageType.Data:
{
HandleDataMessage(im);
break;
}
// Unconnected messages are sent by a server, without creating a full connection. (Used for the auth server)
case NetIncomingMessageType.UnconnectedData:
{
HandleUnconnectedMessage(im);
break;
}
}
networkManager.Recycle(im);
}
}
}
public InitEventArgs(InitMessage message)
{
Message = message;
}
/// <summary>
/// Handles a data message (The bulk of all messages recieved, containing player movements, block places, etc)
/// </summary>
private void HandleDataMessage(NetIncomingMessage im)
{
MessageTypes messageType = (MessageTypes)im.ReadByte(); //Find the type of data message sent
switch (messageType)
{
case MessageTypes.Lobby: //Lobby list packet
{
if (Game.CurrentGameState == GameState.Lobby)
{
LobbyScreen screen = MainWindow.ScreenManager.Current as LobbyScreen;
LobbyMessage msg = new LobbyMessage(im);
screen.Name = msg.ServerName;
screen.Description = msg.Description;
screen.Intro = msg.Intro;
screen.Online = msg.Online;
screen.Rooms = msg.Rooms;
screen.Lobby.LoadRooms();
}
break;
}
case MessageTypes.PlayerJoin: //Player join message
{
PlayerJoinMessage user = new PlayerJoinMessage(im);
//Add player to map
Map.Players.Add(new Player(Map, Map.Spawn, user.Username, user.ID)
{
Tint = user.Color
});
//Add user to userlist
(MainWindow.ScreenManager.Current as GameScreen).PlayerList.Items.Add(user.Username);
if (user.ID != Game.MyID && recievedInit) //Broadcast join message to chat
{
(MainWindow.ScreenManager.Current as GameScreen).SystemChat(user.Username + " [color:LightGray]has[/color] [color:LightGreen]joined.[/color]");
}
if (user.Me)
{
//Let game know of it's own player
Game.MyID = user.ID;
Game.MyIndex = (byte)Map.Players.IndexOf(Map.Players.First(x => x.ID == Game.MyID));
Game.Me.Tint = Game.MyColor;
}
break;
}
case MessageTypes.PlayerLeave: //Player leave message
{
PlayerLeaveMessage user = new PlayerLeaveMessage(im);
//Remove player
if (user.ID != Game.MyID)
{
Player player = (Player)Map.PlayerFromID(user.ID);
Map.Players.Remove((Player)Map.PlayerFromID(user.ID));
(MainWindow.ScreenManager.Current as GameScreen).PlayerList.Items.Remove(player.Username);
(MainWindow.ScreenManager.Current as GameScreen).SystemChat(player.Username + " [color:LightGray]has[/color] [color:IndianRed]left.[/color]");
//Rebuild indexes
for (int i = 0; i < Map.Players.Count; i++)
{
Map.Players[i].Index = i;
if (Map.Players[i].ID == Game.MyID)
{
Game.MyIndex = (byte)i;
}
}
}
break;
}
case MessageTypes.PlayerStatus: //Player move message
{
if (Game.CurrentGameState == GameState.Game)
{
PlayerStateMessage user = new PlayerStateMessage(im);
Player player = (Player)Map.PlayerFromID(user.ID);
player.SimulationState.Position = user.Position.ToVector2();
player.SimulationState.Velocity = user.Velocity.ToVector2();
player.SimulationState.Movement = user.Movement.ToVector2();
if (!recievedInit) //If we have not recieved init (meaning we are not in game yet), set the initial positions directly so interpolation doesn't mess with them
{
player.DisplayState.Position = player.SimulationState.Position;
}
player.VirtualJump = user.IsJumping;
}
break;
}
case MessageTypes.Block: //Block place message
{
if (Game.CurrentGameState == GameState.Game)
{
BlockMessage msg = new BlockMessage(im);
BlockType block = BlockType.FromID(msg.BlockID);
if (Map.CanPlaceBlock(msg.X, msg.Y, msg.Z, block))
{
Map.Tiles[msg.X, msg.Y, msg.Z].Block = block;
}
}
break;
}
case MessageTypes.PlayerSmiley: //Smiley change message
{
if (Game.CurrentGameState == GameState.Game)
{
PlayerSmileyMessage msg = new PlayerSmileyMessage(im);
Player p = (Player)Map.PlayerFromID(msg.ID);
p.Smiley = msg.Smiley;
}
break;
}
case MessageTypes.PlayerMode: //Player mode change message
{
if (Game.CurrentGameState == GameState.Game)
{
PlayerModeMessage mode = new PlayerModeMessage(im);
Map.PlayerFromID(mode.ID).Mode = (PlayerMode)mode.Mode;
}
break;
}
case MessageTypes.Chat: //Chat message
{
if (Game.CurrentGameState == GameState.Game)
{
ChatMessage chat = new ChatMessage(im);
(MainWindow.ScreenManager.Current as GameScreen).AddChat(Map.PlayerFromID(chat.ID).Username, chat.Message);
}
break;
}
case MessageTypes.Init: //Initialization message with world data
{
Game.Map = new Bricklayer.Client.World.Map(game, 1, 1);
InitMessage msg = new InitMessage(im, Map);
Game.Map.Minimap = new Minimap(Game.Map, msg.Width, msg.Height)
{
Position = new Microsoft.Xna.Framework.Vector2(8, 8)
};
Game.Map.CreateCamera();
Game.CurrentGameState = GameState.Game;
(MainWindow.ScreenManager.Current as GameScreen).Show();
(MainWindow.ScreenManager.Current as GameScreen).SystemChat("Connected to [color:LightGray]" + Game.Host + ":" + Game.Port + "[/color]");
recievedInit = true;
break;
}
}
}
