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);
}
}
