public void HandleLeaveDungeonRequest(MessageConnection messageConnection)
{
var leaveDungeonRequestMessage = (messageConnection.messageHeader as LeaveDungeonRequestMessage);
// send the player left dungeon messages
// player is removed from the active client lists, which also shortens the turncycle
Client removeClient = null;
foreach (KeyValuePair <Client, Player> clientPlayerPair in ActiveClientPlayerDictionary)
{
if (clientPlayerPair.Key.Connection == messageConnection.connection) // the leaving client
{
SendPlayerLeftDungeon(clientPlayerPair.Key);
playerTurnList.Remove(clientPlayerPair.Value); // remove from the playerturnlist
removeClient = clientPlayerPair.Key; // I can't directly delete the client in the foreach, because that is not safe to do.
}
}
if (removeClient != null)
{
ActiveClientPlayerDictionary.Remove(removeClient);
UpdateInverseDictionary();
}
TurnExecution();
}
public void HandleClaimTreasureRequest(MessageConnection messageConnection)
{
Node treasureNode = grid.GetSpecificNodeInstance(currentActivePlayer.CurrentNode);
List <Client> receiveTreasureClients = new List <Client>();
// Get all clients on this node
foreach (KeyValuePair <Client, Player> clientPlayerPair in ActiveClientPlayerDictionary)
{
if (clientPlayerPair.Value.CurrentNode == treasureNode)
{
receiveTreasureClients.Add(clientPlayerPair.Key);
}
}
// divide the treasure amount over the players
int treasureAmountPerPlayer = Mathf.RoundToInt(treasureNode.TreasureAmount / receiveTreasureClients.Count);
// Send the obtain treasure to all those clients
foreach (Client c in receiveTreasureClients)
{
foreach (KeyValuePair <Client, Player> clientPlayerPair in ActiveClientPlayerDictionary)
{
if (clientPlayerPair.Key == c)
{
clientPlayerPair.Value.TreasureAmount += treasureAmountPerPlayer;
}
}
}
SendObtainTreasure(treasureAmountPerPlayer, receiveTreasureClients);
treasureNode.Treasure = false;
TurnExecution();
}
public async Task Connected_Handler_Of_Server_Connection_Starts_Reading(IPEndPoint endpoint)
{
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromException <int>(new Exception()));
var tcpMock = new Mock <ITcpClient>();
using (var socket = new Socket(SocketType.Stream, ProtocolType.IP))
{
tcpMock.Setup(m => m.Client).Returns(socket);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
using (var c = new MessageConnection(endpoint, tcpClient: tcpMock.Object))
{
await c.ConnectAsync();
// because the reading takes place in a separate task,
// and we need it to fail so it doesn't keep looping,
// and because ReadingContinuously is set to false when it fails,
// the best way to make sure this is actually starting the reading is to
// check the stream after a delay.
await Task.Delay(500);
streamMock.Verify(s => s.Close(), Times.Once);
}
}
}
public async Task Deferred_Messages_Are_Sent_On_Connected(IPAddress ipAddress, int port)
{
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(Task.Run(() => 1));
var tcpMock = new Mock <ITcpClient>();
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
var msg = new MessageBuilder()
.Code(MessageCode.PeerBrowseRequest)
.Build();
var c = new MessageConnection(MessageConnectionType.Server, ipAddress, port, tcpClient: tcpMock.Object);
await c.WriteMessageAsync(msg);
await c.WriteMessageAsync(msg);
var deferred1 = c.GetProperty <ConcurrentQueue <Message> >("DeferredMessages").Count;
await c.ConnectAsync();
var deferred2 = c.GetProperty <ConcurrentQueue <Message> >("DeferredMessages");
Assert.Equal(2, deferred1);
Assert.Empty(deferred2);
streamMock.Verify(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Exactly(2));
}
public async Task ReadingContinuously_Returns_Expected_Values(string username, IPAddress ipAddress, int port)
{
bool b = false;
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback <byte[], int, int, CancellationToken>((bytes, offset, length, token) =>
{
b = true;
})
.Throws(new Exception());
var tcpMock = new Mock <ITcpClient>();
tcpMock.Setup(m => m.Client).Returns(new Socket(SocketType.Stream, ProtocolType.IP));
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
var c = new MessageConnection(username, ipAddress, port, tcpClient: tcpMock.Object);
var a = c.ReadingContinuously;
await Record.ExceptionAsync(async() => await c.InvokeMethod <Task>("ReadContinuouslyAsync"));
Assert.False(a);
Assert.True(b);
Assert.False(c.ReadingContinuously);
}
public async Task ReadContinuously_Returns_If_Already_Reading(string username, IPEndPoint endpoint)
{
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Throws(new Exception());
var tcpMock = new Mock <ITcpClient>();
using (var socket = new Socket(SocketType.Stream, ProtocolType.IP))
{
tcpMock.Setup(m => m.Client).Returns(socket);
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
using (var c = new MessageConnection(username, endpoint, tcpClient: tcpMock.Object))
{
c.SetProperty("ReadingContinuously", true);
await c.InvokeMethod <Task>("ReadContinuouslyAsync");
}
}
streamMock.Verify(m => m.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Never);
}
public async Task Codes_Normalized_For_Peer_Connections(string username, IPAddress ipAddress, int port)
{
int code = 0;
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(Task.Run(() => 1));
streamMock.Setup(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback <byte[], int, int, CancellationToken>((bytes, offset, length, token) => code = BitConverter.ToInt32(bytes, 4))
.Returns(Task.CompletedTask);
var tcpMock = new Mock <ITcpClient>();
tcpMock.Setup(m => m.Client).Returns(new Socket(SocketType.Stream, ProtocolType.IP));
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
var msg = new MessageBuilder()
.WriteCode(MessageCode.Peer.InfoRequest)
.Build();
var c = new MessageConnection(username, ipAddress, port, tcpClient: tcpMock.Object);
await c.WriteAsync(msg);
Assert.Equal((int)MessageCode.Peer.InfoRequest - 20000, code);
streamMock.Verify(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task WriteAsync_Throws_ConnectionWriteException_When_Stream_WriteAsync_Throws(IPEndPoint endpoint)
{
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Throws(new IOException());
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(Task.Run(() => 1));
var tcpMock = new Mock <ITcpClient>();
using (var socket = new Socket(SocketType.Stream, ProtocolType.IP))
{
tcpMock.Setup(m => m.Client).Returns(socket);
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
var msg = new BrowseRequest();
using (var c = new MessageConnection(endpoint, tcpClient: tcpMock.Object))
{
var ex = await Record.ExceptionAsync(() => c.WriteAsync(msg));
Assert.NotNull(ex);
Assert.IsType <ConnectionWriteException>(ex);
Assert.IsType <IOException>(ex.InnerException);
streamMock.Verify(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
}
}
}
public async Task WriteAsync_Writes_When_Connected(string username, IPAddress ipAddress, int port)
{
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(Task.Run(() => 1));
var tcpMock = new Mock <ITcpClient>();
using (var socket = new Socket(SocketType.Stream, ProtocolType.IP))
{
tcpMock.Setup(m => m.Client).Returns(socket);
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
var msg = new MessageBuilder()
.WriteCode(MessageCode.Peer.BrowseRequest)
.Build();
using (var c = new MessageConnection(username, ipAddress, port, tcpClient: tcpMock.Object))
{
await c.WriteAsync(msg);
streamMock.Verify(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
}
}
}
public async Task WriteAsync_Raises_MessageWritten_After_Write(string username, IPEndPoint endpoint)
{
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(Task.Run(() => 1));
var tcpMock = new Mock <ITcpClient>();
using (var socket = new Socket(SocketType.Stream, ProtocolType.IP))
{
tcpMock.Setup(m => m.Client).Returns(socket);
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
var msg = new BrowseRequest();
using (var c = new MessageConnection(username, endpoint, tcpClient: tcpMock.Object))
{
bool written = false;
c.MessageWritten += (s, a) => { written = true; };
await c.WriteAsync(msg);
Assert.True(written);
}
}
}
public async Task ReadContinuously_Changes_As_Expected(string username, IPEndPoint endpoint)
{
bool b = false;
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback <byte[], int, int, CancellationToken>((bytes, offset, length, token) =>
{
b = true;
})
.Throws(new Exception());
var tcpMock = new Mock <ITcpClient>();
using (var socket = new Socket(SocketType.Stream, ProtocolType.IP))
{
tcpMock.Setup(m => m.Client).Returns(socket);
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
using (var c = new MessageConnection(username, endpoint, tcpClient: tcpMock.Object))
{
var a = c.ReadingContinuously;
await Record.ExceptionAsync(() => c.InvokeMethod <Task>("ReadContinuouslyAsync"));
Assert.False(a);
Assert.True(b);
Assert.False(c.ReadingContinuously);
}
}
streamMock.Verify(m => m.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task WriteAsync_Uses_Given_CancellationToken(string username, IPEndPoint endpoint)
{
var cancellationToken = new CancellationToken();
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(Task.Run(() => 1));
var tcpMock = new Mock <ITcpClient>();
using (var socket = new Socket(SocketType.Stream, ProtocolType.IP))
{
tcpMock.Setup(m => m.Client).Returns(socket);
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
var msg = new BrowseRequest();
using (var c = new MessageConnection(username, endpoint, tcpClient: tcpMock.Object))
{
await c.WriteAsync(msg, cancellationToken);
streamMock.Verify(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), cancellationToken), Times.Once);
}
}
}
public async Task GetUnsolicitedPeerConnectionAsync_Returns_Existing_Connection_If_Existing_And_Not_Disconnected(string username, IPAddress ipAddress, int port)
{
var options = new ConnectionOptions();
var existingConn = new MessageConnection(MessageConnectionType.Peer, username, ipAddress, port, options);
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.Wait <GetPeerAddressResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new GetPeerAddressResponse(username, ipAddress, port)));
var pcm = new Mock <IConnectionManager <IMessageConnection> >();
pcm.Setup(m => m.Get(It.IsAny <ConnectionKey>()))
.Returns(existingConn);
var s = new SoulseekClient("127.0.0.1", 1, peerConnectionManager: pcm.Object, messageWaiter: waiter.Object);
var conn = await s.InvokeMethod <Task <IMessageConnection> >("GetUnsolicitedPeerConnectionAsync", username, options, CancellationToken.None);
Assert.NotNull(conn);
Assert.Equal(username, conn.Username);
Assert.Equal(ipAddress, conn.IPAddress);
Assert.Equal(port, conn.Port);
Assert.Equal(options, conn.Options);
}
public async Task WriteAsync_Throws_ConnectionWriteException_When_Stream_WriteAsync_Throws(IPAddress ipAddress, int port)
{
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Throws(new IOException());
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(Task.Run(() => 1));
var tcpMock = new Mock <ITcpClient>();
tcpMock.Setup(m => m.Client).Returns(new Socket(SocketType.Stream, ProtocolType.IP));
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
var msg = new MessageBuilder()
.WriteCode(MessageCode.Peer.BrowseRequest)
.Build();
var c = new MessageConnection(ipAddress, port, tcpClient: tcpMock.Object);
var ex = await Record.ExceptionAsync(async() => await c.WriteAsync(msg));
Assert.NotNull(ex);
Assert.IsType <ConnectionWriteException>(ex);
Assert.IsType <IOException>(ex.InnerException);
streamMock.Verify(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Once);
}
public void ShowWelcomeMessage(MessageConnection messageConnection)
{
var message = (messageConnection.messageHeader as WelcomeMessage);
uint playerColour = message.PlayerColour;
Color32 color32 = new Color32();
color32 = ColorExtensions.ColorFromUInt(color32, playerColour);
SetMessagesText(color32, $"Welcome! Your player ID is {message.PlayerID}.");
bool host = false;
if (message.PlayerID == 0)
{
host = true;
}
// Have this clients info ready for the gamemanager.
ThisClient = new Client(message.PlayerID, "", messageConnection.connection, host);
ThisClient.PlayerColour = message.PlayerColour;
AllClientsList.Add(ThisClient);
// Remove this later
gameObject.GetComponent <LobbyManager>().thisClient = ThisClient;
SendSetNameMessage();
}
private void HandleNone(MessageConnection message)
{
foreach (Client c in ClientList)
{
SendMessage(message.messageHeader, c.Connection);
}
}
public void AddDeploymentManager(MessageConnection connection)
{
lock (DeploymentManagers)
if (!DeploymentManagers.Exists(i => i == connection))
{
DeploymentManagers.Add(connection);
}
}
void _channels_Login(object sender, LoginEventArgs e)
{
MessageConnection connection = sender as MessageConnection;
e.UserName = this.UserName;
e.Password = this.Password;
e.Parameters = "propertyList=biblio_search,libraryUID=testrouter";
}
void _channels_Login(object sender, LoginEventArgs e)
{
MessageConnection connection = sender as MessageConnection;
e.UserName = "******";
e.Password = "******";//错误的密码
e.Parameters = "propertyList=biblio_search,libraryUID=xxx";
}
public void Throws_When_Given_Username_Is_Invalid(string username)
{
IMessageConnection c;
var ex = Record.Exception(() => c = new MessageConnection(username, new IPEndPoint(IPAddress.Parse("0.0.0.0"), 1), null));
Assert.NotNull(ex);
Assert.IsType <ArgumentException>(ex);
}
private void HandleStartGame(MessageConnection message)
{
foreach (Client c in ClientList)
{
SendMessage(message.messageHeader, c.Connection);
c.StartHP = (message.messageHeader as StartGameMessage).StartHP;
}
}
internal void RegisterSender(MessageConnection sender)
{
lock (SentVia)
if (!SentVia.Contains(sender))
{
SentVia.Add(sender);
}
}
internal void RegisterSender(MessageConnection sender)
{
lock (_onResponse)
if (!_SentVia.Contains(sender))
{
_SentVia.Add(sender);
}
}
protected override void onReceived(MessageConnection connection, Message message)
{
if (message is AssignInstructionSet)
{
_LastAssignment = DateTime.UtcNow;
}
base.onReceived(connection, message);
}
public void run()
{
while (true)
{
Message mes = MessageConnection.getMessage(comm.GetStream()); // read expression
Console.WriteLine(mes.ToString());
TCPServer.broadcast(mes, cr); //send message to other members of the chatroom
}
}
public void Instantiates_Peer_Connection_With_Given_IP(IPAddress ipAddress, int port, ConnectionOptions options)
{
var c = new MessageConnection(ipAddress, port, options);
Assert.Equal(ipAddress, c.IPAddress);
Assert.Equal(port, c.Port);
Assert.Equal(options, c.Options);
Assert.Equal(new ConnectionKey(string.Empty, ipAddress, port), c.Key);
}
protected override Task OnMessage(MessageConnection connection, Message message)
{
if (message.cmd != testCommand)
{
throw new Exception("Unexpected command.");
}
// Echo back data
connection.SendResponse(message.id, testReply, message.data);
return(Task.CompletedTask);
}
/// <summary>
/// Add a MessageConnection to the list of managed connections
/// </summary>
/// <param name="connection">The MessageConnection to add</param>
protected void ManageConnection(MessageConnection connection)
{
lock (ConnectionLock)
{
if (!_MessageConnections.Contains(connection))
{
_MessageConnections.Add(connection);
}
}
}
/// <summary>
/// 删除消息
/// </summary>
/// <param name="records"></param>
/// <param name="strGroupName"></param>
/// <returns>
/// true 成功
/// false 失败
/// </returns>
bool DeleteMessage(List <MessageRecord> records)
{
List <MessageRecord> delete_records = new List <MessageRecord>();
foreach (MessageRecord source in records)
{
MessageRecord record = new MessageRecord();
// 2016-6-20 jane 不需要传group参数
record.groups = dp2WeiXinService.C_Group_PatronNotity.Split(new char[] { ',' });
record.id = source.id;
delete_records.Add(record);
}
string strError = "";
// CancellationToken cancel_token = new CancellationToken();
try
{
MessageConnection connection = this.Channels.GetConnectionTaskAsync(
this.Url,
dp2WeiXinService.C_ConnName_TraceMessage).Result;
SetMessageRequest param = new SetMessageRequest("expire",
"dontNotifyMe",
delete_records);//records);这里应该用delete_records吧，用records好像也没错
CancellationToken cancel_token = new CancellationToken();
SetMessageResult result = connection.SetMessageTaskAsync(param,
new TimeSpan(0, 1, 0),
cancel_token).Result;
if (result.Value == -1)
{
strError = result.ErrorInfo;
goto ERROR1;
}
}
catch (AggregateException ex)
{
strError = MessageConnection.GetExceptionText(ex);
goto ERROR1;
}
catch (Exception ex)
{
strError = ex.Message;
goto ERROR1;
}
return(true);
ERROR1:
dp2WeiXinService.Instance.WriteErrorLog("DeleteMessage() error : " + strError);
//this.WriteLog("DeleteMessage() error : " + strError, dp2WeiXinService.C_LogLevel_1);
return(false);
}
public void Instantiates_Server_Connection_With_Given_IP(IPEndPoint endpoint, ConnectionOptions options)
{
using (var c = new MessageConnection(endpoint, options))
{
Assert.Equal(endpoint.Address, c.IPEndPoint.Address);
Assert.Equal(endpoint.Port, c.IPEndPoint.Port);
Assert.Equal(options, c.Options);
Assert.Equal(new ConnectionKey(string.Empty, endpoint), c.Key);
}
}
