/// <summary>
/// SolveRequest is sent by Computational Client
/// </summary>
/// <param name="messagePackage"></param>
private void handleSolveRequestMessage(MessagePackage messagePackage)
{
SolveRequestMessage message = (SolveRequestMessage)messagePackage.Message;
InformBackup(message);
// if the cluster can solve this problem
if (clientTracker.CanSolveProblem(message.ProblemType))
{
Task task = new Task((int)systemTracker.GetNextTaskID(), message.ProblemType,
message.Data);
taskTracker.AddTask(task);
if (Server.primaryMode)
{
NoOperationMessage responseNoOp = new NoOperationMessage(clientTracker.BackupServers);
SolveRequestResponseMessage response = new SolveRequestResponseMessage((ulong)task.ID);
List <Message> messages = new List <Message>();
messages.Add(responseNoOp);
messages.Add(response);
server.Send(messagePackage.Socket, messages);
SmartConsole.PrintLine("Sent a SolveRequestResponse Message", SmartConsole.DebugLevel.Basic);
}
}
else
{
//TODO RESPONSE MESSAGE
Console.Write(" >> TM ERROR\n");
}
}
private static MessagePackage CrateTestPackage()
{
MessagePackage package =
new MessagePackage($"{nameof(RollbarClientFixture)}.BasicTest");
return(package);
}
private void btnLoad_Click(object sender, EventArgs e)
{
if (this.textBoxServerIP.Text != "" && this.textBoxNickName.Text != "")
{
ServerIP = this.textBoxServerIP.Text;
NickName = this.textBoxNickName.Text;
IPAddress ipadd;
if (MrOwlNetWork.GetLocalIP(out ipadd))
{
Program.ThisGameMrowlTcpClient = new MrOwlTCPClient(ipadd, "4566");
Program.ThisGameMrowlTcpClient.FuncChuLiMessage = DealMsg;
}
if (Program.ThisGameMrowlTcpClient.ConnectSever(ServerIP, "4566"))
{
Program.ThisGamePlayer = new Player(ipadd.ToString(), NickName, ChessPieceType.None);
listenThread = new Thread(new ThreadStart(Program.ThisGameMrowlTcpClient.GetMessage));
listenThread.IsBackground = true;
listenThread.Start();
MessagePackage sendPkg = new MessagePackage("LianJie", "用户登录：" + NickName, Program.ThisGamePlayer.IP, Program.ThisGamePlayer.NickName, DateTime.Now.ToString("yy-MM-dd hh:mm:ss"));
if (!Program.ThisGameMrowlTcpClient.SendMessage(sendPkg.MsgPkgToString()))
{
MessageBox.Show("消息发送失败！");
}
}
else
{
MessageBox.Show("连接服务器失败！", "错误！");
}
}
else
{
MessageBox.Show("服务器IP和用户名不能为空！");
return;
}
}
/// <summary>
/// 组装数据包
/// </summary>
/// <param name="MsgType"></param>
/// <param name="data"></param>
/// <returns></returns>
private string GetMsgPackage(MessagePackage package)
{
string value = @"<hytera>
<product_name>{0}</product_name>
<version>{1}</version>
<objectid>{2}</objectid>
<objecttype>{3}</objecttype>
<cmd_guid>{4}</cmd_guid>
<cmd_name>{5}</cmd_name>
<cmd_time>{6}</cmd_time>
<cmd_content>{7}</cmd_content>
</hytera> ";
value = string.Format(
value,
"EEMS",
"1.0",
string.Empty,
string.Empty,
string.Empty,
package.MsgType,
DateTime.Now.ToString("yyyyMMdd HHmmss"),
package.Data == null || package.Data.ToString() == "" ? string.Empty : XmlUnityConvert.XmlSerialize(package.Data)
);
LogHelper.Instance.WirteLog("SendMessage:" + value, LogLevel.LogDebug);
return(value);
}
public ChannelProcessResult ProcessSubscriberMessage(MessagePackage message)
{
if (MessageEntryHelper.MatchEntryCriteria(_param, message, _config.EntryControl))
{
if (_pipeLine.Process(message))
{
string msgXml = message.GetMessageXml();
Message msg = XObjectManager.CreateObject <Message>(msgXml);
if (msg == null)
{
return(ChannelProcessResult.ProcessingError);
}
msg.Header.ID = Guid.NewGuid();
msg.Header.Type = _config.PublishMessageType;
if (_param.Sender.NotifyMessagePublish(msg))
{
return(ChannelProcessResult.Success);
}
else
{
return(ChannelProcessResult.SendingError);
}
}
else
{
return(ChannelProcessResult.ProcessingError);
}
}
else
{
return(ChannelProcessResult.NotMatchEntryCriteria);
}
}
public AreaList getarealist()
{
MessagePackage message = new MessagePackage();
AreaList arealist = new AreaList();
XmlDocument response = GameUtil.getarealist();
try
{
XmlNodeList nodelist = response.SelectNodes(
"/response/body/exploration_area/area_info_list/area_info");
foreach (XmlNode child in nodelist)
{
debugstring = child.InnerText;
Area area = new Area();
area.Areaid = child["id"].InnerText;
area.AreaName = child["name"].InnerText;
area.AreaProg = child["prog_area"].InnerText;
area.CardProg = child["prog_item"].InnerText;
area.AreaType = child["area_type"].InnerText;
arealist.arealist.Add(area);
}
message.result = arealist;
return(arealist);
}
catch (System.NullReferenceException)
{
return(getarealist());
}
}
/// <summary>
/// 写网络流
/// </summary>
/// <param name="obj">网络流</param>
static void WriteMessage(NetworkStream stream, string account)
{
try
{
var formater = new BinaryFormatter();
while (true)
{
Console.WriteLine("请输入朋友名字：");
var friendName = Console.ReadLine();
Console.WriteLine("输入发送内容：");
var content = Console.ReadLine();
var messagePackage = new MessagePackage {
Content = content, Sender = account, SendTime = DateTime.Now, Accepter = friendName
};
formater.Serialize(stream, messagePackage);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($@"-------------------发送到的消息-开始--------------------
我 :{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}
{content}
-------------------发送到的消息-开始--------------------");
Console.ResetColor();
Thread.Sleep(1000);
}
}
catch (Exception exc)
{
Console.WriteLine(exc.Message);
}
}
public async Task ReadStateAsync()
{
// arrange
const string key = "key";
var result = new MessagePackage
{
Type = _model.GetType().FullName,
Payload = JsonSerializer.Serialize(_model)
};
_databaseMock
.Setup(x => x.StringGetAsync(key, CommandFlags.None))
.Returns(Task.FromResult(new RedisValue(JsonSerializer.Serialize(result))));
_typeResolverMock
.Setup(x => x.ResolveType(result.Type))
.Returns(typeof(ExampleModel));
// act
await _storageService.ReadStateAsync(
_databaseMock.Object,
_typeResolverMock.Object,
_grainState,
key);
// assert
Assert.Equal(_model, _grainState.State);
}
/// <summary>
/// Creates a new instance of type Message
/// </summary>
/// <param name="messagePackage"></param>
public Message(MessagePackage messagePackage)
{
Sender = messagePackage.Sender;
Receiver = messagePackage.Receiver;
TimeReceived = messagePackage.TimeReceived;
Text = messagePackage.Text;
}
/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
public void Communicate(Message message)
{
lock (this)
{
while (!client.Connected)
{
SmartConsole.PrintLine("Lost connection, reconnecting...", SmartConsole.DebugLevel.Advanced);
client.Connect();
}
// Send to server
client.Send(message);
// Wait for response
List <Message> responseMessage = client.ReceiveMessages();
for (int i = 0; i < responseMessage.Count; i++)
{
// handle response
// This is wrong Socket, but we dont use it anyway.
MessagePackage package = new MessagePackage(responseMessage[i], client.Socket);
messageHandler.HandleMessage(package);
}
}
}
public string PrepareMessage(Message msg, bool sign, BackgroundWorker.ProgressMessage OnProgress)
{
OnProgress = OnProgress ?? delegate { };
var payload = new MessagePayload();
payload.type = "text";
payload.blob = Convert.ToBase64String(Encoding.UTF8.GetBytes(msg.Text));
payload.timestamp = (int)(msg.Date - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds;
if (sign)
{
OnProgress(false, "Signing");
var sig = SignerUtilities.GetSigner("RSASSA-PSS");
sig.Init(true, Crypto.ReadKey(App.Instance.Config.PrivateKey));
var bytes = Encoding.UTF8.GetBytes(msg.Text);
sig.BlockUpdate(bytes, 0, bytes.Length);
payload.signature = Convert.ToBase64String(sig.GenerateSignature());
payload.sender_key = Crypto.SanitizeKey(App.Instance.Config.PublicKey);
}
var payloadJson = JsonConvert.SerializeObject(payload);
var iv = new byte[16];
var key = new byte[32];
new SecureRandom().NextBytes(iv);
new SecureRandom().NextBytes(key);
var aes = new AesManaged();
aes.Padding = PaddingMode.PKCS7;
aes.KeySize = 256;
aes.Mode = CipherMode.CBC;
aes.Key = key;
aes.IV = iv;
OnProgress(false, "Encrypting");
var encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
var memory = new MemoryStream();
var cryptoStream = new CryptoStream(memory, encryptor, CryptoStreamMode.Write);
using (var sw = new StreamWriter(cryptoStream))
{
sw.Write(payloadJson);
sw.Flush();
cryptoStream.FlushFinalBlock();
}
cryptoStream.Close();
OnProgress(false, "Packing");
var package = new MessagePackage();
package.data = Convert.ToBase64String(memory.ToArray());
package.iv = Convert.ToBase64String(Crypto.Encrypt(iv, Crypto.ReadKey(msg.ContactKey)));
package.key = Convert.ToBase64String(Crypto.Encrypt(key, Crypto.ReadKey(msg.ContactKey)));
package.recipient_key = msg.ContactKey;
return(JsonConvert.SerializeObject(package));
}
/// <summary>
/// 发送线程
/// </summary>
private void SendMsgThread()
{
new Thread(() =>
{
while (isSend)
{
try
{
MessagePackage package = null;
if (msgList.Count > 0)
{
lock (((ICollection)msgList).SyncRoot)
{
package = msgList.Dequeue();
}
}
if (IceHelper.Instance.Client != null && package != null)
{
IceHelper.Instance.Client.TransDataFromClient(IceHelper.Instance.ClientID, GetMsgPackage(package));
}
}
catch { }
finally
{
Thread.Sleep(5);
}
}
})
{
IsBackground = true
}.Start();
}
/// <summary>
/// 发送本文消息
/// </summary>
/// <param name="content">消息内容</param>
/// <param name="to">接收者</param>
/// <param name="userIds">被@对象集合,@ALL定义为值-1</param>
/// <param name="type">消息类型chat,groupchat</param>
/// <returns>id</returns>
public static string Sendtxt(string content, string to, IList <int> userIds = null, chatType type = chatType.chat, string groupName = null, SDKProperty.SessionType sessionType = SessionType.CommonChat, message.ReceiverInfo recverInfo = null)
{
MessagePackage package = new MessagePackage();
package.ComposeHead(to, SDKClient.Instance.property.CurrentAccount.userID.ToString());
package.data = new message()
{
body = new TxtBody()
{
text = content
},
senderInfo = new message.SenderInfo()
{
photo = SDKClient.Instance.property.CurrentAccount.photo,
userName = SDKClient.Instance.property.CurrentAccount.userName ?? SDKClient.Instance.property.CurrentAccount.loginId
},
receiverInfo = recverInfo,
chatType = to == SDKClient.Instance.property.CurrentAccount.userID.ToString() ? (int)SessionType.FileAssistant : (int)sessionType,
subType = "txt",
tokenIds = userIds,
type = type == chatType.chat ? nameof(chatType.chat) : nameof(chatType.groupChat)
};
if (type == chatType.groupChat)
{
package.data.groupInfo = new message.msgGroup()
{
groupId = to.ToInt(),
groupName = groupName
};
}
package.Send(SDKClient.Instance.ec);
return(package.id);
}
//发送服务器关闭消息
private void SendServerQuit(Socket socket)
{
MessagePackage responsePkg = new MessagePackage("ServerQuit", "",
this.mrowlTCPListener.localIP.ToString(), "Server", DateTime.Now.ToString("yy-MM-dd HH:mm:ss"));
this.mrowlTCPListener.SendToClient(socket, responsePkg.MsgPkgToString());
}
//向所有连接的客户端发送房间列表
private void SendRoomList(Socket userSocket)
{
MessagePackage exitMsgPkg = new MessagePackage("RoomList", GetRoomListString()
, mrowlTCPListener.localIP.ToString(), "Server", DateTime.Now.ToString("yy-MM-dd HH:mm:ss"));
mrowlTCPListener.SendToClient(userSocket, exitMsgPkg.MsgPkgToString());
}
//向服务器发送退出请求
public static void SendCommandTuiChu()
{
MessagePackage sendMsgPkg = new MessagePackage("TuiChu", Program.ThisGamePlayer.NickName,
Program.ThisGamePlayer.IP, Program.ThisGamePlayer.NickName, DateTime.Now.ToString("yy-MM-dd HH:mm:ss"));
Program.ThisGameMrowlTcpClient.SendMessage(sendMsgPkg.MsgPkgToString());
}
//发送创建房间的响应
private void SendCreatRoomResponse(Socket clientSocket)
{
MessagePackage responsePkg = new MessagePackage("CreatRoomResponse", "Success",
this.mrowlTCPListener.localIP.ToString(), "Server", DateTime.Now.ToString("yy-MM-dd HH:mm:ss"));
this.mrowlTCPListener.SendToClient(clientSocket, responsePkg.MsgPkgToString());
}
public void TruncatePayloadTest()
{
MessagePackage package = new MessagePackage(ProduceLongMessage());
using var logger = FakeLogger();
PayloadBundle bundle = new PayloadBundle(logger, package, ErrorLevel.Error);
var payload = bundle.GetPayload();
Assert.IsNotNull(payload);
string jsonData = JsonConvert.SerializeObject(payload);
Assert.IsNotNull(jsonData);
int untruncatedLength = jsonData.Length;
var truncator = new RollbarPayloadTruncator(null);
bool result = truncator.TruncatePayload(bundle);
payload = bundle.GetPayload();
Assert.IsNotNull(payload);
jsonData = JsonConvert.SerializeObject(payload);
Assert.IsNotNull(jsonData);
int truncatedLength = jsonData.Length;
Assert.IsTrue(untruncatedLength > truncatedLength);
}
private async void Handle(MessagePackage <CustomerDTO> message)
{
var customer = message.Entity;
try
{
var service = serviceFunc();
var repo = repoFunc();
var request = new GetShoppingCartByCustomerRequest(customer.AnonymousId);
var response = await service.GetCartAsync(request);
var cart = await repo.GetCartByIdAsync(response.ShoppingCart.Id);
cart.UpdateCustomer(customer.AnonymousId, customer.Id);
await repo.SaveAsync(cart);
//TODO change the order after debugging is completed
await this.Complete(message.Message);
}
catch (Exception ex)
{
await base.Abandon(message.Message);
}
}
/// <summary>
/// Solutions is sent by every node to give info
/// about ongoing computations or final solutions
/// </summary>
/// <param name="messagePackage"></param>
private void handleSolutionsMessage(MessagePackage messagePackage)
{
SolutionsMessage message = (SolutionsMessage)messagePackage.Message;
InformBackup(message);
Task task = taskTracker.GetTask((int)message.Id);
//IT HAS TO BE CHANGED AFTER ADDING SUBTASK ID @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
if (message.Solutions[0].Type == SolutionsSolutionType.Final)
{
task.Solutions = message.Solutions;
task.Status = TaskStatus.Merged;
}
else
{
for (int i = 0; i < task.subTasks.Count; i++)
{
if (task.subTasks[i].Status == TaskStatus.Solving)
{
task.subTasks[i].Status = TaskStatus.Solved;
task.subTasks[i].Solutions = message.Solutions;
break;
}
}
}
if (Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message", SmartConsole.DebugLevel.Basic);
}
}
public void MessagePackageTest()
{
const string rollbarDataTitle = "Got a message...";
const string message = "My message to report to Rollbar";
IDictionary <string, object> extraInfo = new Dictionary <string, object>()
{
{ "extra1", "Info 1" },
{ "extra2", "Info 2" },
};
IRollbarPackage packagingStrategy =
new MessagePackage(message, rollbarDataTitle, extraInfo);
Assert.IsFalse(packagingStrategy.MustApplySynchronously, "Expected to be an async strategy!");
Data rollbarData = packagingStrategy.PackageAsRollbarData();
Assert.AreEqual(rollbarDataTitle, rollbarData.Title, "Data title is properly set!");
Assert.IsNotNull(rollbarData.Body);
Assert.IsNotNull(rollbarData.Body.Message);
Assert.IsNull(rollbarData.Body.Trace);
Assert.IsNull(rollbarData.Body.TraceChain);
Assert.IsNull(rollbarData.Body.CrashReport);
Assert.AreEqual(3, rollbarData.Body.Message.Count);
Assert.AreEqual(message, rollbarData.Body.Message.Body);
Assert.IsTrue(rollbarData.Body.Message.ContainsKey("body"));
Assert.IsTrue(rollbarData.Body.Message.ContainsKey("extra1"));
Assert.IsTrue(rollbarData.Body.Message.ContainsKey("extra2"));
Assert.AreEqual(message, rollbarData.Body.Message["body"]);
Assert.AreEqual("Info 1", rollbarData.Body.Message["extra1"]);
Assert.AreEqual("Info 2", rollbarData.Body.Message["extra2"]);
}
private void SendChessPieceToServer(ChessPiece piece)
{
MessagePackage sendPkg = new MessagePackage("LuoZi", MessagePackage.LuoZiMsgToStirng(piece)
, Program.ThisGamePlayer.IP, Program.ThisGamePlayer.NickName, DateTime.Now.ToString("yy-MM-dd HH:mm:ss"));
Program.ThisGameMrowlTcpClient.SendMessage(sendPkg.MsgPkgToString());
}
//发送重新开始游戏的请求
private void SendCommandReverRequest()
{
MessagePackage sendPkg = new MessagePackage("RequestRevertGame", Program.ThisGamePlayer.NickName + "请求重新开始游戏", Program.ThisGamePlayer.IP, Program.ThisGamePlayer.NickName, DateTime.Now.ToString("yy-MM-dd hh:mm:ss"));
Program.ThisGameMrowlTcpClient.SendMessage(sendPkg.MsgPkgToString());
isSendRevertCommand = true;
}
//发送退出房间的请求
private void SendCommandExitRoom()
{
MessagePackage sendMsgPkg = new MessagePackage("ExitRoom", Program.ThisGamePlayer.NickName,
Program.ThisGamePlayer.IP, Program.ThisGamePlayer.NickName, DateTime.Now.ToString("yy-MM-dd HH:mm:ss"));
Program.ThisGameMrowlTcpClient.SendMessage(sendMsgPkg.MsgPkgToString());
}
/// <summary>
/// this function is a response to task manager status message
/// </summary>
/// <param name="networkNode"></param>
/// <param name="messagePackage"></param>
private void ReactToTaskManagerStatusMessage(NetworkNode networkNode, MessagePackage messagePackage)
{
//checks if divide or merge solution message has been sent. If not than send noOperation message.
bool hasMessageBeenSent = false;
int numberOfAvaliableThreads = AvaliableThreadsCount(networkNode);
for (int i = 0; i < taskTracker.Tasks.Count && numberOfAvaliableThreads > 0; i++)
{
if (isMessageProblemDividedSent(i, networkNode, messagePackage))
{
hasMessageBeenSent = true;
numberOfAvaliableThreads--;
}
}
// If there are avaliable threads than try to send merge solution message
for (int i = 0; i < taskTracker.Tasks.Count && numberOfAvaliableThreads > 0; i++)
{
if (isMergeSolutionSent(i, networkNode, messagePackage))
{
hasMessageBeenSent = true;
numberOfAvaliableThreads--;
}
}
//if divideProblemMessage hasn't been sent than send noOperationMessage
if (hasMessageBeenSent == false && Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message. 0 tasks to divide or 0 apropriate task managers", SmartConsole.DebugLevel.Basic);
}
}
//发送进入房间的响应
private void SendGetInRoomResponse(Room room)
{
MessagePackage responsePkg = new MessagePackage("GetInRoomResponse", MessagePackage.RoomInfoToString(room),
this.mrowlTCPListener.localIP.ToString(), "Server", DateTime.Now.ToString("yy-MM-dd HH:mm:ss"));
this.mrowlTCPListener.SendToClient(room.RoomMaster.UserSocket, responsePkg.MsgPkgToString());
this.mrowlTCPListener.SendToClient(room.RoomMember.UserSocket, responsePkg.MsgPkgToString());
}
//发送落子消息的响应
private void SendLuoZiResponse(Room room, string pieceInfoStr)
{
MessagePackage responsePkg = new MessagePackage("LuoZiResponse", pieceInfoStr,
this.mrowlTCPListener.localIP.ToString(), "Server", DateTime.Now.ToString("yy-MM-dd HH:mm:ss"));
this.mrowlTCPListener.SendToClient(room.RoomMaster.UserSocket, responsePkg.MsgPkgToString());
this.mrowlTCPListener.SendToClient(room.RoomMember.UserSocket, responsePkg.MsgPkgToString());
}
private void handleNoOperationMessage(MessagePackage package)
{
NoOperationMessage message = (NoOperationMessage)package.Message;
clientTracker.BackupServers = message.BackupCommunicationServers;
SmartConsole.PrintLine("Current Backup count: " + clientTracker.BackupServers.Length, SmartConsole.DebugLevel.Basic);
}
public bool ProcessMessage(MessagePackage message)
{
try
{
string xmlString;
try
{
Message msg = XObjectManager.CreateObject<Message>(message.GetMessageXml());
TextReader tr = new StringReader(msg.Body);
//XmlDocument doc = new XmlDocument();
//doc.LoadXml(msg.Body);
//XPathDocument doc = new XPathDocument(tr);
Stream tmpS = new MemoryStream();
XmlWriter xw = new XmlTextWriter(tmpS, null);
//XPathNavigator nav = doc.CreateNavigator();
try
{
xslt.Transform(XmlReader.Create(tr), xw);
xw.Flush();
tmpS.Position = 0;
StreamReader sr = new StreamReader(tmpS);
xmlString = sr.ReadToEnd();
sr.Close();
}
catch (Exception ex)
{
throw (ex);
}
finally
{
xw.Close();
tmpS.Close();
}
msg.Body = xmlString;
message.SetMessageXml(msg.ToXMLString(), _config.DeviceName);
}
catch (Exception ee)
{
_param.Log.Write(LogType.Error, "Get error while transforming XML, " + ee.Message);
return false;
}
return true;
}
catch (Exception e)
{
WriteLog(e);
return false;
}
}
private void handleRegisterResponsenMessage(MessagePackage package)
{
RegisterResponseMessage message = (RegisterResponseMessage)package.Message;
systemTracker.Node.Id = message.Id;
systemTracker.Node.Timeout = message.Timeout;
systemTracker.Node.BackupServers = message.BackupCommunicationServers;
clientTracker.BackupServers = message.BackupCommunicationServers;
}
/// <summary>
/// Support for handling Partial Problems message.
/// Node mocks working on partial problem and sends partial solution to server.
/// </summary>
/// <param name="package"></param>
private void ProcessPartialProblemsMessage(MessagePackage package)
{
var message = (SolvePartialProblems)package.ClusterMessage;
var problemInstanceId = message.Id;
var partialProblem = message.PartialProblems[0];
var taskId = partialProblem.TaskId;
Console.WriteLine("Received partial problem {0} from problem instance {1}.", taskId, problemInstanceId);
CreateAndSendPartialSolution(message, partialProblem);
}
public void Send(MessagePackage package)
{
if (package.MessageBody.Length > 0)
{
if (package.MessageBody[0] > 0)
new Timer((object state) =>
{
Passing.Receiver(package);
}, null, package.MessageBody[0] * 100, Timeout.Infinite);
else
Passing.Receiver(package);
}
else
Passing.Receiver(package);
}
/// <summary>
/// Method recognizes error received from server and logs info.
/// </summary>
/// <param name="message"></param>
protected void HandleErrorMessage(MessagePackage message)
{
var errorMessage = (Error)message.ClusterMessage;
switch (errorMessage.ErrorType)
{
case ErrorErrorType.ExceptionOccured:
Console.WriteLine("Error message from server: Exception occured.");
break;
case ErrorErrorType.InvalidOperation:
Console.WriteLine("Error message from server: Invalid operation.");
break;
case ErrorErrorType.UnknownSender:
Console.WriteLine("Error message from server: Unknow sender.");
break;
}
Console.WriteLine(errorMessage.ErrorMessage);
}
private void RightSideMessageArrive_TestSimpleMsgCallback(MessageArriveCode code, MessagePackage package)
{
Assert.True(code == MessageArriveCode.Ok);
Assert.Equal(package.MessageBody, new byte[] { 3, 120, 240, 67, 89, 12, 123, 45, 156, 165, 123, 155 });
}
private void RightSideMessageArrive_TestSimpleMsg(MessageArriveCode code, MessagePackage package)
{
Assert.True(code == MessageArriveCode.Ok);
Assert.Equal(package.MessageBody, new byte[] { 0, 120 });
_event1.Set();
}
private void RightSideMessageArrive(MessageArriveCode code, MessagePackage package)
{
Assert.True(code == MessageArriveCode.Ok);
}
private void RightSideMessageArrive_TestMultipleMsgCallback(MessageArriveCode code, MessagePackage package)
{
System.Diagnostics.Debug.WriteLine(string.Format("Arrived from 666 to 111, messageID: {0} - body: {1}", package.MessageID.ToString(), System.Text.Encoding.ASCII.GetString(package.MessageBody)));
Assert.True(code == MessageArriveCode.Ok);
}
/// <summary>
/// Support for processing DivideProblem message.
/// Currently, method creates 5 partial problems for each problem instance and sends them to server.
/// </summary>
/// <param name="package">Divide problem message to be processed.</param>
private void ProcessDivideProblem(MessagePackage package)
{
var message = (DivideProblem)package.ClusterMessage;
var problemInstanceId = message.Id;
Console.WriteLine("Received problem {0} to divide.", problemInstanceId);
DivideAndSendPartialProblems(message);
Console.WriteLine("Sent partial problems for problem {0}", problemInstanceId);
}
/// <summary>
/// Support for processing solutions messages.
/// After receiving Solutions, final solution is chosen from all solutions and is sent back to server.
/// Currently choosing final solution is random.
/// </summary>
/// <param name="package">Solutions message to be processed.</param>
private void ProcessSolutions(MessagePackage package)
{
var message = (Solutions)package.ClusterMessage;
var problemInstanceId = message.Id;
Console.WriteLine("Received partial solutions for problem {0}.", problemInstanceId);
ChooseAndSendFinalSolution(message);
Console.WriteLine("Sent final solution for problem {0}", problemInstanceId);
}
/// <summary>
/// Process registration response - retreive Id assigned by server and timeout.
/// </summary>
/// <param name="response"></param>
/// <returns>True on registration success, false otherwise.</returns>
protected bool ProcessRegisterResponse(MessagePackage response)
{
var message = (RegisterResponse) response.ClusterMessage;
Id = ulong.Parse(message.Id);
ServerTimeout = int.Parse(message.Timeout);
ServerTimeout *= 1000;
Console.WriteLine("Registered at server with Id: {0}.", Id);
return Id > 0;
}
/// <summary>
/// Method processing NoOperation message. Retreives backup info.
/// </summary>
/// <param name="package">Received NoOperation message.</param>
protected void ProcessNoOperationMessage(MessagePackage package)
{
if (LogAllInfo)
Console.WriteLine("Received NoOperation message.");
}
