public void ProcessReceivedMessageInputValidMessageAssertValid()
{
var jsonDataContractSerializer = new JsonDataContractSerializer();
var messageFake = new MessageFake {
CreatedAt = DateTime.Now.Date
};
var messageBus = MessageBusFactory.Create(new Identification(), messageFake, jsonDataContractSerializer);
var inputGateway = AgentGatewayFactory.CreateInputGateway <IMessage>(_receiverEndPoint.Object, 5);
var eventargs = new EventReceiverEndPointHandlerArgs
{
Message = Encoding.UTF8.GetBytes(jsonDataContractSerializer.Serialize(messageBus))
};
_receiverEndPoint.Setup(r => r.Start()).Raises(r => r.OnReceivedMessage += null,
new object[] { null, eventargs });
IMessage messageReceived = null;
inputGateway.OnMessage += (sender, args) => messageReceived = args.Message;
inputGateway.Start();
Assert.AreEqual(messageFake.CreatedAt, ((IMessageFake)messageReceived).CreatedAt);
}
protected override void Load(ContainerBuilder builder)
{
var connectionString = ConfigurationManager.ConnectionStrings["rabbitMQ"].ConnectionString;
//message bus
var messageBus = MessageBusFactory.CreateBus(connectionString);
builder
.RegisterInstance(messageBus)
.As <IAdvancedBus>();
//queue consumers
builder.RegisterType <CarRequestMessageProcessorFactory>()
.As <IMessageProcessorFactory <RecogniseBatchCourtesyAmountRequest> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <RecogniseBatchCourtesyAmountRequest> >()
.As <IQueueConsumer <RecogniseBatchCourtesyAmountRequest> >()
.SingleInstance();
//exchange publishers
builder.RegisterType <ExchangePublisher <RecogniseBatchCourtesyAmountResponse> >()
.As <IExchangePublisher <RecogniseCourtesyAmountResponse> >();
}
public void ProcessReceivedMessageInputValidMessageAssertValid()
{
var jsonDataContractSerializer = new JsonDataContractSerializer();
var messageFake = new MessageFake {
CreatedAt = DateTime.Now.Date
};
var messageBus = MessageBusFactory.Create(new Identification(), messageFake, jsonDataContractSerializer);
var inputGateway = RouterGatewayFactory.CreateInputGateway(_receiverEndPoint.Object, 5);
var eventargs = new EventReceiverEndPointHandlerArgs
{
Message = Encoding.UTF8.GetBytes(jsonDataContractSerializer.Serialize(messageBus))
};
_receiverEndPoint.Setup(r => r.Start()).Raises(r => r.OnReceivedMessage += null, new object[] { null, eventargs });
MessageBus messageReceived = null;
inputGateway.OnMessage += (sender, args) => messageReceived = jsonDataContractSerializer.Deserialize <MessageBus>(args.Message);
inputGateway.Start();
Assert.AreEqual(messageBus.Body, messageReceived.Body);
Assert.AreEqual(messageBus.Header.Type, messageReceived.Header.Type);
Assert.AreEqual(messageBus.Header.BodyType, messageReceived.Header.BodyType);
}
public void Setup()
{
//EneterTrace.DetailLevel = EneterTrace.EDetailLevel.Debug;
//EneterTrace.TraceLog = new StreamWriter("d:/tracefile.txt");
// Generate random number for the port.
int aPort1 = RandomPortGenerator.GenerateInt();
int aPort2 = aPort1 + 10;
IMessagingSystemFactory anUnderlyingMessaging = new SharedMemoryMessagingSystemFactory();
IDuplexInputChannel aMessageBusServiceInputChannel = anUnderlyingMessaging.CreateDuplexInputChannel("MyServicesAddress");
IDuplexInputChannel aMessageBusClientInputChannel = anUnderlyingMessaging.CreateDuplexInputChannel("MyClientsAddress");
myMessageBus = new MessageBusFactory().CreateMessageBus();
myMessageBus.AttachDuplexInputChannels(aMessageBusServiceInputChannel, aMessageBusClientInputChannel);
MessagingSystemFactory = new MessageBusMessagingFactory("MyServicesAddress", "MyClientsAddress", anUnderlyingMessaging)
{
ConnectTimeout = TimeSpan.FromMilliseconds(3000)
};
// Address of the service in the message bus.
ChannelId = "Service1_Address";
}
public void Setup()
{
//EneterTrace.DetailLevel = EneterTrace.EDetailLevel.Debug;
//EneterTrace.TraceLog = new StreamWriter("d:/tracefile.txt");
// Generate random number for the port.
int aPort1 = RandomPortGenerator.GenerateInt();
int aPort2 = aPort1 + 10;
IMessagingSystemFactory anUnderlyingMessaging = new TcpMessagingSystemFactory(new EasyProtocolFormatter());
IDuplexInputChannel aMessageBusServiceInputChannel = anUnderlyingMessaging.CreateDuplexInputChannel("tcp://[::1]:" + aPort1 + "/");
IDuplexInputChannel aMessageBusClientInputChannel = anUnderlyingMessaging.CreateDuplexInputChannel("tcp://[::1]:" + aPort2 + "/");
myMessageBus = new MessageBusFactory().CreateMessageBus();
myMessageBus.AttachDuplexInputChannels(aMessageBusServiceInputChannel, aMessageBusClientInputChannel);
MessagingSystemFactory = new MessageBusMessagingFactory("tcp://[::1]:" + aPort1 + "/", "tcp://[::1]:" + aPort2 + "/", anUnderlyingMessaging)
{
ConnectTimeout = TimeSpan.FromMilliseconds(3000)
};
// Address of the service in the message bus.
ChannelId = "Service1_Address";
CompareResponseReceiverId = false;
}
protected override void Load(ContainerBuilder builder)
{
//Message Bus
var connectionString = ConfigurationManager.ConnectionStrings["rabbitMQ"].ConnectionString;
var messageBus = MessageBusFactory.CreateBus(connectionString);
builder
.RegisterInstance(messageBus)
.As <IAdvancedBus>()
.SingleInstance();
//Queues
//Exchanges
builder
.RegisterType <ExchangePublisher <JobRequest> >()
.As <IExchangePublisher <JobRequest> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <Incident> >()
.As <IExchangePublisher <Incident> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <string> >()
.As <IExchangePublisher <string> >()
.SingleInstance();
//Misc
}
static GetVouchersInformationBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
ResponseExchange = new ExchangePublisher <GetVouchersInformationResponse>(Bus);
RequestQueue = Bus.QueueDeclare(ConfigurationHelper.GetPoolVouchersQueueName);
}
static CorrectTransactionBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher <CorrectBatchTransactionRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.CorrectTransactionResponseQueueName);
}
static ValidateCodelineBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher <ValidateBatchCodelineRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.ValidateCodelineResponseQueueName);
}
static CreateAdjustmentLettersBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher <CreateBatchAdjustmentLettersRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.ResponseQueueName);
}
static AutoReadCarBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
InboundExchange = new ExchangePublisher <RecogniseBatchCourtesyAmountRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.OutboundQueueName);
}
static GenerateCorrespondingVoucherBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher <GenerateCorrespondingVoucherRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.GenerateCorrespondingVoucherResponseQueueName);
}
static CheckThirdPartyBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher <CheckThirdPartyBatchRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.CheckThirdPartyResponseQueueName);
}
static VifBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
RequestExchange = new ExchangePublisher <SendBatchValueInstructionFileRequest>(Bus);
Queue = Bus.QueueDeclare(ConfigurationHelper.VifResponseQueueName);
}
/// <summary>
/// Reinjects the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="header">The header.</param>
public void Reinject(IMessage message, MessageHeader header)
{
if (header.ReinjectionNumber > _maxReijections)
{
return;
}
header.ReinjectionNumber++;
var messageBus = MessageBusFactory.Create(header.IdentificationService, message, DataContractSerializer);
messageBus.Header = header;
var serializedMessage = DataContractSerializer.Serialize(messageBus);
_receiverReceiverEndPoint.Reinject(serializedMessage, header.Priority);
}
public void SendMessageAssertTrue()
{
var jsonDataContractSerializer = new JsonDataContractSerializer();
var messageFake = new MessageFake {
CreatedAt = DateTime.Now.Date
};
var messageBus = MessageBusFactory.Create(new Identification(), messageFake, jsonDataContractSerializer);
var message = string.Empty;
_senderEndPoint.Setup(s => s.Send(It.IsAny <string>(), It.IsAny <int>())).Callback <string, int>((s, p) => message = s);
var outputGateway = RouterGatewayFactory.CreateOutputGateway(_senderEndPoint.Object);
var serialize = jsonDataContractSerializer.Serialize(messageBus);
outputGateway.Send(Encoding.UTF8.GetBytes(serialize));
Assert.AreEqual(serialize, message);
}
/// <summary>
/// Sends the specified MSG.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="priority">The priority.</param>
/// <returns>Bytes Sent</returns>
public override int Send(IMessage message, int priority)
{
try
{
var messageBus = MessageBusFactory.Create(_identification, message, DataContractSerializer);
messageBus.Header.Priority = priority;
var callerContext = CallerContextFactory.Create(_identification);
messageBus.Header.CallStack.Push(callerContext);
var serializedMessage = MessageBusParser.ToBytes(messageBus);
SenderEndPoint.Send(serializedMessage, priority);
InvokeSentMessage(messageBus.Header.BodyType, serializedMessage.Length);
return(serializedMessage.Length);
}
catch (Exception ex)
{
Logger.Error("OutputGateway - Error Send Message", ex);
throw;
}
}
public void SendMessageAssertTrue()
{
var jsonDataContractSerializer = new JsonDataContractSerializer();
var messageFake = new MessageFake {
CreatedAt = DateTime.Now.Date
};
var messageBus = MessageBusFactory.Create(new Identification(), messageFake, jsonDataContractSerializer);
var message = string.Empty;
_senderEndPoint.Setup(s => s.Send(It.IsAny <string>(), It.IsAny <int>())).Callback <string, int>((s, p) => message = s);
var outputGateway = AgentGatewayFactory.CreateOutputGateway(_identification, _senderEndPoint.Object);
outputGateway.Send(messageFake);
var deserialized = jsonDataContractSerializer.Deserialize <MessageBus>(message);
Assert.AreEqual(messageBus.Body, deserialized.Body);
Assert.AreEqual(messageBus.Header.Type, deserialized.Header.Type);
Assert.AreEqual(messageBus.Header.BodyType, deserialized.Header.BodyType);
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageInfo">The message info.</param>
/// <returns></returns>
public override int Send(IMessage message, IMessageInfo messageInfo)
{
try
{
var messageBus = MessageBusFactory.Create(_identification, message, DataContractSerializer);
messageBus.Header.Priority = messageInfo.Header.Priority;
messageBus.Header.CallStack = messageInfo.Header.CallStack;
messageBus.Header.CallContext = messageInfo.CurrentCallContext;
if (!messageInfo.IsReply)
{
var callerContext = CallerContextFactory.Create(_identification, messageInfo.CurrentSession);
messageBus.Header.CallStack.Push(callerContext);
}
else
{
messageBus.Header.Type = MessageBusType.Reply;
}
var serializedMessage = MessageBusParser.ToBytes(messageBus);
if (!messageInfo.IsReply)
{
messageBus.Header.CallStack.Pop();
}
SenderEndPoint.Send(serializedMessage, messageInfo.Header.Priority);
InvokeSentMessage(messageBus.Header.BodyType, serializedMessage.Length);
return(serializedMessage.Length);
}
catch (Exception ex)
{
Logger.Error("OutputGateway - Error Send Message", ex);
throw;
}
}
protected override void Load(ContainerBuilder builder)
{
var connectionString = ConfigurationManager.ConnectionStrings["rabbitMQ"].ConnectionString;
var messageBus = MessageBusFactory.CreateBus(connectionString);
builder
.RegisterInstance(messageBus)
.As <IAdvancedBus>()
.SingleInstance();
builder
.RegisterType <AdjustmentLettersRequestProcessorFactory>()
.As <IMessageProcessorFactory <CreateBatchAdjustmentLettersRequest> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <CreateBatchAdjustmentLettersRequest> >()
.As <IQueueConsumer <CreateBatchAdjustmentLettersRequest> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <CreateBatchAdjustmentLettersResponse> >()
.As <IExchangePublisher <CreateBatchAdjustmentLettersResponse> >()
.SingleInstance();
builder
.RegisterType <CustomErrorHandling>()
.As <ICustomErrorHandling>()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <Error> >()
.As <IExchangePublisher <Error> >()
.SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
var connectionString = ConfigurationManager.ConnectionStrings["rabbitMQ"].ConnectionString;
//MessageBus
var messageBus = MessageBusFactory.CreateBus(connectionString);
builder
.RegisterInstance(messageBus)
.As <IAdvancedBus>()
.SingleInstance();
//Error Handling
builder
.RegisterType <CustomErrorHandling>()
.As <ICustomErrorHandling>()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <Error> >()
.As <IExchangePublisher <Error> >()
.SingleInstance();
//Mapper
builder
.RegisterType <BatchCodelineRequestMapHelper>()
.As <IBatchCodelineRequestMapHelper>()
.SingleInstance();
builder
.RegisterType <BatchTransactionRequestMapHelper>()
.As <IBatchTransactionRequestMapHelper>()
.SingleInstance();
builder
.RegisterType <BatchCheckThirdPartyRequestMapHelper>()
.As <IBatchCheckThirdPartyRequestMapHelper>()
.SingleInstance();
builder
.RegisterType <GenerateCorrespondingVoucherRequestMapHelper>()
.As <IGenerateCorrespondingVoucherRequestMapHelper>()
.SingleInstance();
builder
.RegisterType <GenerateBulkCreditRequestMapHelper>()
.As <IGenerateBulkCreditRequestMapHelper>()
.SingleInstance();
//Queues
builder
.RegisterType <ValidateCodelineRequestProcessorFactory>()
.As <IMessageProcessorFactory <ValidateBatchCodelineRequest> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <ValidateBatchCodelineRequest> >()
.As <IQueueConsumer <ValidateBatchCodelineRequest> >()
.SingleInstance();
builder
.RegisterType <CorrectCodelineRequestProcessorFactory>()
.As <IMessageProcessorFactory <CorrectBatchCodelineRequest> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <CorrectBatchCodelineRequest> >()
.As <IQueueConsumer <CorrectBatchCodelineRequest> >()
.SingleInstance();
builder
.RegisterType <ValidateTransactionRequestProcessorFactory>()
.As <IMessageProcessorFactory <ValidateBatchTransactionRequest> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <ValidateBatchTransactionRequest> >()
.As <IQueueConsumer <ValidateBatchTransactionRequest> >()
.SingleInstance();
builder
.RegisterType <CorrectTransactionRequestProcessorFactory>()
.As <IMessageProcessorFactory <CorrectBatchTransactionRequest> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <CorrectBatchTransactionRequest> >()
.As <IQueueConsumer <CorrectBatchTransactionRequest> >()
.SingleInstance();
builder
.RegisterType <CheckThirdPartyRequestProcessorFactory>()
.As <IMessageProcessorFactory <CheckThirdPartyBatchRequest> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <CheckThirdPartyBatchRequest> >()
.As <IQueueConsumer <CheckThirdPartyBatchRequest> >()
.SingleInstance();
builder
.RegisterType <GenerateCorrespondingVoucherRequestProcessorFactory>()
.As <IMessageProcessorFactory <GenerateCorrespondingVoucherRequest> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <GenerateCorrespondingVoucherRequest> >()
.As <IQueueConsumer <GenerateCorrespondingVoucherRequest> >()
.SingleInstance();
builder
.RegisterType <GetVouchersInformationResponseProcessorFactory>()
.As <IMessageProcessorFactory <GetVouchersInformationResponse> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <GetVouchersInformationResponse> >()
.As <IQueueConsumer <GetVouchersInformationResponse> >()
.SingleInstance();
builder
.RegisterType <QueueConsumer <GenerateBatchBulkCreditRequest> >()
.As <IQueueConsumer <GenerateBatchBulkCreditRequest> >()
.SingleInstance();
builder
.RegisterType <GenerateBulkCreditRequestProcessorFactory>()
.As <IMessageProcessorFactory <GenerateBatchBulkCreditRequest> >()
.SingleInstance();
//Exchanges
builder
.RegisterType <ExchangePublisher <ValidateBatchCodelineResponse> >()
.As <IExchangePublisher <ValidateBatchCodelineResponse> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <CorrectBatchCodelineResponse> >()
.As <IExchangePublisher <CorrectBatchCodelineResponse> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <ValidateBatchTransactionResponse> >()
.As <IExchangePublisher <ValidateBatchTransactionResponse> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <CorrectBatchTransactionResponse> >()
.As <IExchangePublisher <CorrectBatchTransactionResponse> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <CheckThirdPartyBatchResponse> >()
.As <IExchangePublisher <CheckThirdPartyBatchResponse> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <GenerateCorrespondingVoucherResponse> >()
.As <IExchangePublisher <GenerateCorrespondingVoucherResponse> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <GetVouchersInformationRequest> >()
.As <IExchangePublisher <GetVouchersInformationRequest> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <GetVouchersInformationRequest> >()
.As <IExchangePublisher <GetVouchersInformationRequest> >()
.SingleInstance();
builder
.RegisterType <ExchangePublisher <GenerateBatchBulkCreditResponse> >()
.As <IExchangePublisher <GenerateBatchBulkCreditResponse> >()
.SingleInstance();
}
public RootController()
{
_solver = FibonacciSolverFactory.GetSolver();
_messageBus = MessageBusFactory.GetMassTransitMessageBus();
}
static JobBus()
{
Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString);
Queue = Bus.QueueDeclare(ConfigurationHelper.JobsQueueName);
}
public FibonacciService()
{
_messageBus = MessageBusFactory.GetMassTransitMessageBus(HandleResponse);
_messageBus.Start();
}
