public RawBusMessage Dispatch(RawBusMessage message)
{
BusMessage <TData> busMessage = new BusMessage <TData>
{
BusId = message.BusId,
Sent = message.Sent,
Data = (TData)message.Data
};
foreach (var header in message.Headers)
{
busMessage.Headers.Add(header);
}
BusMessage <TReplyData> busReplyMessage = _action(busMessage);
RawBusMessage replyMessage = new RawBusMessage
{
Data = busReplyMessage.Data
};
foreach (var header in busReplyMessage.Headers)
{
replyMessage.Headers.Add(header);
}
return(replyMessage);
}
public override void UpdateData(BusMessage <T> input)
{
if (_setEnable.Set)
{
base.UpdateData(input);
}
}
static void Main(string[] args)
{
using (var activator = new BuiltinHandlerActivator())
{
Console.WriteLine("Starting App");
var logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
// might even make it global default
Log.Logger = logger;
activator.Register(() => new BusMessageHandler());
var msg = new BusMessage();
Configure.With(activator)
.Logging(l => l.Serilog(logger))
.Transport(t => t.UseAmazonSQS("AKIA5KWE5Z3FX65JN3YF", "d2e5ElbBqdz7wIEANYaByl8zbNDv1mKOTSquBYmW", RegionEndpoint.EUWest2, "rebusQueue"))
.Routing(r => r.TypeBased().Map <BusMessage>("rebusQueue"))
.Start();
Console.WriteLine("This is Subscriber 1");
Console.WriteLine("Press ENTER to quit");
Console.ReadLine();
Console.WriteLine("Quitting...");
}
}
public void Send <TData>(BusMessage <TData> busMessage)
{
DataContractKey contractKey;
Type type = typeof(TData);
if (!_nameMappings.TryGetValue(type, out contractKey))
{
DataContract contract = new DataContract(busMessage.Data);
_nameMappings.TryAdd(type, contract.Key);
_contractCollector.AddKnownContract(contract);
contractKey = contract.Key;
}
using (Message message = Message.CreateMessage(_messageVersion, MessagingConstants.MessageAction.Regular, busMessage.Data))
{
SetBusHeaders(message, contractKey);
SetUserHeaders(busMessage, message);
_outputChannel.Send(message);
}
}
public RouteResponse CC(ControlCommand command)
{
//serialize message
string serialized = JsonConvert.SerializeObject(command, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
});
JObject asJO = JObject.Parse(serialized);
//create peristed message
BusMessage msg = new BusMessage()
{
PayLoad = serialized, MessageType = asJO["$type"].ToString()
};
RouteResponse toReturn = new RouteResponse()
{
Status = false
};
try {
toReturn = Bus.ReceiveMessage(msg);
} catch {
throw;
}
return(toReturn);
}
public async Task Handle(BusMessage message)
{
using (var scope = _Provider.CreateScope())
{
try
{
var dataBody = Encoding.UTF8.GetString(message.Data);
_Logger.LogInformation(dataBody);
var command = message.ConvertBusMessageToCommand();
await _MediatR.Send(command);
}
catch (DomainException de)
{
_Logger.LogError(de, de.Message);
}
catch (ValidationException ve)
{
_Logger.LogError(ve, ve.Message);
}
catch (CommandException ce)
{
_Logger.LogError(ce, ce.Message);
}
catch (Exception ex)
{
_Logger.LogError(ex, ex.Message);
}
}
}
private void ConstructHeaders(BusMessage message, IBasicProperties properties)
{
foreach (KeyValuePair <string, object> header in properties.Headers)
{
object o = header.Value;
switch (header.Key)
{
case XDeadHeader.WellknownName:
message.Headers.Add(BuildXDeadHeader(o));
break;
case XReceivedFromHeader.WellknownName:
message.Headers.Add(BuildXReceivedFromHeader(o));
break;
case RejectedHeader.WellknownName:
message.Headers.Add(new RejectedHeader());
break;
case ExceptionHeader.WellknownName:
message.Headers.Add(new ExceptionHeader
{
Message = BuildHeaderValue(o)
});
break;
default:
message.Headers.Add(new BusHeader(header.Key, BuildHeaderValue(o)));
break;
}
}
}
public void MessageProcessFailedOnce_RejectMessageUsingExceptionFilter_CheckMessageDeliveredToDeadLetterQ()
{
using (RabbitMQBus entityA = new RabbitMQBus(), entityB = new RabbitMQBus(), entityC = new RabbitMQBus(c => c.UseConnectionString("amqp://localhost/amq.direct")))
{
TransactionalPerson message = new TransactionalPerson
{
Id = 5
};
ManualResetEvent ev = new ManualResetEvent(false);
int counter = 0;
BusMessage <TransactionalPerson> actual = null;
using (ISubscriber subscriberA = entityA.CreateSubscriber(c => c.UseDurableQueue(QueueName).UseTransactionalDelivery(new MyFilter())))
{
subscriberA.Subscribe((Action <TransactionalPerson>)(d =>
{
counter++;
throw new Exception();
}));
subscriberA.Open();
using (ISubscriber deadLetterSubscriber = entityC.CreateSubscriber(c => c.UseDurableQueue(DeadLetterQueueName)))
{
deadLetterSubscriber.Subscribe <TransactionalPerson>(m =>
{
actual = m;
ev.Set();
});
deadLetterSubscriber.Open();
const int expected = 2;
using (IPublisher publisher = entityB.CreatePublisher())
{
publisher.Send(message);
}
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(50));
counter.Should().BeGreaterOrEqualTo(expected);
waitOne.Should().BeTrue();
actual.Data.ShouldBeEquivalentTo(message);
XDeadHeader xDeadHeader = actual.Headers.OfType <XDeadHeader>().First();
xDeadHeader.Exchange.Should().Be("amq.headers");
xDeadHeader.Reason.Should().Be("rejected");
xDeadHeader.Queue.Should().Be(QueueName);
}
}
}
}
public BusHandlerResponse HandleMessage(BusContext busContext, BusMessage busMessage)
{
var x = 10;
//WriteShareClass shareClass = busMessage.Payload as WriteShareClass;
log.Info($"Handling: order for bus Event");
return(new BusHandlerResponse());
}
public async Task HandleMessage(BusMessage message)
{
using (var scope = _ServiceProvider.CreateScope())
{
var request = message.ConvertBusMessageToMediatr();
await scope.ServiceProvider.GetRequiredService <IMediator>().Send(request);
}
}
public async Task <bool> Handle(EnrollmentRequestCommand request, CancellationToken cancellationToken)
{
var message = new BusMessage("CourseEnrollment", request);
await _Publisher.Publish(message, "course.queue");
return(true);
}
public void HandleCreateTruckOwnerUser(BusMessage message)
{
var truckOwnerUserInfo = JsonConvert.DeserializeObject <EstateManagerSetUpUser>(message.Data);
if (truckOwnerUserInfo.UserType == (int)UserTypes.Estate_Manager)
{
_truckOwnerUserService.CreateTruckOwnerUser(truckOwnerUserInfo);
}
}
private void Action(ILifetimeScope arg1, IAfEvent arg2, BusMessage sourceMessage)
{
if (arg2 is SmallCacheExpiredEvent evt &&
sourceMessage.SenderId != _afEventHub.AfEventHubId)
{
_logger.LogInformation("cache expired and remove it");
_smallCache.Remove(evt.CacheKey);
}
}
public void HandleCreateMarketerUser(BusMessage message)
{
var landlordUserInfo = JsonConvert.DeserializeObject <LandLordSetUpUser>(message.Data);
if (landlordUserInfo.UserType == (int)UserTypes.Estate_Manager)
{
_marketerUserService.CreateMarketerUser(landlordUserInfo);
}
}
private void OnMessage(BusMessage <ScaleoutMessage> message)
{
string sIndex = message.Headers.OfType <BusHeader>().Where(h => h.Name == StreamIndexHeader).Select(h => h.Value).FirstOrDefault();
int streamIndex;
Int32.TryParse(sIndex, out streamIndex);
OnReceived(streamIndex, (ulong)Interlocked.Increment(ref _payloadId), message.Data);
}
private static void SetUserHeaders <TData>(BusMessage <TData> busMessage, Message message)
{
foreach (BusHeader busHeader in busMessage.Headers)
{
message.Headers.Add(MessageHeader.CreateHeader(busHeader.Name,
MessagingConstants.Namespace.MessageBus,
busHeader.Value, false,
MessagingConstants.Actor.User));
}
}
public void Publish(BusMessage message)
{
var exchange = Exchange.DeclareTopic(_exName);
using (var channel = _bus.OpenPublishChannel())
{
channel.Publish<BusMessage>(exchange, "", new Message<BusMessage>(message));
_log.InfoFormat("Message for command id {0} published on exchange {1}", message.MessageId, _exName);
}
}
public void WrapAndPublish(ICommand command, CommandType commandType)
{
var message = new BusMessage
{
CommandType = commandType.ToString(),
MessageId = command.CommandId,
BodyJson = JsonConvert.SerializeObject(command, new IsoDateTimeConverter()),
SendDateTime = "" //use default
};
Publish(message);
}
public TData Receive <TData>()
{
BusMessage <TData> message = ReceiveBusMessage <TData>();
if (message == null)
{
return(default(TData));
}
return(message.Data);
}
public void Send(BusMessage message)
{
var endpoint = this.endpointInstanceProvider.Get(message.TopicName);
if (endpoint == null)
{
throw new Exception($"Failed to resolve NServiceBus endpoint mapping to send topic {message.TopicName}");
}
endpoint.Instance.Send(endpoint.Name, message);
}
public Task <TReplyData> Send <TData, TReplyData>(TData data, TimeSpan timeOut, bool persistant)
{
return(SendAndCreateTask(new BusMessage <TData> {
Data = data
}, timeOut, m =>
{
BusMessage <TReplyData> replyMessage = CreateBusMessage <TReplyData>(m);
return replyMessage.Data;
}, persistant));
}
private void Send(byte[] bytes, string contentType, string name, string ns, BusMessage busMessage, SendParams sendParams)
{
busMessage.Sent = DateTime.Now;
busMessage.BusId = sendParams.BusId;
BasicProperties basicProperties = new BasicProperties
{
AppId = busMessage.BusId,
Timestamp = busMessage.Sent.ToAmqpTimestamp(),
ContentType = contentType,
Headers = new Dictionary <string, object>()
};
if (!string.IsNullOrEmpty(name))
{
basicProperties.Type = name;
basicProperties.Headers.Add(MessagingConstants.HeaderNames.Name, name);
}
if (!string.IsNullOrEmpty(ns))
{
basicProperties.Headers.Add(MessagingConstants.HeaderNames.NameSpace, ns);
}
foreach (BusHeaderBase header in busMessage.Headers)
{
basicProperties.Headers.Add(header.Name, header.GetValue());
}
if (sendParams.PersistentDelivery)
{
basicProperties.Persistent = true;
}
if (!string.IsNullOrEmpty(sendParams.ReplyTo))
{
basicProperties.ReplyTo = sendParams.ReplyTo;
}
if (!string.IsNullOrEmpty(sendParams.CorrelationId))
{
basicProperties.CorrelationId = sendParams.CorrelationId;
}
if (sendParams.Priority.HasValue)
{
basicProperties.Priority = sendParams.Priority.Value;
}
sendParams.Model.BasicPublish(sendParams.Exchange, sendParams.RoutingKey, sendParams.MandatoryDelivery, basicProperties, bytes);
}
public BusMessage <T> ConstructMessage <T>(DataContractKey dataContractKey, IBasicProperties properties, T data)
{
BusMessage <T> message = new BusMessage <T>
{
Data = data,
BusId = properties.AppId,
Sent = properties.Timestamp.GetDateTime()
};
ConstructHeaders(message, properties);
return(message);
}
public bool SaveMessage <t>(BusMessage <t> message)
{
bool result = false;
IMongoCollection <BusMessage <t> > collection = GetMongoCollection <t>();
if (isValidCollection(collection))
{
collection.InsertOneAsync(message).Wait();
result = true;
}
return(result);
}
private void ConstructHeaders(BusMessage message, IBasicProperties properties)
{
foreach (KeyValuePair <string, object> header in properties.Headers)
{
object o = header.Value;
if (header.Key == XDeadHeader.WellknownName)
{
List <object> list = (List <object>)o;
Dictionary <string, object> values = (Dictionary <string, object>)list[0];
byte[] reason = (byte[])values["reason"];
byte[] queue = (byte[])values["queue"];
AmqpTimestamp time = (AmqpTimestamp)values["time"];
byte[] exchange = (byte[])values["exchange"];
List <object> routingKeys = (List <object>)values["routing-keys"];
XDeadHeader xDeadHeader = new XDeadHeader
{
Reason = Encoding.ASCII.GetString(reason),
Queue = Encoding.ASCII.GetString(queue),
Exchange = Encoding.ASCII.GetString(exchange),
Time = time.GetDateTime()
};
foreach (var routingKey in routingKeys)
{
xDeadHeader.RoutingKeys.Add(Encoding.ASCII.GetString((byte[])routingKey));
}
message.Headers.Add(xDeadHeader);
}
else if (header.Key == RejectedHeader.WellknownName)
{
message.Headers.Add(new RejectedHeader());
}
else if (header.Key == ExceptionHeader.WellknownName)
{
message.Headers.Add(new ExceptionHeader
{
Message = Encoding.ASCII.GetString((byte[])o)
});
}
else
{
message.Headers.Add(new BusHeader(header.Key, Encoding.ASCII.GetString((byte[])o)));
}
}
}
public void Send <TData>(BusMessage <TData> busMessage)
{
RawBusMessage rawBusMessage = new RawBusMessage
{
Data = busMessage.Data
};
foreach (BusHeader header in busMessage.Headers)
{
rawBusMessage.Headers.Add(header);
}
Send(rawBusMessage);
}
public BusHandlerResponse HandleMessage(BusContext busContext, BusMessage busMessage)
{
var x = 10;
//WriteShareClass shareClass = busMessage.Payload as WriteShareClass;
busContext.Bus.Publish(
"ShareClassCreated",
new BusEvent
{
TopicName = "ShareClassCreated",
Payload = "Test"
});
return(new BusHandlerResponse());
}
private RawBusMessage CreateRawMessage <TData>(BusMessage <TData> busMessage)
{
RawBusMessage rawBusMessage = new RawBusMessage
{
Data = busMessage.Data
};
foreach (var header in busMessage.Headers.Concat(_configuration.Headers))
{
rawBusMessage.Headers.Add(header);
}
return(rawBusMessage);
}
private void FireEvent(IAsyncCursor <BusMessage <t> > cursor, StorageManager storageManager)
{
List <BusMessage <t> > messages = cursor.Current.ToList();
FilterMessagesForTTL(messages);
BusMessage <t> lastMessage = messages.LastOrDefault();
if (lastMessage.IsNotNull())
{
ProcessedMessageTrack track = DBUtil.ToMessageTrack(lastMessage._id, lastMessage.CreationTime, lastMessage.Message.GetType(), this.listenerApplication);
storageManager.SaveProcessedMessageTrack(track);
FireEvent(messages.Select(x => x.Message).ToList());
}
}
public void Bus_BusMessage_HeadersAndPropertiesUsage()
{
const string busId = "Bus";
using (MessageBus.Core.RabbitMQBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
BusMessage <Person> message = new BusMessage <Person>
{
Data = new Person {
Id = 5
}
};
message.Headers.Add(new BusHeader
{
Name = "Version", Value = "Ver1"
});
BusMessage <Person> received = null;
ManualResetEvent ev = new ManualResetEvent(false);
DateTime sent;
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReceiveSelfPublish()))
{
subscriber.Subscribe((Action <BusMessage <Person> >)(m =>
{
received = m;
ev.Set();
}));
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
sent = DateTime.Now;
publisher.Send(message);
}
bool wait = ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
}
received.ShouldBeEquivalentTo(message, options => options.Excluding(m => m.BusId).Excluding(m => m.Sent));
received.BusId.Should().Be(busId);
received.Sent.Should().BeCloseTo(sent, 1000);
}
}
public void Send(BusMessage message)
{
var handlers = this.busHandlers.FindAll(bh => bh.CanHandleMessage(message));
var busContext = new BusContext(this);
try
{
Task.WaitAll(handlers.Select(busHandler => Task.Run(() => busHandler.HandleMessage(busContext, message))).Cast <Task>().ToArray());
}
catch (AggregateException ae)
{
throw ae.Flatten();
}
}
public async Task SendResponseMessagesAsync(BusMessage messageInfo)
{
IMessageSender messageSender;
messageSender = new MessageSender(appOptions.BusConnectionString, messageInfo.TopicName);
var messagesToSend = new List <Message>();
var message = new Message(messageInfo.MessageBody);
message.SessionId = messageInfo.TokenID;
message.UserProperties.Add(appOptions.RuleName, messageInfo.SubscriptionName);
messagesToSend.Add(message);
await messageSender.SendAsync(messagesToSend);
await messageSender.CloseAsync();
}
public void Handle(BusMessage busMessage)
{
DateTime dtSent = DateTime.Parse(busMessage.SendDateTime);
SystemCommandType systemCommandType = GetSystemCommandType(busMessage.CommandType);
switch(systemCommandType)
{
case SystemCommandType.AddRetriesToQ:
if (DateTime.Now.Subtract(dtSent) < new TimeSpan(0, 0, 10, 0)) //only process message sent in the last 10 mintuts
_qAddRetryCommandHandler.Execute();
break;
case SystemCommandType.ReRouteDocument:
var command = JsonConvert.DeserializeObject<ReRouteDocumentCommand>(busMessage.BodyJson);
_reRouteDocumentCommandHandler.Execute(command);
break;
}
}
public void Handle(BusMessage message)
{
Stopwatch handlerTimer = new Stopwatch();
handlerTimer.Start();
_logger.InfoFormat(" Subscriber Processing command : {0} with {1} ", message.CommandType, message.BodyJson);
CommandProcessingStatus currentStatus = CommandProcessingStatus.SubscriberProcessBegin;
//ICommand command = _commandDeserialize.DeserializeCommand(message.CommandType, message.BodyJson);
ICommand command = JsonConvert.DeserializeObject<DocumentCommand>(message.BodyJson);
try
{
//run guard to confirm if message can be run
_subscriberCommandExecutionGuard.CanExecute(command);
//record to command audit that message has arrived
Audit("CommandProcessing", string.Format("Handle : {0} Command {1} of Type {2}", currentStatus.ToString(), command.CommandId.ToString(), message.CommandType), currentStatus.ToString(), command.CommandGeneratedByCostCentreId);
if (!string.IsNullOrWhiteSpace(message.SendDateTime))
{
DateTime _sendDateTime = _commandDeserialize.DeserializeSendDateTime(message.SendDateTime);
command.SendDateTime = _sendDateTime;
}
_logger.InfoFormat("Handle Command {4} : {0} for Document id {1} from cost centre {2} : {3}", command.CommandId, command.DocumentId, command.CommandGeneratedByCostCentreId, command.CommandGeneratedByCostCentreApplicationId, command.GetType().ToString());
CommandType commandType = GetCommandType(message.CommandType);
command = _documentHelper.GetExternalRef(command);
CommandRouteOnRequestDTO commandRouteItems = _commandRoutingOnRequestResolver.GetCommand(command, commandType);
if (commandRouteItems != null)
{
_runCommandOnRequestInHostedEnvironment.RunCommandInHostedenvironment(commandRouteItems.RouteOnRequest, command);
_commandRoutingOnRequestRepository.Add(commandRouteItems.RouteOnRequest);
var ccAdded = new List<Guid>();
foreach (var rc in commandRouteItems.CommandRouteCentres.Distinct())
{
if (ccAdded.Any(n => n == rc.CostCentreId))
continue;
ccAdded.Add(rc.CostCentreId);
rc.CommandRouteOnRequestId = commandRouteItems.RouteOnRequest.Id;
rc.DateAdded = DateTime.Now;
_commandRoutingOnRequestRepository.AddRoutingCentre(rc);
}
RouteExternalRef(commandRouteItems,command);
}
currentStatus = CommandProcessingStatus.Complete;
// _busPublisher.SignalComplete(command);
}
catch (MarkForRetryException ex)
{
_logger.Error("Markfor retry", ex);
currentStatus = CommandProcessingStatus.MarkedForRetry;
}
catch (CommandAlreadyExecutedException ex)
{
_logger.Error("Command already executed", ex);
currentStatus = CommandProcessingStatus.Failed;
}
catch (Exception ex)
{
//record to command audit that message failed to be processed
_logger.Error("Command processing error ", ex);
currentStatus = CommandProcessingStatus.MarkedForRetry;
//throw ex;
}
Audit("CommandProcessing", string.Format("Handle : {0} Command {1} of Type {2}", currentStatus.ToString(), command.CommandId.ToString(), message.CommandType), currentStatus.ToString(), command.CommandGeneratedByCostCentreId);
_commandProcessingAuditRepository.SetCommandStatus(message.MessageId, currentStatus);
//record that message was processed successfully
handlerTimer.Stop();
_logger.InfoFormat("Total Request Time(m/s) {0} for command {1} ",handlerTimer.Elapsed.TotalMilliseconds, message.CommandType);
}
public void Publish(BusMessage message)
{
// _busSubscriber.Handle(message);
throw new NotImplementedException("StubbedBusPublisher");
}
