public ServerMessage(IPEndPoint endpoint, byte[] data, Message trainMessage) { //EndPoint = new IPEndPoint(endpoint.Address, endpoint.Port); EndPoint = endpoint; Data = data; TrainMessage = trainMessage; }
/*******************************************************************/ /************************* PUBLIC METHODS **************************/ /*******************************************************************/ /// <summary> /// Handles the given message. /// </summary> public void Handle(Message message) { lock (systemTracker) { handle(message); } }
public void SendMessageArrayTest() { SystemInformation info = new SystemInformation(); info.CountCore = 4; info.PasswordsPerSecond = 100000; Agent agentOne = new Agent(0, info, @".\private$\SendMessageArrayTestSend1", @".\private$\SendMessageArrayTestReceive1"); Agent agentTwo = new Agent(0, info, @".\private$\SendMessageArrayTestSend2", @".\private$\SendMessageArrayTestReceive2"); Agent agentThree = new Agent(0, info, @".\private$\SendMessageArrayTestSend3", @".\private$\SendMessageArrayTestReceive3"); if (!MessageQueue.Exists(agentOne.QueueReceiveName)) { MessageQueue.Create(agentOne.QueueReceiveName); } if (!MessageQueue.Exists(agentTwo.QueueReceiveName)) { MessageQueue.Create(agentTwo.QueueReceiveName); } if (!MessageQueue.Exists(agentThree.QueueReceiveName)) { MessageQueue.Create(agentThree.QueueReceiveName); } agentOne.SetConnect(); agentTwo.SetConnect(); agentThree.SetConnect(); Communication.Message testMessage = new Communication.Message(0, 0); PingMessage pingMessage = new Communication.PingMessage(0, 0); Communication.Message[] arrayMessage = { testMessage, pingMessage }; List <Agent> agentList = new List <Agent>() { agentOne, agentTwo, agentThree }; ProcessingMessage.SendMessageArray(arrayMessage, agentList); foreach (var itemAgent in agentList) { var messageObj = itemAgent.QueueReceive.Receive(); Communication.Message message = (Communication.Message)messageObj.Body; Assert.AreEqual(message.TypeMessage, (int)EnumTypeMessage.Message); messageObj = itemAgent.QueueReceive.Receive(); message = (Communication.Message)messageObj.Body; Assert.AreEqual(message.TypeMessage, (int)EnumTypeMessage.PingMessage); } MessageQueue.Delete(@".\private$\SendMessageArrayTestReceive1"); MessageQueue.Delete(@".\private$\SendMessageArrayTestReceive2"); MessageQueue.Delete(@".\private$\SendMessageArrayTestReceive3"); }
/*******************************************************************/ /****************** PRIVATE / PROTECTED METHODS ********************/ /*******************************************************************/ protected override void handle(Message message) { if (message.GetType() == typeof(SolveRequestResponseMessage)) handleSolverRequestResponseMessage((SolveRequestResponseMessage)message); else if (message.GetType() == typeof(SolutionsMessage)) handleSolutionsMessage((SolutionsMessage)message); else if (message.GetType() == typeof(NoOperationMessage)) handleNoOperationMessage((NoOperationMessage)message); else throw new NotImplementedException("Unknow message"); }
/// <summary> /// обработчик пустого сообщения /// </summary> /// <param name="quere">очередь откуда пришло сообщение</param> /// <param name="message">приянтое сообщение</param> public static bool ProcessingMessag(MessageQueue quere, Communication.Message message) { try { Console.WriteLine("ControllAplication idSender:" + message.IdSender + " idIdRecepient:" + message.IdRecepient); } catch (Exception e) { Console.WriteLine(e.Message); return(false); } return(true); }
/// <summary> /// Функция ждет когда управляющее приложение отправит сообщение с именем очереди /// и присвоенным id агенту, подключается к этой очереди /// </summary> /// <returns> /// true если подключиться получилось, false если иначе /// </returns> public static bool Connecting(string nameQueue) { Console.WriteLine("Ожидание связи с управляющим приложнием..."); do { Agent.mainQuere = new MessageQueue(nameQueue); Thread.Sleep(1000); } while (!Agent.mainQuere.CanRead); Console.WriteLine("Соединение установлено!"); HalloMessage messagSend = new HalloMessage(0, Agent.IdAgent, Agent.Info); try { Agent.mainQuere.Formatter = new BinaryMessageFormatter(); Agent.mainQuere.Send(messagSend); var objMessage = Agent.mainQuere.Receive(); while (((Communication.Message)objMessage.Body).TypeMessage != (int)EnumTypeMessage.CreateQuereMessage) { Communication.Message tempMessage = new Communication.Message(0, Agent.IdAgent); tempMessage = (Communication.Message)objMessage.Body; Agent.mainQuere.Send(tempMessage); Thread.Sleep(1000); objMessage = Agent.mainQuere.Receive(); } CreateQuereMessage messageRead = (CreateQuereMessage)objMessage.Body; Agent.IdAgent = messageRead.IdRecepient; Agent.NameQueueReceive = messageRead.PathReceive; Agent.NameQueueSend = messageRead.PathSend; } catch (Exception e) { Console.WriteLine(e.Message); return(false); } Agent.QueueReceive = new MessageQueue("FormatName:DIRECT=OS:" + Agent.NameQueueReceive); Agent.QueueReceive.Formatter = new BinaryMessageFormatter(); Agent.QueueSend = new MessageQueue("FormatName:DIRECT=OS:" + Agent.NameQueueSend); Agent.QueueSend.Formatter = new BinaryMessageFormatter(); Agent.QueueSend.Send(messagSend); return(true); }
/// <summary> /// Функция проверяет подключился ли очередной агент к очереди quere и добавляет его в список aгентов, /// так же создается новая очередь сообщений, имя которой записывается в список очередей /// для работы с подключенным агентом создается новый поток /// </summary> /// <param name="quere"> /// имя просматриваемй очереди /// </param> /// public static int ChekMessage(MessageQueue quere) { var objMessage = quere.Receive(); Communication.Message messageRead = (Communication.Message)objMessage.Body; foreach (var item in MessageHandler) { if (item.Key == messageRead.TypeMessage) { item.Value.DynamicInvoke(quere, messageRead); return(item.Key); } } return(-1); }
// on check si l'utilisateur existe déjà ou est déjà connecté (c'est le serveur qui nous le dit) public void rcvMsg(Communication.Message message) { if (message.Msg == "ok") { home.Username = textBox1.Text; this.Close(); } else if (message.Msg == "no") { label3.Text = "This user does not exist !"; } else if (message.Msg == "connected") { label3.Text = "This user is already connected !"; } }
protected override void handle(Message message) { if (message != null) { if (message.GetType() == typeof(NoOperationMessage)) handleNoOperationMessage((NoOperationMessage)message); else if (message.GetType() == typeof(RegisterResponseMessage)) handleRegisterResponsenMessage((RegisterResponseMessage)message); else if (message.GetType() == typeof(SolvePartialProblemsMessage)) handleSolvePartialProblemsMessage((SolvePartialProblemsMessage)message); else Console.Write(" >> Unknow message type, can't handle it... \n\n"); } }
public void ChekMessageTestEmptyMessage() { if (!MessageQueue.Exists(@".\private$\ChekMessageTestEmptyMessage")) { MessageQueue.Create(@".\private$\ChekMessageTestEmptyMessage"); } MessageQueue testQueue = new MessageQueue(@".\private$\ChekMessageTestEmptyMessage"); testQueue.Formatter = new BinaryMessageFormatter(); Communication.Message testMessage = new Communication.Message(0, 0); testQueue.Send(testMessage); Assert.AreEqual(ProcessingMessage.ChekMessage(testQueue), (int)EnumTypeMessage.Message); MessageQueue.Delete(@".\private$\ChekMessageTestEmptyMessage"); }
private static void testChekMessageReceiveHalloMessage() { MessageQueue queue = new MessageQueue(@".\private$\ChekMessageTestReceiveHalloMessage"); queue.Formatter = new BinaryMessageFormatter(); var message = queue.Receive(); while (((Communication.Message)message.Body).TypeMessage != (int)EnumTypeMessage.CreateQuereMessage) { queue.Send(message); Thread.Sleep(1000); message = queue.Receive(); } MessageQueue queueSend = new MessageQueue(((CreateQuereMessage)message.Body).PathSend); queueSend.Formatter = new BinaryMessageFormatter(); Communication.Message messageSend = new Communication.Message(0, 0); queueSend.Send(messageSend); }
public static int ChekMessage(MessageQueue quere) { try { var objMessage = quere.Receive(); Communication.Message messageRead = (Communication.Message)objMessage.Body; foreach (var item in MessageHandler) { if (item.Key == messageRead.TypeMessage) { item.Value.DynamicInvoke(messageRead); return(item.Key); } } } catch (Exception e) { Console.WriteLine(e.Message); } return(-1); }
/* * Deals with all server based messsages */ public void Receiver() { bool cancel = false; do { Message msg = Net.rcvMsg(comm); if (msg is TopicInfo) { // View Topics Response ListTopics.Items.Clear(); ListTopics.Items.AddRange(((TopicInfo)msg).TList.ToArray()); } else if (msg is ChatMessage) { ChatMessage message = (ChatMessage)msg; if (message is DirectMessage) { DMsBox.AppendText(message + Environment.NewLine); } else { if (message.MType == (int)MTypes.CHATLEAVE) { cancel = true; } else if (message.MType == (int)MTypes.CHATWELCOME) { MessagesBox.AppendText(message.Sender + " joined the Topic!" + Environment.NewLine); } else { MessagesBox.AppendText(message + Environment.NewLine); } } } } while (!cancel); }
private void button1_Click(object sender, EventArgs e) { if (usernameTextBox.Text != "" && passwordTextBox.Text != "") { Net.sendMsg(comm.GetStream(), new Request("signUp", usernameTextBox.Text, passwordTextBox.Text)); Communication.Message m = Net.rcvMsg(comm.GetStream()); if (m.GetType() == typeof(Communication.User)) { Program.currentUser = (User)m; Program.connected = true; this.Close(); } else if (m.GetType() == typeof(Communication.Error)) { Error error = (Error)m; errorLabel.Text = error.ToString(); } } else { errorLabel.Text = "Please enter credentials"; } }
/*******************************************************************/ /************************ PRIVATE METHODS **************************/ /*******************************************************************/ /*******************************************************************/ /************************* PUBLIC METHODS **************************/ /*******************************************************************/ /// <summary> /// Sends status to the server and waits for response /// </summary> public void Communicate(Message message) { List<Message> messages = new List<Message>(); messages.Add(message); this.Communicate(messages); }
public MessagePackage(Message message, Socket socket) { Message = message; Socket = socket; }
/*******************************************************************/ /******************* PRIVATE / PROTECTED METHODS *******************/ /*******************************************************************/ /// <summary> /// Handle /// </summary> /// <param name="message"></param> protected abstract void handle(Message message);
/// <summary> /// Write a message to Arduino /// </summary> /// <param name="message"></param> /// <returns></returns> public byte Write(Message message) { message.Header[0] = message.Action; message.Header[1] = message.DataLen; this.Write(message.Begin, 0, 2); this.Write(message.Header, 0, 2); this.Write(message.Data, 0, message.DataLen); this.Write(message.End, 0, 2); return (byte)(message.DataLen + 6); }
/// <summary> /// Read messages from the Arduino /// </summary> /// <param name="message"></param> /// <returns>Returns amount of bytes</returns> public byte Read(Message message) { if (this.BytesToRead > 5 && this.ReadByte() == message.Begin[0] && this.ReadByte() == message.Begin[1]) { //Read action & Data lenght message.Action = (byte)this.ReadByte(); message.DataLen = (byte)this.ReadByte(); if (message.DataLen > 58) { message.DataLen = 58; } this.Read(message.Data, 0, message.DataLen); message.Data[message.DataLen] = 0; //Corruption check this.Read(message.Corruptioncheck, 0, 2); message.PossiblyCorrupt = message.Corruptioncheck[0] != message.End[0] || message.Corruptioncheck[1] != message.End[1]; return (byte)(message.DataLen + 6); } return 0; }
private void InformBackup(Message message) { s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); int length = clientTracker.BackupServers.Length; // If this is primary server and it has atleast one backup if (Server.primaryMode && length > 0) { BackupCommunicationServer bserver = clientTracker.BackupServers[0]; IPAddress address = IPAddress.Parse(bserver.address); int port = bserver.port; s.Connect(address, port); server.Send(s, message); SmartConsole.PrintLine("Informed Backup Server: " + address.ToString() + ":" + port, SmartConsole.DebugLevel.Advanced); } // If this is one of the backups else { // Find yourself, and inform next backup for(int i = 0; i < length ; i++) { BackupCommunicationServer bserver = clientTracker.BackupServers[i]; if (server.Address.ToString().Equals(bserver.address) && server.Port == bserver.port) { if (i + 1 < length) { BackupCommunicationServer bserverToSend = clientTracker.BackupServers[i+1]; IPAddress address = IPAddress.Parse(bserverToSend.address); int port = bserverToSend.port; s.Connect(address, port); server.Send(s, message); SmartConsole.PrintLine("Informed Backup Server: " + address.ToString() + ":" + port, SmartConsole.DebugLevel.Advanced); } } } } }
public static void ProcessingMessag(Communication.Message message) { Console.WriteLine(message.TypeMessage + "Agent idSender:" + message.IdSender); }
//private void Tick(Object source, ElapsedEventArgs args) private void _timer_Tick(object sender, EventArgs e) { foreach(KeyValuePair<Arduino, IPEndPoint> train in new Dictionary<Arduino, IPEndPoint>(_ARDUINO2IP)) { try { IPEndPoint endpoint = _ARDUINO2IP[train.Key]; Train realTrain = _ARDUINO2TRAIN[train.Key]; if (train.Key.IsConnected) { //retrieve serial messages { Message message = new Message(); while (train.Key.Read(message) > 0) { //perform connection of arduino to the system switch ((Actions)message.Action) { case Actions.TRAIN_CONNECTME: { string name = System.Text.Encoding.ASCII.GetString(message.Data).Replace("\0", ""); IPEndPoint connection = TrafficMessage.ConnectMeEx(ObjectType.Train, name, train.Value); if (connection != null) { _ARDUINO2IP[train.Key] = connection; endpoint = connection; train.Key.Write(new Message((byte)Actions.TRAIN_CONNECTIONOK)); administration.Add(realTrain); } else { train.Key.Write(new Message((byte)Actions.TRAIN_CONNECTIONFAIL)); } } break; case Actions.TRAIN_I_AM_GOING_TO_NEXT_STATION: realTrain.UpdateNextStation(); break; //TODO case for whatsmyconnectionstatus default: //else if not connection just send the message to the next station { ServerMessage sm = new ServerMessage(); if (realTrain.NextStation != null && realTrain.NextStation.Address != null) { sm.EndPoint = realTrain.NextStation.Address; sm.TrainMessage = message; TrafficMessage.SendMessageEx(sm, train.Value); } } break; } message = new Message(); } } //send new messages to arduino (train) { List<ServerMessage> messages = new List<ServerMessage>(); if (TrafficMessage.RetrieveAllMessagesEx(out messages, train.Value)) { foreach (ServerMessage sm in messages) { if (sm.TrainMessage != null) { train.Key.Write(sm.TrainMessage); } } } } } } catch(Exception ex) { Console.WriteLine(ex.Message); } } }
/*******************************************************************/ /************************* 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); } } }
/// <summary> /// Sends a message to the socket /// </summary> /// <param name="socket"></param> /// <param name="message"></param> public void Send(Socket socket, Message message) { List<Message> messages = new List<Message>(); messages.Add(message); try { //base.Send(socket, message); base.Send(socket, messages); } catch (SocketException e) { Console.Write(" >> [Send] Socket unavaible, removing connection... \n"); RemoveConnection(socket); } }