public void ReceiveMessage(IChannelMessage response)
{
IResponse _response = (IResponse)response;
RequestResponsePair reqResponsePair = _requests[_response.RequestId] as RequestResponsePair;
bool unregister = false;
if (reqResponsePair != null)
{
lock (reqResponsePair)
{
if (reqResponsePair != null)
{
reqResponsePair.Response = _response;
System.Threading.Monitor.Pulse(reqResponsePair);
if (reqResponsePair.Listener != null)
{
reqResponsePair.Listener.OnResponseReceived(response);
unregister = true;
}
}
}
if (unregister)
{
lock (_lock)
{
_requests.Remove(_response.RequestId);
}
}
}
}
public void ReceiveMessage(IChannelMessage response)
{
if (response is IRequest)
{
_threadPool.ExecuteTask(new RequestDeliverTask(response, requestListener));
}
}
/// <summary>
/// Post a notification to the registered <see cref="IChannel{T}"/>s in parallel.
/// </summary>
/// <typeparam name="T">The type of the notification topic.</typeparam>
/// <param name="channelMessage">The message to send via the channels.</param>
/// <returns>Returns a task which is completed when all channel notifications have been completed.</returns>
public Task PostMessageToChannelsAsync <T>(IChannelMessage <T> channelMessage)
{
if (channelMessage == null)
{
throw new ArgumentNullException(nameof(channelMessage));
}
var channels = this.Settings.ResolveAll <IChannel <T> >();
if (!channels.Any())
{
return(Task.CompletedTask);
}
var channelsTasks = new List <Task>(channels.Count());
foreach (var channel in channels)
{
var channelTask = Task.Run(async() =>
{
await SendMessageToChannelAsync(channel, channelMessage);
});
channelsTasks.Add(channelTask);
}
return(Task.WhenAll(channelsTasks));
}
public object Deserialize(byte[] buffer)
{
IChannelMessage response = null;
if (buffer != null)
{
response = (IChannelMessage)CompactBinaryFormatter.FromByteBuffer(buffer, null);
}
return(response);
}
public void Send(IChannelMessage message)
{
//new OscMessage("/midi", )
sender.Send(new OscMessage("/midi",
(int)message.Command,
(int)message.MessageType,
message.MidiChannel,
message.Data1,
message.Data2));
}
/// <summary>
/// Queue a message to all available channels.
/// </summary>
/// <typeparam name="M">The type of the model in the message.</typeparam>
/// <typeparam name="T">The type of the topic in the messages.</typeparam>
/// <param name="channelMessage">The message to send to the available channels.</param>
/// <returns>Returns a task whose completion is the successful queuing of the <paramref name="channelMessage"/>.</returns>
public async Task QueueMessageToChannelsAsync <M, T>(IChannelMessage <M, T> channelMessage)
{
if (channelMessage == null)
{
throw new ArgumentNullException(nameof(channelMessage));
}
var channelsDispatcher = GetChannelsDispatcher <T>();
await channelsDispatcher.QueueMessageToChannelsAsync(channelMessage);
}
public byte[] Serialize(object graph)
{
try
{
IChannelMessage command = graph as IChannelMessage;
return(CompactBinaryFormatter.ToByteBuffer(command, null));
}
catch (Exception ex)
{
throw ex;
}
//byte[] buffer = null;
//CommandBase command = null;
//if (graph is IRequest)
//{
// IRequest request = graph as IRequest;
// command = request.Message as CommandBase;
//}
//else if (graph is IResponse)
//{
// ChannelResponse res = graph as ChannelResponse;
// command = res.ResponseMessage as CommandBase;
//}
//if (command != null)
//{
// if (command.commandType == CommandBase.CommandType.RESPONSE)
// {
// if (command.response.ResponseMessage != null)
// command.response.returnVal = CompactBinaryFormatter.ToByteBuffer(command.response.ResponseMessage, null);
// }
// else
// {
// if (command.command.Parameters != null)
// command.command.arguments = CompactBinaryFormatter.ToByteBuffer(command.command.Parameters, null);
// }
// using (MemoryStream stream = new MemoryStream())
// {
// ProtoBuf.Serializer.Serialize<CommandBase>(stream, command);
// buffer = stream.ToArray();
// }
//}
//return buffer;
}
/// <summary>
/// E-mail a message.
/// </summary>
/// <typeparam name="M">The type of the model in the message.</typeparam>
/// <param name="channelMessage">The message to send to the channel.</param>
public async Task SendMessageAsync <M>(IChannelMessage <M, T> channelMessage)
{
if (channelMessage == null)
{
throw new ArgumentNullException(nameof(channelMessage));
}
var destinationIdentities = await GetDestinationIdentitiesAsync(channelMessage.Destination, channelMessage.Topic);
if (!destinationIdentities.Any())
{
return;
}
bool useSingleMessageForMultipleRecepients = UseSingleMessageForMultipleRecepients(channelMessage.Destination, channelMessage.Topic);
var emailDestinationAddressesCollection = GetEmailDestinationAddressesCollection(destinationIdentities, useSingleMessageForMultipleRecepients);
var senderIdentity = await GetSenderIdentityAsync(channelMessage.Source, channelMessage.Topic);
var senderAddress = GetMailAddress(senderIdentity);
var destinationIdentitiesByEmail = destinationIdentities.ToReadOnlyMultiDictionary(i => i.Email);
foreach (var emailDestinationAddresses in emailDestinationAddressesCollection)
{
using (var bodyWriter = new System.IO.StringWriter())
{
var messageDestinationIdentities = from address in emailDestinationAddresses
where destinationIdentitiesByEmail.ContainsKey(address.Address)
from identity in destinationIdentitiesByEmail[address.Address]
select identity;
renderProvider.Render(
GetFullTemplateKey(channelMessage.TemplateKey),
bodyWriter,
channelMessage.Model,
GetDynamicProperties(channelMessage, messageDestinationIdentities));
string messageBody = bodyWriter.ToString();
string messageID = GetMessageID(channelMessage, messageDestinationIdentities);
await SendEmailMessageAsync(
channelMessage.Subject,
senderAddress,
emailDestinationAddresses,
messageBody,
messageID);
}
}
}
/// <summary>
/// Send a notification to the registered <see cref="IChannel{T}"/>s sequentially.
/// </summary>
/// <typeparam name="T">The type of the notification topic.</typeparam>
/// <param name="channelMessage">The message to send via the channels.</param>
/// <returns>Returns a task which is completed when all channel notifications have been completed.</returns>
public async Task SendMessageToChannelsAsync <T>(IChannelMessage <T> channelMessage)
{
if (channelMessage == null)
{
throw new ArgumentNullException(nameof(channelMessage));
}
var channels = this.Settings.ResolveAll <IChannel <T> >();
foreach (var channel in channels)
{
await SendMessageToChannelAsync(channel, channelMessage);
}
}
/// <summary>
/// Builds an e-mail message ID of the format <see cref="ChannelMessage{T}.Guid"/>/<see cref="IChannelIdentity.Guid"/>
/// if the destination identities have a single member,
/// else returns the <see cref="ChannelMessage{T}.Guid"/>.
/// </summary>
/// <param name="channelMessage">The channel message.</param>
/// <param name="destinationIdentities">The collection of destination identities.</param>
/// <returns>
/// Returns message-guid/destination guid if the destination identities have a single member,
/// else returns message-gruid.
/// </returns>
private string GetMessageID(IChannelMessage <T> channelMessage, IEnumerable <IChannelIdentity> destinationIdentities)
{
var messageIdBuilder = new StringBuilder();
messageIdBuilder.Append(channelMessage.Guid);
if (destinationIdentities.Count() == 1)
{
messageIdBuilder.Append("/");
var singleDestinationIdentity = destinationIdentities.Single();
messageIdBuilder.Append(singleDestinationIdentity.Guid);
}
return(messageIdBuilder.ToString());
}
private static Dictionary <string, object> GetDynamicProperties(IChannelMessage <T> channelMessage, IEnumerable <IChannelIdentity> destinationIdentities)
{
Dictionary <string, object> dynamicProperties;
if (channelMessage.DynamicProperties != null)
{
dynamicProperties = new Dictionary <string, object>(channelMessage.DynamicProperties.ToDictionary(e => e.Key, e => e.Value));
}
else
{
dynamicProperties = new Dictionary <string, object>(2);
}
dynamicProperties[ChannelMessagePropertyKey] = channelMessage;
dynamicProperties[DestinationIdentitiesPropertyKey] = destinationIdentities.ToArray();
return(dynamicProperties);
}
/// <summary>
/// Attempt to send a notification to a channel and log any error.
/// </summary>
/// <typeparam name="T">The type of the topic.</typeparam>
/// <param name="channel">The Channel to send to.</param>
/// <param name="channelMessage">The message to send via the channel.</param>
private async Task SendMessageToChannelAsync <T>(IChannel <T> channel, IChannelMessage <T> channelMessage)
{
try
{
await channel.SendMessageAsync(channelMessage);
}
catch (Exception e)
{
var loggersRepository = lazyLoggerRepository.Value;
var logger = loggersRepository.GetLogger(channelPostLoggerName);
logger.Log(
Logging.LogLevel.Error,
e,
$"Failed to send via channel of type {channel.GetType().FullName}, subject: '{channelMessage.Subject}'");
}
}
public static void PostMessage(string channelName, IChannelMessage message)
{
if (string.IsNullOrEmpty(channelName))
{
throw new ArgumentNullException(nameof(channelName));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (!_channels.ContainsKey(channelName.ToLower(CultureInfo.InvariantCulture)))
{
throw new InvalidOperationException("The channel <" + channelName.ToLower(CultureInfo.InvariantCulture) + "> does not exist.");
}
_channels[channelName.ToLower(CultureInfo.InvariantCulture)].Enqueue(message);
}
/// <summary>
/// Queue a message to all available channels.
/// </summary>
/// <typeparam name="M">The type of the model in the message.</typeparam>
/// <param name="channelMessage">The message to send to the available channels.</param>
/// <returns>Returns a task whose completion is the successful queuing of the <paramref name="channelMessage"/>.</returns>
public Task QueueMessageToChannelsAsync <M>(IChannelMessage <M, T> channelMessage)
{
if (channelMessage == null)
{
throw new ArgumentNullException(nameof(channelMessage));
}
var channels = channelsFactory.Get();
foreach (var channel in channels)
{
var channelTask = taskQueuer.QueueAsyncAction(channel.GetType(), async() =>
{
await channel.SendMessageAsync(channelMessage);
});
}
return(Task.CompletedTask);
}
public void OnDataReceived(IConnection sender, byte[] buffer, object context)
{
ReciveContext receiveContext = (ReciveContext)context;
switch (receiveContext)
{
case ReciveContext.LengthReceive:
int rspLength = Convert.ToInt32(UTF8Encoding.UTF8.GetString(buffer, 0, buffer.Length));
buffer = new byte[rspLength];
sender.ReceiveAsync(buffer, buffer.Length, ReciveContext.DataReceive);
break;
case ReciveContext.DataReceive:
sender.ReceiveAsync(_sizeBuffer, DATA_SIZE_BUFFER_LENGTH, ReciveContext.LengthReceive);
IChannelMessage message = null;
if (_formatter != null)
{
message = _formatter.Deserialize(buffer) as IChannelMessage;
}
message.Channel = this;
message.Source = GetSourceAddress();
try
{
if (_eventListener != null)
{
_eventListener.ReceiveMessage(message);
}
}
catch (Exception e)
{
if (_traceProvider != null)
{
_traceProvider.TraceError(Name + ".Run", e.ToString());
}
}
break;
}
}
public object Deserialize(byte[] buffer)
{
IChannelMessage response = null;
if (buffer != null)
{
response = (IChannelMessage)CompactBinaryFormatter.FromByteBuffer(buffer, null);
}
return(response);
//CommandBase command = null;
//using (MemoryStream stream = new MemoryStream(buffer))
//{
// command = ProtoBuf.Serializer.Deserialize<CommandBase>(stream);
//}
//if (command.commandType == CommandBase.CommandType.RESPONSE)
//{
// if (command.response.returnVal != null)
// command.response.ResponseMessage = CompactBinaryFormatter.FromByteBuffer(command.response.returnVal, null);
//}
//return command;
}
public void ReceiveMessage(IChannelMessage message)
{
try
{
IRequest request = message as IRequest;
if (request != null)
{
if (_threadPool != null)
{
_threadPool.ExecuteTask(new RequestDeliverTask(message, _requestListener));
}
else
{
_requestListener.OnRequest(request);
}
}
else
{
IResponse response = message as IResponse;
if (_responseListener != null)
{
_responseListener.ReceiveMessage(message);
}
//if(response != null)
// _threadPool.ExecuteTask(new ResponseDeliverTask(message, _responseListener));
}
}
catch (Exception ex)
{
if (LoggerManager.Instance.ServerLogger != null && LoggerManager.Instance.ServerLogger.IsErrorEnabled)
{
LoggerManager.Instance.ServerLogger.Error("DualChannelListener.RecieveMessage", ex.Message);
}
}
}
public void Write(IChannelMessage message, HttpListenerResponse response)
{
_msgService.WriteHttpResponse(message, response);
OnPostMessageServiceInvoked?.Invoke(this, EventArgs.Empty);
}
public byte[] Serialize(object graph)
{
IChannelMessage command = graph as IChannelMessage;
return(CompactBinaryFormatter.ToByteBuffer(command, null));
}
/// <summary>
/// Initializes a new instance of the <see cref="DataReceivedEventArgs"/> class.
/// </summary>
/// <param name="message">The message.</param>
public DataReceivedEventArgs(IChannelMessage message)
{
Message = message;
}
public RequestDeliverTask(IChannelMessage message, IRequestListener requestLisetner)
{
_message = message;
_requestListener = requestLisetner;
}
/// <summary>
///
/// </summary>
private void Run()
{
while (true)
{
try
{
//receive data size for the response
if (_connection != null)
{
_connection.Receive(_sizeBuffer, DATA_SIZE_BUFFER_LENGTH);
int rspLength = Convert.ToInt32(UTF8Encoding.UTF8.GetString(_sizeBuffer, 0, _sizeBuffer.Length));
if (rspLength > 0)
{
byte[] dataBuffer = new byte[rspLength];
_connection.Receive(dataBuffer, rspLength);
//deserialize the message
IChannelMessage message = null;
if (_formatter != null)
{
message = _formatter.Deserialize(dataBuffer) as IChannelMessage;
}
message.Channel = this;
message.Source = GetSourceAddress();
if (_eventListener != null)
{
_eventListener.ReceiveMessage(message);
}
}
}
else
{
break;
}
}
catch (ThreadAbortException) { break; }
catch (ThreadInterruptedException) { break; }
catch (ConnectionException ce)
{
if (_traceProvider != null && _forcedDisconnected)
{
_traceProvider.TraceError(Name + ".Run", ce.ToString());
}
if (_eventListener != null & !_forcedDisconnected)
{
_eventListener.ChannelDisconnected(ce.Message);
}
break;
}
catch (Exception e)
{
if (_traceProvider != null)
{
_traceProvider.TraceError(Name + ".Run", e.ToString());
}
break;
//new ChannelException();
}
}
}
