public void Enqueue(MessageDelivery value)
{
lock (_queue)
{
_queue.Enqueue(value);
}
}
public IDelivery Send(object message)
{
MessageDelivery delivery = new MessageDelivery();
ICommand send = new SendMessage(client, message, formatter);
ICommand sendAndNotify = new NotifyDelivery(send, delivery);
Queue.Enqueue(sendAndNotify);
return delivery;
}
public override void Dispatch(MessageDelivery messageDelivery)
{
MethodInfo methodInfo;
string replyAction = null;
if (!_actionLookup.TryGetValue(messageDelivery.Action, out methodInfo))
{
foreach (string a in _actionLookup.Keys)
{
if (a == messageDelivery.Action)
{
methodInfo = _actionLookup[a];
break;
}
}
}
if (methodInfo != null)
{
object result;
try
{
result = methodInfo.Invoke(Target, new object[] { messageDelivery.Message });
if (!IsOneWay)
{
KeyValuePair<MessageDeliveryContextKey, object>[] replyData = new KeyValuePair<MessageDeliveryContextKey, object>[1];
replyData[0] = new KeyValuePair<MessageDeliveryContextKey, object>(MessageDelivery.CorrelationId, GetResponseCorrelationId(messageDelivery));
replyAction = _replyLookup[messageDelivery.Action];
Runtime.PublishOneWay(new PublishRequest(Endpoint.ContractType, replyAction, result, new MessageDeliveryContext(replyData)));
}
}
catch (TargetInvocationException ex)
{
result = ex.InnerException;
if (!IsOneWay)
{
KeyValuePair<MessageDeliveryContextKey, object>[] replyData = new KeyValuePair<MessageDeliveryContextKey, object>[1];
replyData[0] = new KeyValuePair<MessageDeliveryContextKey, object>(MessageDelivery.CorrelationId, GetResponseCorrelationId(messageDelivery));
Runtime.PublishOneWay(new PublishRequest(Endpoint.ContractType, replyAction, result, new MessageDeliveryContext(replyData)));
}
else
{
throw;
}
}
}
else
{
throw new InvalidOperationException("Matching action not found");
}
}
public override void Dispatch(MessageDelivery messageDelivery)
{
PublishRequest pr = new PublishRequest(messageDelivery.ContractType, messageDelivery.Action, messageDelivery.Message, messageDelivery.Context);
using (TransactionScope ts = new TransactionScope())
{
foreach (MessageDelivery md in determineDeliveries(pr))
{
DeliveryCore deliveryCore = SelectDeliveryCore(md);
deliveryCore.Deliver(md);
}
ts.Complete();
}
}
List<MessageDelivery> determineDeliveries(PublishRequest publishRequest)
{
List<MessageDelivery> messageDeliveries = new List<MessageDelivery>();
List<SubscriptionEndpoint> unhandledFilters = new List<SubscriptionEndpoint>();
bool handled = false;
foreach (SubscriptionEndpoint subscription in _getSubscriptions())
{
if (!subscription.IsExpired)
{
bool include;
if (subscription.Filter is UnhandledMessageFilter)
{
include = false;
if (subscription.Filter.Include(publishRequest))
{
unhandledFilters.Add(subscription);
}
}
else
{
include = subscription.Filter == null || subscription.Filter.Include(publishRequest);
}
if (include)
{
MessageDelivery delivery = new MessageDelivery(subscription.Id, publishRequest.ContractType, publishRequest.Action, publishRequest.Message, Runtime.MaxRetries, publishRequest.Context);
messageDeliveries.Add(delivery);
handled = true;
}
}
}
// if unhandled, send to subscribers of unhandled messages
if (!handled)
{
foreach (SubscriptionEndpoint subscription in unhandledFilters)
{
if (!subscription.IsExpired)
{
MessageDelivery delivery = new MessageDelivery(subscription.Id, publishRequest.ContractType, publishRequest.Action, publishRequest.Message, Runtime.MaxRetries, publishRequest.Context);
messageDeliveries.Add(delivery);
}
}
}
return messageDeliveries;
}
public override void Dispatch(MessageDelivery messageDelivery)
{
try
{
FileStream fs = File.Open(Path.Combine(OutgoingFolder, messageDelivery.MessageDeliveryId), FileMode.CreateNew, FileAccess.Write, FileShare.None);
using (var writer = WriterFactory.CreateWriter(fs))
{
writer.Write(messageDelivery);
}
}
catch (IOException ex)
{
throw new DeliveryException("Error writing file", ex);
}
}
public override System.ServiceModel.Channels.Message ToMessage(MessageDelivery delivery)
{
MessageDeliveryConverter converter;
if (delivery.Action == null)
{
throw new InvalidOperationException("Action cannot be null");
}
if (_converterMap.TryGetValue(delivery.Action, out converter))
{
return converter.ToMessage(delivery);
}
else
{
throw new InvalidOperationException("Unknown action " + delivery.Action);
}
}
protected override Message ToMessageCore(MessageDelivery delivery)
{
if (!_converterHash.ContainsKey(delivery.Action))
{
throw new InvalidOperationException("Unsupported action");
}
TypedMessageConverter converter = getCachedConverter(delivery.Action);
if (converter != null)
{
return converter.ToMessage(delivery.Message);
}
else
{
return null;
}
}
public override void Dispatch(MessageDelivery messageDelivery)
{
IOutputChannel channel = CreateChannelFactory().CreateChannel();
bool closed = false;
try
{
channel.Open();
channel.Send(_converter.ToMessage(messageDelivery));
}
finally
{
channel.Close();
closed = true;
}
if (!closed)
{
channel.Abort();
}
}
public override void Deliver(MessageDelivery delivery)
{
if (!Started)
{
throw new InvalidOperationException("Cannot deliver messages before the bus is started");
}
try
{
SubscriptionEndpoint endpoint = Runtime.GetSubscription(delivery.SubscriptionEndpointId);
if (endpoint != null) // subscription may be removed
{
endpoint.Dispatcher.Dispatch(delivery);
}
NotifyDelivery(delivery);
}
catch(Exception ex)
{
throw new DeliveryException("Unhandled exception while attempting to deliver the message", ex);
}
}
public override void Dispatch(MessageDelivery messageDelivery)
{
if (!Started) throw new InvalidOperationException("Dispatcher is not started yet");
ChannelFactory factory = CreateFactory();
factory.Endpoint.Address = new EndpointAddress(Endpoint.Address);
ApplySecurityContext(messageDelivery, factory);
IContextChannel proxy = CreateProxy(factory);
using (OperationContextScope scope = new OperationContextScope(proxy))
{
bool success = false;
try
{
var lookup = initActionLookup(Endpoint);
MethodInfo methodInfo = lookup.MethodLookup[_passThrough ? "*" : messageDelivery.Action];
if (methodInfo != null)
{
try
{
object result = methodInfo.Invoke(proxy, new object[] { messageDelivery.Message });
if (lookup.ReplyActionLookup.ContainsKey(messageDelivery.Action)) // if two way message, publish reply
{
KeyValuePair<MessageDeliveryContextKey, object>[] replyData = new KeyValuePair<MessageDeliveryContextKey, object>[1];
replyData[0] = new KeyValuePair<MessageDeliveryContextKey, object>(MessageDelivery.CorrelationId, GetResponseCorrelationId(messageDelivery));
Runtime.PublishOneWay(new PublishRequest(Endpoint.ContractType, lookup.ReplyActionLookup[messageDelivery.Action], result, new MessageDeliveryContext(replyData)));
}
}
catch (System.Reflection.TargetInvocationException ex)
{
if (lookup.ReplyActionLookup.ContainsKey(messageDelivery.Action)) // if two way message, publish reply
{
KeyValuePair<MessageDeliveryContextKey, object>[] replyData = new KeyValuePair<MessageDeliveryContextKey, object>[1];
replyData[0] = new KeyValuePair<MessageDeliveryContextKey, object>(MessageDelivery.CorrelationId, GetResponseCorrelationId(messageDelivery));
FaultException fex = ex.InnerException as FaultException;
if (fex != null)
{
Runtime.PublishOneWay(new PublishRequest(Endpoint.ContractType, fex.Action, ((FaultException)ex.InnerException), new MessageDeliveryContext(replyData)));
}
else
{
throw;
}
}
else
{
throw;
}
}
}
else
{
throw new InvalidOperationException("Matching method not found");
}
proxy.Close();
success = true;
}
finally
{
if (!success)
{
proxy.Abort();
}
}
}
}
/// <summary>
/// Sends the message with options.
/// </summary>
/// <param name="msg">The message in byte[].</param>
/// <param name="msgDelivery">The <see cref="MessageDelivery"/>.</param>
/// <param name="channelID">The channel identifier.</param>
/// <returns>True if the message arrived.</returns>
public bool SendMessage(byte[] msg, MessageDelivery msgDelivery, int channelID)
{
return _networkImp.SendMessage(msg, msgDelivery, channelID);
}
/// <summary>
/// Sends the message with options.
/// </summary>
/// <param name="msg">The message in byte[].</param>
/// <param name="msgDelivery">The <see cref="MessageDelivery"/>.</param>
/// <param name="channelID">The channel identifier.</param>
/// <returns>True if the message arrived.</returns>
public bool SendMessage(byte[] msg, MessageDelivery msgDelivery, int channelID)
{
return(_networkImp.SendMessage(msg, msgDelivery, channelID));
}
private System.Messaging.Message createMessage(MessageDelivery value)
{
System.Messaging.Message message = new System.Messaging.Message();
message.Label = value.MessageDeliveryId;
message.Formatter = _formatter;
message.Body = value;
return message;
}
/// <summary>
/// Sends the message.
/// </summary>
/// <param name="msg">The MSG.</param>
/// <param name="msgDelivery">The MSG delivery.</param>
/// <param name="msgChannel">The MSG channel.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public bool SendMessage(byte[] msg, MessageDelivery msgDelivery, int msgChannel)
{
return(false);
}
public override void Dispatch(MessageDelivery messageDelivery)
{
DispatchAction(Endpoint, messageDelivery);
}
public virtual DeliveryCore SelectDeliveryCore(MessageDelivery delivery)
{
DeliveryCore deliveryCore = Runtime.ServiceLocator.GetInstance<DeliveryCore>();
return deliveryCore;
}
public virtual MailAddress DetermineFromAddress(MessageDelivery messageDelivery)
{
return _from;
}
public virtual IEnumerable<MailAddress> DetermineCCEmailAddresses(MessageDelivery messageDelivery)
{
return new MailAddress[0];
}
/// <summary>
/// Decision: Allow and Keep
/// </summary>
public async Task <Decision> ConsumerReceiveFailed(HorseQueue queue, MessageDelivery delivery, MqClient receiver)
{
return(await Task.FromResult(new Decision(true, false, PutBackDecision.Start, DeliveryAcknowledgeDecision.None)));
}
/// <summary>
/// Process pull request and sends queue message to requester as response
/// </summary>
private async Task ProcessPull(ChannelClient requester, TmqMessage request, QueueMessage message)
{
//if we need acknowledge, we are sending this information to receivers that we require response
message.Message.AcknowledgeRequired = _queue.Options.RequestAcknowledge;
//if we need acknowledge from receiver, it has a deadline.
DateTime?deadline = null;
if (_queue.Options.RequestAcknowledge)
{
deadline = DateTime.UtcNow.Add(_queue.Options.AcknowledgeTimeout);
}
//if to process next message is requires previous message acknowledge, wait here
if (_queue.Options.RequestAcknowledge && _queue.Options.WaitForAcknowledge)
{
await _queue.WaitForAcknowledge(message);
}
message.Decision = await _queue.DeliveryHandler.BeginSend(_queue, message);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return;
}
//if message is sent before and this is second client, skip the process
bool skip = !message.Message.FirstAcquirer && _queue.Options.SendOnlyFirstAcquirer;
if (skip)
{
if (!message.Decision.KeepMessage)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageRemoved(_queue, message);
}
return;
}
//call before send and check decision
message.Decision = await _queue.DeliveryHandler.CanConsumerReceive(_queue, message, requester.Client);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return;
}
//create delivery object
MessageDelivery delivery = new MessageDelivery(message, requester, deadline);
delivery.FirstAcquirer = message.Message.FirstAcquirer;
//change to response message, send, change back to channel message
string mid = message.Message.MessageId;
message.Message.SetMessageId(request.MessageId);
message.Message.Type = MessageType.Response;
bool sent = requester.Client.Send(message.Message);
message.Message.SetMessageId(mid);
message.Message.Type = MessageType.Channel;
if (sent)
{
_queue.TimeKeeper.AddAcknowledgeCheck(delivery);
delivery.MarkAsSent();
//do after send operations for per message
_queue.Info.AddDelivery();
message.Decision = await _queue.DeliveryHandler.ConsumerReceived(_queue, delivery, requester.Client);
//after all sending operations completed, calls implementation send completed method and complete the operation
_queue.Info.AddMessageSend();
if (!await _queue.ApplyDecision(message.Decision, message))
{
return;
}
}
else
{
message.Decision = await _queue.DeliveryHandler.ConsumerReceiveFailed(_queue, delivery, requester.Client);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return;
}
}
message.Decision = await _queue.DeliveryHandler.EndSend(_queue, message);
await _queue.ApplyDecision(message.Decision, message);
if (message.Decision.Allow && !message.Decision.KeepMessage)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageRemoved(_queue, message);
}
}
public bool SendMessage(byte[] packet, MessageDelivery msgDelivery, int msgChannel)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Decision: Allow
/// </summary>
public async Task <Decision> AcknowledgeTimedOut(ChannelQueue queue, MessageDelivery delivery)
{
return(await Task.FromResult(new Decision(true, false)));
}
/// <summary>
/// Decision: Allow
/// </summary>
public async Task <Decision> AcknowledgeReceived(ChannelQueue queue, TmqMessage acknowledgeMessage, MessageDelivery delivery, bool success)
{
return(await Task.FromResult(new Decision(true, false)));
}
public async Task <Decision> AcknowledgeReceived(ChannelQueue queue, TmqMessage acknowledgeMessage, MessageDelivery delivery, bool success)
{
Console.WriteLine($"Acknowledge received in {queue.Id} queue in {queue.Channel.Name}");
return(await Task.FromResult(new Decision(true, false, false, DeliveryAcknowledgeDecision.IfSaved)));
}
public virtual string DetermineSubject(MessageDelivery messageDelivery)
{
return _subject;
}
public async Task <Decision> ConsumerReceiveFailed(ChannelQueue queue, MessageDelivery delivery, MqClient receiver)
{
Console.WriteLine($"Message sent failed to {receiver.UniqueId} in {queue.Id} queue in {queue.Channel.Name}");
return(await Task.FromResult(new Decision(true, false)));
}
public virtual IEnumerable<MailAddress> DetermineToEmailAddresses(MessageDelivery messageDelivery)
{
return _to;
}
public abstract void Write(MessageDelivery delivery);
public override void Dispatch(MessageDelivery messageDelivery)
{
try
{
SmtpClient client = new SmtpClient();
MailMessage mailMessage = new MailMessage();
mailMessage.Subject = DetermineSubject(messageDelivery);
mailMessage.From = DetermineFromAddress(messageDelivery);
foreach (MailAddress address in DetermineToEmailAddresses(messageDelivery))
{
mailMessage.To.Add(address);
}
foreach (MailAddress address in DetermineCCEmailAddresses(messageDelivery))
{
mailMessage.CC.Add(address);
}
foreach (MailAddress address in DetermineBccEmailAddresses(messageDelivery))
{
mailMessage.Bcc.Add(address);
}
mailMessage.BodyEncoding = BodyEncoding;
Message content = Converter.ToMessage(messageDelivery);
using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
{
using (XmlTextWriter xmlWriter = new XmlTextWriter(writer))
{
content.WriteMessage(xmlWriter);
}
mailMessage.Body = writer.ToString();
}
client.Send(mailMessage);
}
catch (System.Net.Mail.SmtpException ex)
{
throw new DeliveryException("Error sending mail", ex);
}
}
public void Enqueue(MessageDelivery value)
{
if (_disposed) throw new ObjectDisposedException("MsmqMessageDeliveryQueue");
System.Messaging.Message message = createMessage(value);
_queue.Send(message, _transactionType);
}
protected string GetResponseCorrelationId(MessageDelivery delivery)
{
return (string)delivery.Context[MessageDelivery.PublishRequestId];
}
/// <summary>
/// Sends the message with options.
/// </summary>
/// <param name="msg">The message.</param>
/// <param name="connection">The connection.</param>
/// <param name="msgDelivery">The <see cref="MessageDelivery"/>.</param>
/// <param name="msgChannel">The message channel.</param>
/// <returns>True if the message was sent succesfully.</returns>
public bool SendMessage(byte[] msg, NetConnection connection, MessageDelivery msgDelivery, int msgChannel)
{
// _netConfig.RedirectPackets = true;
NetSendResult sendResult;
switch (_config.SysType)
{
case SysType.Peer:
//sendMsg = _netPeer.CreateMessage(msg);
//sendMsg.Write(msg);
break;
case SysType.Client:
var sendMsgClient = _netClient.CreateMessage();
sendMsgClient.Write(msg);
sendResult = _netClient.SendMessage(sendMsgClient, connection, (NetDeliveryMethod)msgDelivery, msgChannel);
return (sendResult == NetSendResult.Sent);
case SysType.Server:
var sendMsgServer = _netServer.CreateMessage();
sendMsgServer.Write(msg);
sendResult = _netServer.SendMessage(sendMsgServer, connection, (NetDeliveryMethod)msgDelivery, msgChannel);
return (sendResult == NetSendResult.Sent);
}
return false;
}
public async Task <Decision> AcknowledgeReceived(ChannelQueue queue, TmqMessage acknowledgeMessage, MessageDelivery delivery)
{
_server.OnAcknowledge++;
return(await Task.FromResult(new Decision(true, false, false, DeliveryAcknowledgeDecision.Always)));
}
public virtual int Tick()
{
// Deliver messages whose delivery time has passed
_now += _tickDuration;
// logger.debug( "tick:"+now );
IEnumerator <MessageDelivery> iter = _messageDeliveries.GetEnumerator();
while (iter.MoveNext())
{
MessageDelivery messageDelivery = iter.Current;
if (messageDelivery.MessageDeliveryTime <= _now)
{
long delay = _strategy.messageDelay(messageDelivery.Message, messageDelivery.Server.Server.boundAt().ToString());
if (delay != NetworkLatencyStrategy_Fields.LOST)
{
messageDelivery.Server.process(messageDelivery.Message);
}
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
iter.remove();
}
}
// Check and trigger timeouts
foreach (TestProtocolServer testServer in Participants.Values)
{
testServer.Tick(_now);
}
// Get all sent messages from all test servers
IList <Message> messages = new List <Message>();
foreach (TestProtocolServer testServer in Participants.Values)
{
testServer.SendMessages(messages);
}
// Now send them and figure out latency
foreach (Message message in messages)
{
string to = message.getHeader(Message.HEADER_TO);
long delay = 0;
if (message.getHeader(Message.HEADER_TO).Equals(message.getHeader(Message.HEADER_FROM)))
{
Log.debug("Sending message to itself; zero latency");
}
else
{
delay = _strategy.messageDelay(message, to);
}
if (delay == NetworkLatencyStrategy_Fields.LOST)
{
Log.debug("Send message to " + to + " was lost");
}
else
{
TestProtocolServer server = Participants[to];
Log.debug("Send to " + to + ": " + message);
_messageDeliveries.Add(new MessageDelivery(_now + delay, message, server));
}
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Iterator<org.neo4j.helpers.collection.Pair<java.util.concurrent.Future<?>, Runnable>> waiters = futureWaiter.iterator();
IEnumerator <Pair <Future <object>, ThreadStart> > waiters = _futureWaiter.GetEnumerator();
while (waiters.MoveNext())
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.helpers.collection.Pair<java.util.concurrent.Future<?>, Runnable> next = waiters.Current;
Pair <Future <object>, ThreadStart> next = waiters.Current;
if (next.First().Done)
{
next.Other().run();
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
waiters.remove();
}
}
return(_messageDeliveries.Count);
}
protected internal override void OnMessageDeliveryFailed(MessageDelivery delivery, bool permanent)
{
base.OnMessageDeliveryFailed(delivery, permanent);
if (permanent)
{
_permFailureCounter.Increment();
_permFailurePerSecondCounter.Increment();
}
else
{
_failureCounter.Increment();
_failurePerSecondCounter.Increment();
}
}
protected virtual void ApplySecurityContext(MessageDelivery delivery, ChannelFactory factory)
{
}
public async Task <Decision> AcknowledgeTimedOut(ChannelQueue queue, MessageDelivery delivery)
{
Console.WriteLine($"Acknowledge timed out in {queue.Id} queue in {queue.Channel.Name}");
return(await Task.FromResult(new Decision(true, true)));
}
public void Enqueue(MessageDelivery value)
{
}
/// <summary>
/// Decision: Allow
/// </summary>
public async Task <Decision> ConsumerReceiveFailed(ChannelQueue queue, MessageDelivery delivery, MqClient receiver)
{
return(await Task.FromResult(new Decision(true, false)));
}
public override void Dispatch(MessageDelivery messageDelivery)
{
_heartbeat.Event.Set();
}
protected internal override void OnMessageDelivered(MessageDelivery delivery)
{
base.OnMessageDelivered(delivery);
_deliveryCounter.Increment();
_deliveryPerSecondCounter.Increment();
}
protected override System.ServiceModel.Channels.Message ToMessageCore(MessageDelivery delivery)
{
return Message.CreateMessage(MessageVersion.Default, ((FaultException)(delivery.Message)).CreateMessageFault(), delivery.Action);
}
public Task Consume(MessageDelivery delivery)
{
Console.WriteLine("[Consumer " + _name + "] Consume received msg " + delivery.deliveryTag);
return(Task.CompletedTask);
}
