/// <summary>
/// Serializes a message to send to MDS 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(MDSSerializationHelper.SerializeToByteArray(response));
}
/// <summary>
/// Sends a ControlMessage to MDS server.
/// </summary>
/// <param name="message">Message to send</param>
public void SendMessage(ControlMessage message)
{
SendMessageInternal(new MDSControllerMessage
{
MessageData = MDSSerializationHelper.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, MDSControllerMessage incomingMessage)
{
//Create MDSControllerMessage that includes serialized GetApplicationListResponseMessage message
var outgoingMessage = new MDSControllerMessage
{
ControllerMessageTypeId = message.MessageTypeId,
MessageData = MDSSerializationHelper.SerializeToByteArray(message),
RepliedMessageId = incomingMessage.MessageId
};
//Send message to communicator that sent to message
SendMessage(outgoingMessage, communicator);
}
/// <summary>
/// Saves a MDSMessageRecord.
/// </summary>
/// <param name="messageRecord">MDSMessageRecord object to save</param>
/// <returns>Auto Increment Id of saved message</returns>
public int StoreMessage(MDSMessageRecord messageRecord)
{
var bytesOfMessage = MDSSerializationHelper.SerializeToByteArray(messageRecord.Message);
var id = InsertAndGetLastId(
"INSERT INTO Messages(MessageId, DestServer, NextServer, DestApplication, MessageData, MessageDataLength, RecordDate) VALUES(@MessageId, @DestServer, @NextServer, @DestApplication, @MessageData, @MessageDataLength, GetDate())",
new SqlParameter("@MessageId", messageRecord.MessageId),
new SqlParameter("@DestServer", messageRecord.DestServer),
new SqlParameter("@NextServer", messageRecord.NextServer),
new SqlParameter("@DestApplication", messageRecord.DestApplication),
new SqlParameter("@MessageData", bytesOfMessage),
new SqlParameter("@MessageDataLength", bytesOfMessage.Length)
);
messageRecord.Id = id;
return(id);
}
/// <summary>
/// Sends a ControlMessage to MDS 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 MDSControllerMessage
{
MessageData = MDSSerializationHelper.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 MDSException("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);
}
}
}
}
public int StoreMessage(MDSMessageRecord messageRecord)
{
int id = 0;
var bytesOfMessage = MDSSerializationHelper.SerializeToByteArray(messageRecord.Message);
//Buscando id e insertando
while (true)
{
var collection = _database.GetCollection <MDSMessageRecord>(_tableName);
int lastId = collection.AsQueryable()
.OrderByDescending(m => m.Id)
.Select(m => m.Id)
.FirstOrDefault();
id = lastId + 1;
messageRecord.Id = id;
try
{
collection.InsertOne(messageRecord);
}
catch (Exception writeError)
{
if (writeError.Message.Contains("11000"))
{
continue;
}
else
{
throw writeError;
}
}
break;
}
return(id);
}
/// <summary>
/// Sends a ControlMessage to all connected MDSController instances.
/// </summary>
/// <param name="message">Message to send</param>
private void SendMessageToAllReceivers(ControlMessage message)
{
var outgoingMessage = new MDSControllerMessage
{
ControllerMessageTypeId = message.MessageTypeId,
MessageData = MDSSerializationHelper.SerializeToByteArray(message)
};
var receivers = GetAllReceiverCommunicators();
foreach (var receiver in receivers)
{
try
{
SendMessage(outgoingMessage, receiver);
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
}
}
}
/// <summary>
/// Makes web service call, receives result and raises MessageReceived event.
/// </summary>
/// <param name="message"></param>
private void SendMessageToWebService(MDSDataTransferMessage message)
{
using (var appService = new MDSAppService())
{
appService.Url = _url;
var responseMessageBytes = appService.ReceiveMDSMessage(MDSSerializationHelper.SerializeToByteArray(message));
if (responseMessageBytes == null)
{
throw new MDSException("Response byte array from web service call is null.");
}
var responseMessage = MDSSerializationHelper.DeserializeFromByteArray(() => new MDSDataTransferResponseMessage(), responseMessageBytes);
if (responseMessage.Result != null)
{
OnMessageReceived(responseMessage.Result);
}
if (responseMessage.Message != null)
{
OnMessageReceived(responseMessage.Message);
}
}
}
