internal static byte[] BuildNodeMessage(NodeMessage msg)
{
byte[] msgData = Encoding.Encode(msg.m_ID, msg.m_NodeHeader, msg.m_ProtoData);
StringBuilder sb = new StringBuilder();
sb.Append(Convert.ToBase64String(msgData));
sb.Append('\0');
byte[] data = System.Text.Encoding.ASCII.GetBytes(sb.ToString());
return data;
}
private void HandleRequestSceneRoomList(NodeMessage msg, int handle, uint seq)
{
GameFrameworkMessage.NodeMessageWithGuid headerMsg = msg.m_NodeHeader as GameFrameworkMessage.NodeMessageWithGuid;
if (null != headerMsg) {
ulong guid = headerMsg.m_Guid;
RoomProcessThread roomProcess = LobbyServer.Instance.RoomProcessThread;
roomProcess.QueueAction(roomProcess.RequestSceneRoomList, guid);
}
}
private void HandleQuitRoom(NodeMessage msg, int handle, uint seq)
{
GameFrameworkMessage.NodeMessageWithGuid quitClientMsg = msg.m_NodeHeader as GameFrameworkMessage.NodeMessageWithGuid;
if (null != quitClientMsg) {
GameFrameworkMessage.QuitRoom protoData = msg.m_ProtoData as GameFrameworkMessage.QuitRoom;
if (null != protoData) {
m_RoomProcessThread.QueueAction(m_RoomProcessThread.QuitRoom, quitClientMsg.m_Guid, protoData.m_IsQuitRoom, handle);
}
}
}
//==========================================================================================================================
private void HandleEnterScene(NodeMessage msg, int handle, uint seq)
{
GameFrameworkMessage.NodeMessageWithGuid startGameMsg = msg.m_NodeHeader as GameFrameworkMessage.NodeMessageWithGuid;
if (startGameMsg != null) {
GameFrameworkMessage.Msg_LB_RequestEnterScene msgData = msg.m_ProtoData as GameFrameworkMessage.Msg_LB_RequestEnterScene;
if (null != msgData) {
m_RoomProcessThread.QueueAction(m_RoomProcessThread.RequestEnterScene, startGameMsg.m_Guid, msgData.SceneId, msgData.WantRoomId, msgData.FromSceneId);
}
}
}
private void HandleChangeSceneRoom(NodeMessage msg, int handle, uint seq)
{
GameFrameworkMessage.NodeMessageWithGuid changeSceneMsg = msg.m_NodeHeader as GameFrameworkMessage.NodeMessageWithGuid;
if (null != changeSceneMsg) {
GameFrameworkMessage.ChangeSceneRoom protoData = msg.m_ProtoData as GameFrameworkMessage.ChangeSceneRoom;
if (null != protoData) {
m_RoomProcessThread.QueueAction(m_RoomProcessThread.RequestChangeSceneRoom, changeSceneMsg.m_Guid, protoData.m_SceneId, protoData.m_RoomId);
}
}
}
internal void AddFriend(string nickname)
{
try {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.Msg_CL_AddFriend);
msg.SetHeaderWithGuid(m_Guid);
Msg_CL_AddFriend protoData = new Msg_CL_AddFriend();
protoData.m_FriendNickname = nickname;
msg.m_ProtoData = protoData;
SendMessage(msg);
} catch (Exception ex) {
LogSystem.Error("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
internal void DiscardItem(ulong itemGuid)
{
try {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.Msg_CL_DiscardItem);
msg.SetHeaderWithGuid(m_Guid);
Msg_CL_DiscardItem protoData = new Msg_CL_DiscardItem();
protoData.ItemGuid = itemGuid;
msg.m_ProtoData = protoData;
SendMessage(msg);
} catch (Exception ex) {
LogSystem.Error("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
internal void DeleteMail(ulong mailGuid)
{
try {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.Msg_CL_DeleteMail);
msg.SetHeaderWithGuid(m_Guid);
Msg_CL_DeleteMail protoData = new Msg_CL_DeleteMail();
protoData.m_MailGuid = mailGuid;
msg.m_ProtoData = protoData;
SendMessage(msg);
} catch (Exception ex) {
LogSystem.Error("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
internal void EnterScene(int sceneId, int roomId)
{
try {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.EnterScene);
msg.SetHeaderWithGuid(m_Guid);
GameFrameworkMessage.EnterScene protoData = new GameFrameworkMessage.EnterScene();
protoData.m_SceneId = sceneId;
protoData.m_RoomId = roomId;
msg.m_ProtoData = protoData;
SendMessage(msg);
} catch (Exception ex) {
LogSystem.Error("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
internal void ChangeRoom(int sceneId, int roomId)
{
try {
if (ClientModule.Instance.IsMainUiScene) {
} else {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.ChangeSceneRoom);
msg.SetHeaderWithGuid(m_Guid);
GameFrameworkMessage.ChangeSceneRoom protoData = new GameFrameworkMessage.ChangeSceneRoom();
protoData.m_SceneId = sceneId;
protoData.m_RoomId = roomId;
msg.m_ProtoData = protoData;
SendMessage(msg);
}
} catch (Exception ex) {
LogSystem.Error("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
/// <summary>
/// Converts BrokeredMessage message to <see cref="T:NodeMessage"/> object.
/// </summary>
/// <param name="message">The message to convert.</param>
/// <returns>Converted message of NodeMessage type.</returns>
public NodeMessage ConvertToNodeMessage(BrokeredMessage message)
{
var messageType = (NodeMessageType)Enum.Parse(typeof(NodeMessageType), (string)message.Properties[MessageTypePropertyName]);
var messageSubtype = message.Properties.ContainsKey(MessageSubtypePropertyName) ? (string)message.Properties[MessageSubtypePropertyName] : null;
var result = new NodeMessage(messageType);
result.SenderNodeId = (string)message.Properties[SenderIdPropertyName];
result.RecipientNodeId = (string)message.Properties[RecipientIdPropertyName];
switch (result.MessageType)
{
case NodeMessageType.ScrumTeamMessage:
if (string.Equals(messageSubtype, typeof(ScrumTeamMemberMessage).Name, StringComparison.OrdinalIgnoreCase))
{
result.Data = message.GetBody <ScrumTeamMemberMessage>();
}
else if (string.Equals(messageSubtype, typeof(ScrumTeamMemberEstimationMessage).Name, StringComparison.OrdinalIgnoreCase))
{
result.Data = message.GetBody <ScrumTeamMemberEstimationMessage>();
}
else
{
result.Data = message.GetBody <ScrumTeamMessage>();
}
break;
case NodeMessageType.TeamCreated:
case NodeMessageType.InitializeTeam:
result.Data = message.GetBody <byte[]>();
break;
case NodeMessageType.TeamList:
case NodeMessageType.RequestTeams:
result.Data = message.GetBody <string[]>();
break;
}
return(result);
}
public async Task Start_RequestTeamsMessageReceived_TeamIsSentToServiceBus()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
var teamList = new string[] { TeamName };
var nodeMessage = new NodeMessage(NodeMessageType.RequestTeams)
{
Data = teamList
};
serviceBus.Setup(b => b.SendMessage(It.IsAny <NodeMessage>())).Returns(Task.CompletedTask);
var sendMessages = SetupServiceBus(serviceBus, target.NodeId, nodeMessage);
NodeMessage initializeTeamMessage = null;
serviceBus.Setup(b => b.SendMessage(It.Is <NodeMessage>(m => m.MessageType == NodeMessageType.InitializeTeam)))
.Callback <NodeMessage>(m => initializeTeamMessage = m).Returns(Task.CompletedTask).Verifiable();
var team = CreateBasicTeam();
SetupPlanningPoker(planningPoker, team);
// Act
await target.Start();
sendMessages();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
Assert.IsNotNull(initializeTeamMessage);
Assert.IsNotNull(initializeTeamMessage.Data);
Assert.IsInstanceOfType(initializeTeamMessage.Data, typeof(string));
var expectedData = JsonConvert.SerializeObject(team.GetData());
Assert.AreEqual(expectedData, (string)initializeTeamMessage.Data);
Assert.AreEqual <string>(nodeMessage.SenderNodeId, initializeTeamMessage.RecipientNodeId);
}
public async Task Start_MasterActivityFromServiceBus_MasterUpdatedActivityInTeam()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
var message = new ScrumTeamMemberMessage(TeamName, MessageType.MemberActivity)
{
MemberName = ScrumMasterName,
MemberType = "ScrumMaster"
};
var nodeMessage = new NodeMessage(NodeMessageType.ScrumTeamMessage)
{
Data = message
};
var sendMessages = SetupServiceBus(serviceBus, target.NodeId, nodeMessage);
var dateTimeProvider = new DateTimeProviderMock();
dateTimeProvider.SetUtcNow(new DateTime(2012, 9, 9, 23, 27, 33, DateTimeKind.Utc));
var team = new ScrumTeam(TeamName, dateTimeProvider);
team.SetScrumMaster(ScrumMasterName);
var teamLock = SetupPlanningPoker(planningPoker, team);
dateTimeProvider.SetUtcNow(new DateTime(2012, 9, 9, 23, 28, 27, DateTimeKind.Utc));
// Act
await target.Start();
sendMessages();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
teamLock.Verify();
Assert.AreEqual <DateTime>(dateTimeProvider.UtcNow, team.ScrumMaster.LastActivity);
}
public async Task Start_RequestTeamListMessageReceived_TeamListIsSentToServiceBus()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
var nodeMessage = new NodeMessage(NodeMessageType.RequestTeamList)
{
SenderNodeId = "sender"
};
serviceBus.Setup(b => b.SendMessage(It.IsAny <NodeMessage>())).Returns(Task.CompletedTask);
var sendMessages = SetupServiceBus(serviceBus, target.NodeId, nodeMessage);
NodeMessage teamListMessage = null;
serviceBus.Setup(b => b.SendMessage(It.Is <NodeMessage>(m => m.MessageType == NodeMessageType.TeamList)))
.Callback <NodeMessage>(m => teamListMessage = m).Returns(Task.CompletedTask).Verifiable();
var teamList = new string[] { TeamName };
planningPoker.Setup(p => p.ObservableMessages).Returns(Observable.Empty <ScrumTeamMessage>());
planningPoker.Setup(p => p.DateTimeProvider).Returns(DateTimeProvider.Default);
planningPoker.Setup(p => p.SetTeamsInitializingList(It.IsAny <IEnumerable <string> >()));
planningPoker.Setup(p => p.EndInitialization());
planningPoker.Setup(p => p.ScrumTeamNames).Returns(teamList);
// Act
await target.Start();
sendMessages();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
Assert.IsNotNull(teamListMessage);
Assert.IsNotNull(teamListMessage.Data);
CollectionAssert.AreEquivalent(teamList, (string[])teamListMessage.Data);
Assert.AreEqual <string>(nodeMessage.SenderNodeId, teamListMessage.RecipientNodeId);
}
/// <summary>
/// Converts BrokeredMessage message to <see cref="T:NodeMessage"/> object.
/// </summary>
/// <param name="message">The message to convert.</param>
/// <returns>Converted message of NodeMessage type.</returns>
public NodeMessage ConvertToNodeMessage(Message message)
{
var messageType = (NodeMessageType)Enum.Parse(typeof(NodeMessageType), (string)message.UserProperties[MessageTypePropertyName]);
var messageSubtype = message.UserProperties.ContainsKey(MessageSubtypePropertyName) ? (string)message.UserProperties[MessageSubtypePropertyName] : null;
var result = new NodeMessage(messageType);
result.SenderNodeId = (string)message.UserProperties[SenderIdPropertyName];
result.RecipientNodeId = (string)message.UserProperties[RecipientIdPropertyName];
string messageJson;
switch (result.MessageType)
{
case NodeMessageType.ScrumTeamMessage:
messageJson = Encoding.UTF8.GetString(message.Body);
if (string.Equals(messageSubtype, typeof(ScrumTeamMemberMessage).Name, StringComparison.OrdinalIgnoreCase))
{
result.Data = JsonConvert.DeserializeObject<ScrumTeamMemberMessage>(messageJson);
}
else if (string.Equals(messageSubtype, typeof(ScrumTeamMemberEstimationMessage).Name, StringComparison.OrdinalIgnoreCase))
{
result.Data = JsonConvert.DeserializeObject<ScrumTeamMemberEstimationMessage>(messageJson);
}
else
{
result.Data = JsonConvert.DeserializeObject<ScrumTeamMessage>(messageJson);
}
break;
case NodeMessageType.TeamCreated:
case NodeMessageType.InitializeTeam:
result.Data = message.Body;
break;
case NodeMessageType.TeamList:
case NodeMessageType.RequestTeams:
messageJson = Encoding.UTF8.GetString(message.Body);
result.Data = JsonConvert.DeserializeObject<string[]>(messageJson);
break;
}
return result;
}
public void ConvertToBrokeredMessageAndBack_ScrumTeamMemberEstimationMessage()
{
var scrumTeamMessage = new ScrumTeamMemberEstimationMessage(TeamName, MessageType.MemberEstimated)
{
MemberName = "Scrum Master",
Estimation = 8
};
var nodeMessage = new NodeMessage(NodeMessageType.ScrumTeamMessage)
{
SenderNodeId = SenderId,
Data = scrumTeamMessage
};
var result = ConvertToBrokeredMessageAndBack(nodeMessage);
var resultData = (ScrumTeamMemberEstimationMessage)result.Data;
Assert.AreEqual(MessageType.MemberEstimated, resultData.MessageType);
Assert.AreEqual(TeamName, resultData.TeamName);
Assert.AreEqual(scrumTeamMessage.MemberName, resultData.MemberName);
Assert.AreEqual(scrumTeamMessage.Estimation, resultData.Estimation);
}
public void SendMessage(NodeMessage <T> msg, byte[] payload)
{
var json = JsonConvert.SerializeObject(msg);
try
{
lock (bWriter)
{
bWriter.Write(json);
if (payload != null)
{
bWriter.Write(payload);
}
bWriter.Flush();
}
}
catch (Exception e)
{
InternalExceptionOccured(this, new MessageNetworkException("Error while sending a message.", e));
}
}
public async Task Start_RequestTeamsMessageReceivedButTeamDoesNotExistAnymore_TeamNameIsSentToServiceBus()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
var teamList = new string[] { TeamName };
var nodeMessage = new NodeMessage(NodeMessageType.RequestTeams)
{
Data = teamList
};
serviceBus.Setup(b => b.SendMessage(It.IsAny <NodeMessage>())).Returns(Task.CompletedTask);
var sendMessages = SetupServiceBus(serviceBus, target.NodeId, nodeMessage);
NodeMessage initializeTeamMessage = null;
serviceBus.Setup(b => b.SendMessage(It.Is <NodeMessage>(m => m.MessageType == NodeMessageType.InitializeTeam)))
.Callback <NodeMessage>(m => initializeTeamMessage = m).Returns(Task.CompletedTask).Verifiable();
planningPoker.Setup(p => p.SetTeamsInitializingList(It.IsAny <IEnumerable <string> >()));
planningPoker.Setup(p => p.EndInitialization()).Verifiable();
planningPoker.Setup(p => p.ObservableMessages).Returns(Observable.Empty <ScrumTeamMessage>()).Verifiable();
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Throws(new ArgumentException("teamName")).Verifiable();
// Act
await target.Start();
sendMessages();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
Assert.IsNotNull(initializeTeamMessage);
Assert.IsNotNull(initializeTeamMessage.Data);
Assert.IsInstanceOfType(initializeTeamMessage.Data, typeof(string));
Assert.AreEqual <string>(TeamName, (string)initializeTeamMessage.Data);
Assert.AreEqual <string>(nodeMessage.SenderNodeId, initializeTeamMessage.RecipientNodeId);
}
public async Task Start_TeamCreatedMessage_MessageIsSentToServiceBus()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
planningPoker.Setup(p => p.SetTeamsInitializingList(It.IsAny <IEnumerable <string> >()));
planningPoker.Setup(p => p.EndInitialization());
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var message = new ScrumTeamMessage(TeamName, MessageType.TeamCreated);
var startPlanningPokerMsg = SetupPlanningPokerMsg(planningPoker, message);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var sendServiceBusMsg = SetupServiceBus(serviceBus, target.NodeId, null);
NodeMessage nodeMessage = null;
serviceBus.Setup(b => b.SendMessage(It.Is <NodeMessage>(m => m.MessageType == NodeMessageType.TeamCreated)))
.Callback <NodeMessage>(m => nodeMessage = m).Returns(Task.CompletedTask).Verifiable();
// Act
await target.Start();
sendServiceBusMsg();
startPlanningPokerMsg();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
teamLock.Verify();
Assert.IsNotNull(nodeMessage);
Assert.AreEqual <NodeMessageType>(NodeMessageType.TeamCreated, nodeMessage.MessageType);
Assert.AreEqual <string>(target.NodeId, nodeMessage.SenderNodeId);
Assert.IsNotNull(nodeMessage.Data);
Assert.IsInstanceOfType(nodeMessage.Data, typeof(byte[]));
}
internal static NodeMessage DecodeNodeMessage(byte[] data)
{
NodeMessage msg = null;
if (s_Inited) {
string msgStr = null;
try {
msgStr = System.Text.Encoding.ASCII.GetString(data, 0, data.Length - 1);
byte[] msgData = Convert.FromBase64String(msgStr);
if (msgData.Length >= 4) {
int first = msgData[0];
int second = msgData[1];
int headerFirst = msgData[2];
int headerSecond = msgData[3];
int id = first + (second << 8);
int headerSize = headerFirst + (headerSecond << 8);
msg = new NodeMessage(id);
Type type = GetMessageType(id);
if (null != type) {
msg.m_NodeHeader = Encoding.Decode(type, msgData, 4, headerSize);
}
Type proto = GetMessageProtoType(id);
if (null != proto) {
msg.m_ProtoData = Encoding.Decode(proto, msgData, 4 + headerSize);
}
}
} catch (Exception ex) {
if (null == msgStr) {
LogSys.Log(LOG_TYPE.ERROR, "[Exception] DecodeJsonMessage:{0}\n{1}", ex.Message, ex.StackTrace);
} else {
LogSys.Log(LOG_TYPE.ERROR, "[Exception] DecodeJsonMessage:{0} {1}\n{2}", msgStr, ex.Message, ex.StackTrace);
}
}
}
if (null != msg) {
msg.m_OriginalMsgData = data;
}
return msg;
}
internal void ManageTask(Task task, TaskAction action)
{
var protocolAction = "";
switch (action)
{
case TaskAction.Cancel:
protocolAction = "CANCELTASK";
break;
case TaskAction.Pause:
protocolAction = "PAUSETASK";
break;
case TaskAction.Start:
protocolAction = "STARTTASK";
break;
case TaskAction.Restart:
protocolAction = "RESUMETASK";
break;
case TaskAction.Expire:
protocolAction = "EXPIRETASK";
break;
default:
break;
}
var taskM = new NodeMessage {
Context = MessageContext.Task,
Action = protocolAction,
TaskId = task.Id,
Data = task.ToJson <Task>()
};
SendMessage(taskM);
}
private static Action SetupServiceBus(Mock <IServiceBus> serviceBus, string nodeId, string[] initializationTeamList, NodeMessage nodeMessage)
{
serviceBus.Setup(b => b.Register(nodeId)).Returns(Task.CompletedTask).Verifiable();
serviceBus.Setup(b => b.Unregister()).Returns(Task.CompletedTask).Verifiable();
var emptyTeamListMessage = new NodeMessage(NodeMessageType.TeamList)
{
Data = initializationTeamList ?? Array.Empty <string>(),
RecipientNodeId = nodeId
};
var observableMessages = new Subject <NodeMessage>();
serviceBus.Setup(b => b.ObservableMessages).Returns(observableMessages).Verifiable();
if (initializationTeamList != null && initializationTeamList.Length != 0)
{
serviceBus.Setup(b => b.SendMessage(It.Is <NodeMessage>(m =>
m.MessageType == NodeMessageType.RequestTeamList || m.MessageType == NodeMessageType.RequestTeams)))
.Returns(Task.CompletedTask).Verifiable();
}
else
{
serviceBus.Setup(b => b.SendMessage(It.Is <NodeMessage>(m => m.MessageType == NodeMessageType.RequestTeamList)))
.Returns(Task.CompletedTask).Verifiable();
}
return(new Action(
() =>
{
observableMessages.OnNext(emptyTeamListMessage);
if (nodeMessage != null)
{
observableMessages.OnNext(nodeMessage);
}
observableMessages.OnCompleted();
}));
}
private void HandleAuthMessage(NodeMessage message)
{
char[] separator = { ' ' };
string[] decoded = message.Data.Split(separator);
switch (message.Action)
{
case "CLIENTINFO": // send version and OS
P2PBackup.Common.Node remoteInfo = message.Data.FromJson <P2PBackup.Common.Node>();
this.Version = remoteInfo.Version;
this.OS = remoteInfo.OS;
this.HostName = remoteInfo.HostName;
this.Plugins = remoteInfo.Plugins;
this.LastConnection = DateTime.Now;
new DAL.NodeDAO().UpdatePartial(this);
break;
default:
throw new P2PBackup.Common.ProtocolViolationException(message);
}
}
public void ConvertToBrokeredMessageAndBack_ScrumTeamMemberMessage()
{
var scrumTeamMessage = new ScrumTeamMemberMessage(TeamName, MessageType.MemberJoined)
{
MemberType = "Observer",
MemberName = "Test person",
SessionId = Guid.NewGuid()
};
var nodeMessage = new NodeMessage(NodeMessageType.ScrumTeamMessage)
{
SenderNodeId = SenderId,
Data = scrumTeamMessage
};
var result = ConvertToBrokeredMessageAndBack(nodeMessage);
var resultData = (ScrumTeamMemberMessage)result.Data;
Assert.AreEqual(MessageType.MemberJoined, resultData.MessageType);
Assert.AreEqual(TeamName, resultData.TeamName);
Assert.AreEqual(scrumTeamMessage.MemberType, resultData.MemberType);
Assert.AreEqual(scrumTeamMessage.MemberName, resultData.MemberName);
Assert.AreEqual(scrumTeamMessage.SessionId, resultData.SessionId);
}
private void Session_RawMessageReceived(NodeSession <T> sender, NodeMessage <T> message, byte[] payload)
{
if (message.Receiver != null)
{
if (message.Receiver.Equals(keyPair.Public))
{
HandleMessage(message, payload);
}
else
{
rootNode.Find(message.Receiver).Session.SendMessage(message, payload);
}
}
else
{
foreach (var node in rootNode.Children.Where(o => !o.PublicKey.Equals(sender.ReceivedPublicKey)))
{
node.Session.SendMessage(message, payload);
}
HandleMessage(message, payload);
}
}
/// <summary>
/// Converts <see cref="T:NodeMessage"/> message to BrokeredMessage object.
/// </summary>
/// <param name="message">The message to convert.</param>
/// <returns>Converted message of BrokeredMessage type.</returns>
public Message ConvertToBrokeredMessage(NodeMessage message)
{
byte[] messageData;
if (message.MessageType == NodeMessageType.InitializeTeam || message.MessageType == NodeMessageType.TeamCreated)
{
messageData = (byte[])message.Data;
}
else
{
messageData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message.Data));
}
var result = new Message(messageData);
result.UserProperties[MessageTypePropertyName] = message.MessageType.ToString();
if (message.Data != null)
{
result.UserProperties[MessageSubtypePropertyName] = message.Data.GetType().Name;
}
result.UserProperties[SenderIdPropertyName] = message.SenderNodeId;
result.UserProperties[RecipientIdPropertyName] = message.RecipientNodeId;
return result;
}
public async Task Start_ObserverJoinedFromServiceBus_ObserverJoinedTeam()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
var message = new ScrumTeamMemberMessage(TeamName, MessageType.MemberJoined)
{
MemberName = ObserverName,
MemberType = "Observer"
};
var nodeMessage = new NodeMessage(NodeMessageType.ScrumTeamMessage)
{
Data = message
};
var sendMessages = SetupServiceBus(serviceBus, target.NodeId, nodeMessage);
var team = CreateBasicTeam();
var teamLock = SetupPlanningPoker(planningPoker, team);
// Act
await target.Start();
sendMessages();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
teamLock.Verify();
var observer = team.FindMemberOrObserver(ObserverName);
Assert.IsNotNull(observer);
Assert.IsInstanceOfType(observer, typeof(Observer));
Assert.AreEqual <string>(ObserverName, observer.Name);
}
internal static NodeMessage DecodeNodeMessage(string msgStr)
{
NodeMessage msg = null;
if (s_Inited) {
try {
byte[] msgData = Convert.FromBase64String(msgStr);
if (msgData.Length >= 4) {
int first = msgData[0];
int second = msgData[1];
int headerFirst = msgData[2];
int headerSecond = msgData[3];
int id = first + (second << 8);
int headerSize = headerFirst + (headerSecond << 8);
LogSystem.Info("DecodeNodeMessage:{0} {1}", id, msgStr);
msg = new NodeMessage(id);
Type type = GetMessageType(id);
if (null != type) {
msg.m_NodeHeader = Encoding.Decode(type, msgData, 4, headerSize);
}
Type proto = GetMessageProtoType(id);
if (null != proto) {
msg.m_ProtoData = Encoding.Decode(proto, msgData, 4 + headerSize);
}
}
} catch (Exception ex) {
if (null == msgStr) {
LogSystem.Error("[Exception] DecodeJsonMessage:{0}\n{1}", ex.Message, ex.StackTrace);
} else {
LogSystem.Error("[Exception] DecodeJsonMessage:{0} {1}\n{2}", msgStr, ex.Message, ex.StackTrace);
}
}
}
return msg;
}
public async Task Start_InitializeTeamMessageReceived_InitializeTeamOnPlanningPoker()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
var teamList = new string[] { TeamName };
var nodeMessage = new NodeMessage(NodeMessageType.InitializeTeam)
{
Data = CreateSerializedBasicTeam()
};
serviceBus.Setup(b => b.SendMessage(It.IsAny <NodeMessage>())).Returns(Task.CompletedTask);
var sendMessages = SetupServiceBus(serviceBus, target.NodeId, teamList, nodeMessage);
planningPoker.Setup(p => p.ObservableMessages).Returns(Observable.Empty <ScrumTeamMessage>());
planningPoker.Setup(p => p.DateTimeProvider).Returns(DateTimeProvider.Default);
planningPoker.Setup(p => p.SetTeamsInitializingList(It.IsAny <IEnumerable <string> >()));
ScrumTeam initializingTeam = null;
planningPoker.Setup(p => p.InitializeScrumTeam(It.IsAny <ScrumTeam>())).Callback <ScrumTeam>(t => initializingTeam = t).Verifiable();
planningPoker.Setup(p => p.EndInitialization()).Verifiable();
// Act
await target.Start();
sendMessages();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
Assert.IsNotNull(initializingTeam);
Assert.AreEqual <string>(TeamName, initializingTeam.Name);
}
public async Task Start_MasterEstimatedFromServiceBus_MasterEstimationIsSet()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
var message = new ScrumTeamMemberEstimationMessage(TeamName, MessageType.MemberEstimated)
{
MemberName = ScrumMasterName,
Estimation = 5.0
};
var nodeMessage = new NodeMessage(NodeMessageType.ScrumTeamMessage)
{
Data = message
};
var sendMessages = SetupServiceBus(serviceBus, target.NodeId, nodeMessage);
var team = CreateBasicTeam();
team.ScrumMaster.StartEstimation();
var teamLock = SetupPlanningPoker(planningPoker, team);
// Act
await target.Start();
sendMessages();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
teamLock.Verify();
Assert.IsNotNull(team.ScrumMaster.Estimation);
Assert.AreEqual <double?>(5.0, team.ScrumMaster.Estimation.Value);
}
public async Task Start_TeamCreatedFromServiceBus_TeamAttachedToPlanningPoker()
{
// Arrange
var planningPoker = new Mock <IAzurePlanningPoker>(MockBehavior.Strict);
var serviceBus = new Mock <IServiceBus>(MockBehavior.Strict);
var target = CreatePlanningPokerAzureNode(planningPoker.Object, serviceBus.Object, CreateConfigutartion());
var nodeMessage = new NodeMessage(NodeMessageType.TeamCreated)
{
Data = CreateSerializedBasicTeam()
};
var sendMessages = SetupServiceBus(serviceBus, target.NodeId, nodeMessage);
var dateTimeProvider = new DateTimeProviderMock();
ScrumTeam team = null;
planningPoker.Setup(p => p.AttachScrumTeam(It.IsAny <ScrumTeam>()))
.Callback <ScrumTeam>(t => team = t).Returns(default(IScrumTeamLock)).Verifiable();
planningPoker.Setup(p => p.DateTimeProvider).Returns(dateTimeProvider).Verifiable();
planningPoker.Setup(p => p.ObservableMessages).Returns(Observable.Empty <ScrumTeamMessage>()).Verifiable();
planningPoker.Setup(p => p.SetTeamsInitializingList(It.IsAny <IEnumerable <string> >()));
planningPoker.Setup(p => p.EndInitialization());
// Act
await target.Start();
sendMessages();
await target.Stop();
// Verify
planningPoker.Verify();
serviceBus.Verify();
Assert.IsNotNull(team);
Assert.AreEqual <string>(TeamName, team.Name);
Assert.AreEqual <DateTimeProvider>(dateTimeProvider, team.DateTimeProvider);
}
private void ListenIncoming(KadNode ownerNode)
{
IPEndPoint incomingIpEndPoint = new IPEndPoint(IPAddress.Any, EndPoint.Port);
while (!_stopped)
{
try {
byte[] rawMsg = _udpClient.Receive(ref incomingIpEndPoint);
NodeMessage incomingMsg = new NodeMessage.Builder(rawMsg).Build(); //TODO: msg validation
ulong msgIdx = GetMessageId(incomingIpEndPoint.Address, incomingMsg.Seq); //TODO: two spare bytes for port
if (_messages.ContainsKey(msgIdx))
{
NodeMessage rqMsg = null;
if (_messages.TryRemove(msgIdx, out rqMsg))
{
rqMsg.ProcessResponse(incomingMsg);
}
}
else
{
if (incomingMsg.IsRequest)
{
ownerNode.ProcessRequest(incomingMsg, incomingIpEndPoint);
_messages.AddOrUpdate(msgIdx, incomingMsg, (k, v) => v);
}
}
} catch (SocketException se) {
if (se.SocketErrorCode != SocketError.Interrupted)
{
throw se;
}
}
incomingIpEndPoint = new IPEndPoint(IPAddress.Any, EndPoint.Port);
}
}
public bool ShouldReset(NodeMessage message)
{
return(FromLeader(message) && message.Term > _node.Status.Term);
}
internal static void SendNodeMessage(int handle, NodeMessage msg)
{
if (s_Inited) {
byte[] data = BuildNodeMessage(msg);
if (null != data) {
CenterClientApi.SendByHandle(handle, data, data.Length);
}
}
}
private void CommitLogEntry(NodeMessage message)
{
Node.CommitLog(message);
Node.SendCommit(message);
}
private void AddConfirmation(NodeMessage message)
{
_status.ConfirmedNodes.Add(message.SenderName);
}
private bool ShouldResetTimer(NodeMessage message)
{
return(_strategySelector.SelectTimerStrategy(Node).ShouldReset(message));
}
internal static bool SendMessage(NodeMessage msg)
{
string msgStr = BuildNodeMessage(msg);
LogSystem.Info("SendToLobby:{0} {1}", msg.m_ID, msgStr);
/*
/// ���Է���
if (msg.m_ID == (int)LobbyMessageDefine.GetMorrowReward
|| msg.m_ID == (int)LobbyMessageDefine.SellItem
|| msg.m_ID == (int)LobbyMessageDefine.DiscardItem
|| msg.m_ID == (int)LobbyMessageDefine.MountEquipment
|| msg.m_ID == (int)LobbyMessageDefine.UnmountEquipment
|| msg.m_ID == (int)LobbyMessageDefine.UpgradeSkill
|| msg.m_ID == (int)LobbyMessageDefine.CompoundEquip
|| msg.m_ID == (int)LobbyMessageDefine.CompoundTalentCard
|| msg.m_ID == (int)LobbyMessageDefine.BuyEliteCount
|| msg.m_ID == (int)LobbyMessageDefine.StartPartnerBattle
|| msg.m_ID == (int)LobbyMessageDefine.EndPartnerBattle
|| msg.m_ID == (int)LobbyMessageDefine.BuyPartnerCombatTicket
|| msg.m_ID == (int)LobbyMessageDefine.RefreshPartnerCombatResult
|| msg.m_ID == (int)LobbyMessageDefine.UpgradeItem
|| msg.m_ID == (int)LobbyMessageDefine.StageClear
|| msg.m_ID == (int)LobbyMessageDefine.SweepStage
|| msg.m_ID == (int)LobbyMessageDefine.LiftSkill
|| msg.m_ID == (int)LobbyMessageDefine.BuyStamina
|| msg.m_ID == (int)LobbyMessageDefine.FinishMission
|| msg.m_ID == (int)LobbyMessageDefine.UpgradeLegacy
|| msg.m_ID == (int)LobbyMessageDefine.AddXSoulExperience
|| msg.m_ID == (int)LobbyMessageDefine.XSoulChangeShowModel
|| msg.m_ID == (int)LobbyMessageDefine.FinishExpedition
|| msg.m_ID == (int)LobbyMessageDefine.ExpeditionAward
|| msg.m_ID == (int)LobbyMessageDefine.MidasTouch
|| msg.m_ID == (int)LobbyMessageDefine.ExchangeGoods
|| msg.m_ID == (int)LobbyMessageDefine.SecretAreaTrial
|| msg.m_ID == (int)LobbyMessageDefine.SecretAreaFightingInfo
|| msg.m_ID == (int)LobbyMessageDefine.RequestRefreshExchange
|| msg.m_ID == (int)LobbyMessageDefine.SelectPartner
|| msg.m_ID == (int)LobbyMessageDefine.UpgradePartnerLevel
|| msg.m_ID == (int)LobbyMessageDefine.UpgradePartnerStage
|| msg.m_ID == (int)LobbyMessageDefine.CompoundPartner
|| msg.m_ID == (int)LobbyMessageDefine.SignInAndGetReward
|| msg.m_ID == (int)LobbyMessageDefine.WeeklyLoginReward
|| msg.m_ID == (int)LobbyMessageDefine.GetOnlineTimeReward
|| msg.m_ID == (int)LobbyMessageDefine.RequestMpveAward
|| msg.m_ID == (int)LobbyMessageDefine.EquipTalent
|| msg.m_ID == (int)LobbyMessageDefine.AddTalentExperience
|| msg.m_ID == (int)LobbyMessageDefine.GainVipReward
|| msg.m_ID == (int)LobbyMessageDefine.GainFirstPayReward
|| msg.m_ID == (int)LobbyMessageDefine.RequestEnhanceEquipmentStar
|| msg.m_ID == (int)LobbyMessageDefine.UpgradeEquipBatch
|| msg.m_ID == (int)LobbyMessageDefine.BuyFashion
|| msg.m_ID == (int)LobbyMessageDefine.LuckyDraw
|| msg.m_ID == (int)LobbyMessageDefine.EquipmentStrength) {
/// Test codes
/// ÿ�η���32���������Զ��߳�����������BUG
for (int i = 0; i < 32; ++i) {
LobbyNetworkSystem.Instance.SendMessage(msgStr);
}
return true;
}
*/
return UserNetworkSystem.Instance.SendMessage(msgStr);
}
internal void QuitRoom(bool isQuitTeam)
{
if (m_Guid != 0) {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.QuitRoom);
msg.SetHeaderWithGuid(m_Guid);
GameFrameworkMessage.QuitRoom protoMsg = new GameFrameworkMessage.QuitRoom();
protoMsg.m_IsQuitRoom = isQuitTeam;
msg.m_ProtoData = protoMsg;
SendMessage(msg);
}
}
internal void QuitClient()
{
if (m_Guid != 0) {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.Logout, m_Guid);
SendMessage(msg);
}
if (m_AccountId != string.Empty) {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.AccountLogout, m_AccountId);
SendMessage(msg);
}
m_IsWaitStart = true;
m_HasLoggedOn = false;
Disconnect();
}
internal static bool SendMessageTest(NodeMessage msg)
{
string msgStr = BuildNodeMessage(msg);
/// Test codes
/// ÿ�η���32���������Զ��߳�����������BUG
for (int i = 0; i < 32; ++i) {
UserNetworkSystem.Instance.SendMessage(msgStr);
}
return true;
}
private static string BuildNodeMessage(NodeMessage msg)
{
byte[] msgData = Encoding.Encode(msg.m_ID, msg.m_NodeHeader, msg.m_ProtoData);
return Convert.ToBase64String(msgData);
}
internal static void HandleNodeMessage(NodeMessage msg, int handle, uint session)
{
if (s_Inited && msg != null) {
//LogSys.Log(LOG_TYPE.DEBUG, "Handle Json Message:{0}={1}", msg.m_ID, msg.GetType().Name);
NodeMessageHandlerInfo info = s_MessageHandlers[(int)msg.m_ID];
if (info != null && info.m_Handler != null) {
info.m_Handler(msg, handle, session);
}
}
}
private bool ConfirmsLastEntry(NodeMessage message)
{
return(message.Id == Node.LastLogEntry()?.Id);
}
public override void OnInput(NodeMessage msg)
{
Console.WriteLine("OK", msg.Payload.ToString());
Done();
}
internal static void HandleNodeMessage(NodeMessage msg)
{
if (s_Inited && msg != null) {
NodeMessageHandlerInfo info = s_MessageHandlers[(int)msg.m_ID];
if (info != null && info.m_Handler != null) {
info.m_Handler(msg);
}
}
}
private void RespondToMessage(NodeMessage message)
{
_strategySelector.SelectResponseStrategy(Node).RespondToMessage(message);
}
private void SendGetQueueingCount()
{
NodeMessage msg = new NodeMessage(LobbyMessageDefine.GetQueueingCount, m_AccountId);
SendMessage(msg);
}
private static Action SetupServiceBus(Mock <IServiceBus> serviceBus, string nodeId, NodeMessage nodeMessage)
{
return(SetupServiceBus(serviceBus, nodeId, null, nodeMessage));
}
private void SendHeartbeat()
{
NodeMessage msg = new NodeMessage(LobbyMessageDefine.UserHeartbeat, m_Guid);
SendMessage(msg);
}
public void OnNodeChange(NodeMessage msg)
{
var n = Self.Nodes[msg.Index];
n.Symbol = new Card(msg.Symbol);
Self.UpdateNodeVisual(n);
}
private void SendMessage(NodeMessage msg)
{
try {
NodeMessageDispatcher.SendMessage(msg);
} catch (Exception ex) {
LogSystem.Error("LobbyNetworkSystem.SendMessage throw Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
internal void HandleQuitRoom(NodeMessage lobbyMsg)
{
if (!ClientModule.Instance.IsMainUiScene) {
}
}
private void Vote(NodeMessage message)
{
Node.Vote(message.Term, message.SenderName, message.Id);
}
private void HandleQueueingCountResult(NodeMessage lobbyMsg)
{
GameFrameworkMessage.QueueingCountResult protoData = lobbyMsg.m_ProtoData as GameFrameworkMessage.QueueingCountResult;
if (null != protoData) {
int queueingCount = protoData.m_QueueingCount;
if (queueingCount != UserNetworkSystem.Instance.QueueingNum) {
UserNetworkSystem.Instance.QueueingNum = protoData.m_QueueingCount;
}
}
}
internal static void SendNodeMessage(string name, NodeMessage msg)
{
if (s_Inited) {
byte[] data = BuildNodeMessage(msg);
if (null != name && null != data) {
CenterClientApi.SendByName(name, data, data.Length);
}
}
}
private void RoleEnter(string accountId, string nickname)
{
try {
NodeMessage msg = new NodeMessage(LobbyMessageDefine.RoleEnter, accountId);
GameFrameworkMessage.RoleEnter protoData = new GameFrameworkMessage.RoleEnter();
protoData.m_Nickname = nickname;
msg.m_ProtoData = protoData;
SendMessage(msg);
} catch (Exception ex) {
LogSystem.Error("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
private void HandleUserHeartbeat(NodeMessage lobbyMsg)
{
m_LastReceiveHeartbeatTime = TimeUtility.GetLocalMilliseconds();
TimeUtility.LobbyLastResponseTime = m_LastReceiveHeartbeatTime;
long rtt = m_LastReceiveHeartbeatTime - m_LastHeartbeatTime;
if (rtt > 0) {
if (TimeUtility.LobbyAverageRoundtripTime == 0)
TimeUtility.LobbyAverageRoundtripTime = rtt;
else
TimeUtility.LobbyAverageRoundtripTime = (long)(TimeUtility.LobbyAverageRoundtripTime * 0.7f + rtt * 0.3f);
}
}
private void OnOpened()
{
//首先校验版本
NodeMessage versionMsg = new NodeMessage(LobbyMessageDefine.VersionVerify, (uint)0x01010101);
SendMessage(versionMsg);
}
protected static bool FromLeader(NodeMessage message)
{
return(message.Type == MessageType.Info || message.Type == MessageType.LogUpdate ||
message.Type == MessageType.LogCommit);
}
