/// <summary>
/// Deserializes a ControlMessage from a NGRIDControllerMessage.
/// </summary>
/// <param name="controllerMessage">NGRIDControllerMessage that includes ControlMessage</param>
/// <returns>Deserialized ControlMessage object.</returns>
private static ControlMessage DeserializeControlMessage(NGRIDControllerMessage controllerMessage)
{
return(NGRIDSerializationHelper.DeserializeFromByteArray(
() =>
ControlMessageFactory.CreateMessageByTypeId(controllerMessage.ControllerMessageTypeId),
controllerMessage.MessageData));
}
/// <summary>
/// Gets waiting messages for an NGRID server.
/// </summary>
/// <param name="nextServer">Next server name</param>
/// <param name="minId">Minimum Id (as start Id)</param>
/// <param name="maxCount">Max record count to get</param>
/// <returns>Records gotten from database.</returns>
public List <NGRIDMessageRecord> GetWaitingMessagesOfServer(string nextServer, int minId, int maxCount)
{
DataTable recordsTable;
lock (_syncObj)
{
recordsTable = GetTable(
"SELECT * FROM messages WHERE NextServer = @NextServer AND Id >= @Id ORDER BY Id ASC Limit @LimitValue",
new SQLiteParameter("@NextServer", nextServer),
new SQLiteParameter("@Id", minId),
new SQLiteParameter("@LimitValue", maxCount)
);
}
var recordsList = new List <NGRIDMessageRecord>(recordsTable.Rows.Count);
foreach (DataRow recordRow in recordsTable.Rows)
{
recordsList.Add(
new NGRIDMessageRecord
{
Id = Convert.ToInt32(recordRow["Id"]),
DestApplication = recordRow["DestApplication"] as string,
DestServer = recordRow["DestServer"] as string,
NextServer = recordRow["NextServer"] as string,
Message = NGRIDSerializationHelper.DeserializeFromByteArray(() => new NGRIDDataTransferMessage(), (byte[])recordRow["MessageData"]),
MessageId = recordRow["MessageId"] as string,
RecordDate = (DateTime)recordRow["RecordDate"]
});
}
return(recordsList);
}
/// <summary>
/// Serializes a message to send to NGRID server from Web Service.
/// </summary>
/// <param name="responseMessage">Message to serialize</param>
/// <returns>Serialized message</returns>
public static byte[] SerializeMessage(IWebServiceResponseMessage responseMessage)
{
CheckResponseMessage(responseMessage);
var response = ((ResponseMessage)responseMessage).CreateDataTransferResponseMessage();
return(NGRIDSerializationHelper.SerializeToByteArray(response));
}
/// <summary>
/// Gets waiting messages for an application.
/// </summary>
/// <param name="nextServer">Next server name</param>
/// <param name="destApplication">Destination application name</param>
/// <param name="minId">Minimum Id (as start Id)</param>
/// <param name="maxCount">Max record count to get</param>
/// <returns>Records gotten from database.</returns>
public List <NGRIDMessageRecord> GetWaitingMessagesOfApplication(string nextServer, string destApplication, int minId, int maxCount)
{
var recordsTable = GetTable(
"SELECT * FROM messages WHERE NextServer = ? AND DestApplication = ? AND Id >= ? ORDER BY Id ASC Limit ?;",
new OdbcParameter("?NextServer", nextServer),
new OdbcParameter("?DestApplication", destApplication),
new OdbcParameter("?Id", minId),
new OdbcParameter("?LimitValue", maxCount)
);
var recordsList = new List <NGRIDMessageRecord>(recordsTable.Rows.Count);
foreach (DataRow recordRow in recordsTable.Rows)
{
recordsList.Add(
new NGRIDMessageRecord
{
Id = Convert.ToInt32(recordRow["Id"]),
DestApplication = recordRow["DestApplication"] as string,
DestServer = recordRow["DestServer"] as string,
NextServer = recordRow["NextServer"] as string,
Message = NGRIDSerializationHelper.DeserializeFromByteArray(() => new NGRIDDataTransferMessage(), (byte[])recordRow["MessageData"]),
MessageId = recordRow["MessageId"] as string,
RecordDate = (DateTime)recordRow["RecordDate"]
}
);
}
return(recordsList);
}
/// <summary>
/// Sends a ControlMessage to NGRID server.
/// </summary>
/// <param name="message">Message to send</param>
public void SendMessage(ControlMessage message)
{
SendMessageInternal(new NGRIDControllerMessage
{
MessageData = NGRIDSerializationHelper.SerializeToByteArray(message),
ControllerMessageTypeId = message.MessageTypeId
});
}
/// <summary>
/// Sends a message to a spesific communicator as a reply to an incoming message.
/// </summary>
/// <param name="communicator">Communicator to send message</param>
/// <param name="message">Message to send</param>
/// <param name="incomingMessage">Incoming message which is being replied</param>
private void ReplyMessageToCommunicator(ICommunicator communicator, ControlMessage message, NGRIDControllerMessage incomingMessage)
{
//Create NGRIDControllerMessage that includes serialized GetApplicationListResponseMessage message
var outgoingMessage = new NGRIDControllerMessage
{
ControllerMessageTypeId = message.MessageTypeId,
MessageData = NGRIDSerializationHelper.SerializeToByteArray(message),
RepliedMessageId = incomingMessage.MessageId
};
//Send message to communicator that sent to message
SendMessage(outgoingMessage, communicator);
}
/// <summary>
/// Saves a NGRIDMessageRecord.
/// </summary>
/// <param name="messageRecord">NGRIDMessageRecord object to save</param>
/// <returns>Auto Increment Id of saved message</returns>
public int StoreMessage(NGRIDMessageRecord messageRecord)
{
var bytesOfMessage = NGRIDSerializationHelper.SerializeToByteArray(messageRecord.Message);
var id = InsertAndGetLastId(
"INSERT INTO messages(MessageId, DestServer, NextServer, DestApplication, MessageData, MessageDataLength, RecordDate) VALUES(?,?,?,?,?,?,now());",
new OdbcParameter("?MessageId", messageRecord.MessageId),
new OdbcParameter("?DestServer", messageRecord.DestServer),
new OdbcParameter("?NextServer", messageRecord.NextServer),
new OdbcParameter("?DestApplication", messageRecord.DestApplication),
new OdbcParameter("?MessageData", bytesOfMessage),
new OdbcParameter("?MessageDataLength", bytesOfMessage.Length)
);
messageRecord.Id = id;
return(id);
}
/// <summary>
/// Saves a NGRIDMessageRecord.
/// </summary>
/// <param name="messageRecord">NGRIDMessageRecord object to save</param>
/// <returns>Auto Increment Id of saved message</returns>
public int StoreMessage(NGRIDMessageRecord messageRecord)
{
lock (_syncObj)
{
var bytesOfMessage = NGRIDSerializationHelper.SerializeToByteArray(messageRecord.Message);
var id = InsertAndGetLastId(
"INSERT INTO messages(MessageId, DestServer, NextServer, DestApplication, MessageData, MessageDataLength, RecordDate) VALUES(@MessageId,@DestServer,@NextServer,@DestApplication,@MessageData,@MessageDataLength,@RecordDate);",
new SQLiteParameter("@MessageId", messageRecord.MessageId),
new SQLiteParameter("@DestServer", messageRecord.DestServer),
new SQLiteParameter("@NextServer", messageRecord.NextServer),
new SQLiteParameter("@DestApplication", messageRecord.DestApplication),
new SQLiteParameter("@MessageData", bytesOfMessage),
new SQLiteParameter("@MessageDataLength", bytesOfMessage.Length),
new SQLiteParameter("@RecordDate", DateTime.Now)
);
messageRecord.Id = id;
return(id);
}
}
/// <summary>
/// Sends a ControlMessage to NGRID server and gets it's response message.
/// </summary>
/// <param name="message">Message to send</param>
/// <returns>Response message from server</returns>
public ControlMessage SendMessageAndGetResponse(ControlMessage message)
{
//Create a WaitingMessage to wait and get response message and add it to waiting messages
var outgoingMessage = new NGRIDControllerMessage
{
MessageData = NGRIDSerializationHelper.SerializeToByteArray(message),
ControllerMessageTypeId = message.MessageTypeId
};
var waitingMessage = new WaitingMessage();
lock (_waitingMessages)
{
_waitingMessages[outgoingMessage.MessageId] = waitingMessage;
}
try
{
//Send message to the server
SendMessageInternal(outgoingMessage);
//Wait until thread is signalled by another thread to get response (Signalled by CommunicationChannel_MessageReceived method)
waitingMessage.WaitEvent.WaitOne(TimeSpan.FromSeconds(90));
//Check if response received or timeout occured
if (waitingMessage.ResponseMessage == null)
{
throw new NGRIDException("Timeout occured. Response message did not received.");
}
return(DeserializeControlMessage(waitingMessage.ResponseMessage));
}
finally
{
//Remove message from waiting messages
lock (_waitingMessages)
{
if (_waitingMessages.ContainsKey(outgoingMessage.MessageId))
{
_waitingMessages.Remove(outgoingMessage.MessageId);
}
}
}
}
/// <summary>
/// Handles MessageReceived event.
/// All messages received from all controllers comes to this method.
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">Event arguments</param>
private void NGRIDController_MessageReceived(object sender, MessageReceivedFromRemoteApplicationEventArgs e)
{
try
{
//Response to Ping messages
if ((e.Message.MessageTypeId == NGRIDMessageFactory.MessageTypeIdNGRIDPingMessage) && string.IsNullOrEmpty(e.Message.RepliedMessageId))
{
//Reply ping message
SendMessage(new NGRIDPingMessage {
RepliedMessageId = e.Message.MessageId
}, e.Communicator);
return;
}
//Do not process messages other than NGRIDControllerMessage
if (e.Message.MessageTypeId != NGRIDMessageFactory.MessageTypeIdNGRIDControllerMessage)
{
return;
}
//Cast message to NGRIDControllerMessage
var controllerMessage = e.Message as NGRIDControllerMessage;
if (controllerMessage == null)
{
return;
}
//Create (deserialize) ControlMessage from MessageData of controllerMessage object
var controlMessage = NGRIDSerializationHelper.DeserializeFromByteArray(
() =>
ControlMessageFactory.CreateMessageByTypeId(controllerMessage.ControllerMessageTypeId),
controllerMessage.MessageData);
//Process message
ProcessControllerMessage(e.Communicator, controllerMessage, controlMessage);
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
}
}
/// <summary>
/// Sends a ControlMessage to all connected NGRIDController instances.
/// </summary>
/// <param name="message">Message to send</param>
private void SendMessageToAllReceivers(ControlMessage message)
{
var outgoingMessage = new NGRIDControllerMessage
{
ControllerMessageTypeId = message.MessageTypeId,
MessageData = NGRIDSerializationHelper.SerializeToByteArray(message)
};
var receivers = GetAllReceiverCommunicators();
foreach (var receiver in receivers)
{
try
{
SendMessage(outgoingMessage, receiver);
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
}
}
}
/// <summary>
/// Deserializes an incoming message for Web Service from NGRID server.
/// </summary>
/// <param name="bytesOfMessage">Message as byte array</param>
/// <returns>Deserialized message</returns>
public static IWebServiceIncomingMessage DeserializeMessage(byte[] bytesOfMessage)
{
var dataMessage = NGRIDSerializationHelper.DeserializeFromByteArray(() => new NGRIDDataTransferMessage(), bytesOfMessage);
return(new IncomingDataMessage(dataMessage));
}
