public void Run()
{
if (!Configure.Instance.DistributorConfiguredToRunOnThisEndpoint())
return;
var dataTransport = new TransactionalTransport
{
NumberOfWorkerThreads = NumberOfWorkerThreads,
IsTransactional = true,
MessageReceiver = new MsmqMessageReceiver(),
MaxRetries = 5,
FailureManager = Builder.Build(MessageFailureManager.GetType()) as IManageMessageFailures
};
distributor = new Unicast.Distributor.Distributor
{
MessageBusTransport = dataTransport,
MessageSender = new MsmqMessageSender(),
WorkerManager = WorkerAvailabilityManager,
DataTransportInputQueue = InputQueue
};
distributor.Start();
}
public void Start()
{
var templateTransport = Configure.Instance.Builder.Build <TransactionalTransport>();
transport = new TransactionalTransport
{
//todo grab the receiver from the main bus and clone
MessageReceiver = new MsmqMessageReceiver(),
IsTransactional = true,
NumberOfWorkerThreads = templateTransport.NumberOfWorkerThreads == 0 ? 1 : templateTransport.NumberOfWorkerThreads,
MaxRetries = templateTransport.MaxRetries,
FailureManager = templateTransport.FailureManager
};
transport.TransportMessageReceived += (s, e) =>
{
var address = GetRemoteAddress(RemoteAddress, e.Message);
channelSender.Send(e.Message, address);
notifier.RaiseMessageForwarded(ChannelType.Msmq, ChannelType.Http, e.Message);
//todo get audit settings from the audit settings of the host (possibly allowing to override in config)
//if (!string.IsNullOrEmpty(audit))
// messageSender.Send(e.Message, audit);
};
transport.Start(InputQueue);
}
public void Run()
{
if (!Configure.Instance.DistributorConfiguredToRunOnThisEndpoint())
{
return;
}
controlTransport = new TransactionalTransport
{
IsTransactional = true,
FailureManager = MessageFailureManager,
MessageReceiver = new MsmqMessageReceiver(),
MaxRetries = 5,
NumberOfWorkerThreads = NumberOfWorkerThreads,
};
controlTransport.TransportMessageReceived +=
(obj, ev) =>
{
var transportMessage = ev.Message;
if (!transportMessage.IsControlMessage())
{
return;
}
HandleControlMessage(transportMessage);
};
controlTransport.Start(ControlQueue);
}
public void Run()
{
if (!Configure.Instance.DistributorConfiguredToRunOnThisEndpoint())
{
return;
}
var dataTransport = new TransactionalTransport
{
NumberOfWorkerThreads = NumberOfWorkerThreads,
IsTransactional = true,
MessageReceiver = new MsmqMessageReceiver()
};
distributor = new Unicast.Distributor.Distributor
{
MessageBusTransport = dataTransport,
MessageSender = new MsmqMessageSender(),
WorkerManager = WorkerAvailabilityManager,
DataTransportInputQueue = InputQueue
};
distributor.Start();
}
public void A_message_that_fails_processing_should_go_back_to_queue_on_transactional_queue()
{
TransactionalTransport.MessageArrived += ThrowOnFirstAction();
TransactionalTransport.Send(TransactionalTestQueueUri, new object[] { DateTime.Today });
gotFirstMessage.WaitOne(TimeSpan.FromSeconds(30), false);
Assert.NotNull(transactionalQueue.Peek());
gotSecondMessage.Set();
}
public void Init()
{
NServiceBus.Configure.With().Log4Net().DefaultBuilder().UnicastBus();
string errorQueue = ConfigurationManager.AppSettings["ErrorQueue"];
string audit = ConfigurationManager.AppSettings["ForwardReceivedMessageTo"];
string listenUrl = ConfigurationManager.AppSettings["ListenUrl"];
string n = ConfigurationManager.AppSettings["NumberOfWorkerThreads"];
string remoteUrl = ConfigurationManager.AppSettings["RemoteUrl"];
connectionString = ConfigurationManager.AppSettings["ConnectionString"];
inputQueue = ConfigurationManager.AppSettings["InputQueue"];
outputQueue = ConfigurationManager.AppSettings["OutputQueue"];
int numberOfWorkerThreads = 10;
int.TryParse(n, out numberOfWorkerThreads);
ThreadPool.SetMaxThreads(numberOfWorkerThreads, numberOfWorkerThreads);
messageSender = new MsmqMessageSender {
UseDeadLetterQueue = true, UseJournalQueue = true
};
transport = new TransactionalTransport
{
MessageReceiver = new MsmqMessageReceiver(),
IsTransactional = true,
NumberOfWorkerThreads = numberOfWorkerThreads
};
notifier = new MessageNotifier();
NServiceBus.Configure.Instance.Configurer.RegisterSingleton <ISendMessages>(messageSender);
NServiceBus.Configure.Instance.Configurer.RegisterSingleton <ITransport>(transport);
NServiceBus.Configure.Instance.Configurer.RegisterSingleton <INotifyAboutMessages>(notifier);
transport.TransportMessageReceived += (s, e) =>
{
new MsmqHandler(notifier, listenUrl).Handle(e.Message, remoteUrl);
if (!string.IsNullOrEmpty(audit))
{
messageSender.Send(e.Message, audit);
}
};
listener = new HttpListener();
listener.Prefixes.Add(listenUrl);
}
public void Init()
{
var numberOfThreads = int.Parse(ConfigurationManager.AppSettings["NumberOfWorkerThreads"]);
var maxRetries = int.Parse(ConfigurationManager.AppSettings["MaxRetries"]);
var remoteServer = ConfigurationManager.AppSettings["RemoteServer"];
var externalTransport = new TransactionalTransport
{
NumberOfWorkerThreads = numberOfThreads,
MaxRetries = maxRetries,
IsTransactional = true,
MessageReceiver = new MsmqMessageReceiver()
};
var internalTransport = new TransactionalTransport
{
NumberOfWorkerThreads = numberOfThreads,
MaxRetries = maxRetries,
IsTransactional = true,
MessageReceiver = new MsmqMessageReceiver()
};
var configure = Configure.With().DefaultBuilder();
configure.Configurer.ConfigureComponent <MsmqSubscriptionStorage>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.Queue, "NServiceBus_Proxy_Subscriptions");
configure.Configurer.ConfigureComponent <MsmqProxyDataStorage>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.StorageQueue, "NServiceBus_Proxy_Storage");
configure.Configurer.ConfigureComponent <Proxy>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.RemoteServer, remoteServer);
Logger.Info("Proxy configured for remoteserver: " + remoteServer);
var proxy = configure.Builder.Build <Proxy>();
proxy.ExternalTransport = externalTransport;
proxy.ExternalMessageSender = new MsmqMessageSender();
proxy.InternalTransport = internalTransport;
proxy.InternalMessageSender = new MsmqMessageSender();
proxy.InternalAddress = ConfigurationManager.AppSettings["InternalQueue"];
proxy.ExternalAddress = ConfigurationManager.AppSettings["ExternalQueue"];
proxy.Start();
Logger.Info("Proxy successfully started");
}
public void When_a_message_fails_enough_times_it_is_moved_to_error_queue_using_transactional_queue()
{
int count = 0;
TransactionalTransport.MessageArrived += o =>
{
Interlocked.Increment(ref count);
throw new InvalidOperationException();
};
TransactionalTransport.Send(TransactionalTestQueueUri, new object[] { DateTime.Today });
using (var errorQueue = new MessageQueue(transactionalTestQueuePath + ";errors"))
{
Assert.NotNull(errorQueue.Peek());
Assert.Equal(5, count);
}
}
public ITransport GetTransport(EventHandler <TransportMessageReceivedEventArgs> onTransportMessageReceived)
{
var transport = new TransactionalTransport
{
MessageReceiver = new MsmqMessageReceiver(),
IsTransactional = true,
NumberOfWorkerThreads = 1,
MaxRetries = 5,
FailureManager = new FaultManager
{
ErrorQueue = errorQueue
}
};
transport.TransportMessageReceived += onTransportMessageReceived;
return(transport);
}
void ConfigureDistributor(int numberOfThreads)
{
var dataTransport = new TransactionalTransport
{
NumberOfWorkerThreads = numberOfThreads,
IsTransactional = true,
MessageReceiver = new MsmqMessageReceiver()
};
var distributor = new Unicast.Distributor.Distributor
{
MessageBusTransport = dataTransport,
MessageSender = new MsmqMessageSender(),
DataTransportInputQueue = ConfigurationManager.AppSettings["DataInputQueue"]
};
Configure.Instance.Configurer.RegisterSingleton <Unicast.Distributor.Distributor>(distributor);
}
public void Start()
{
var templateTransport = Configure.Instance.Builder.Build <TransactionalTransport>();
transport = new TransactionalTransport
{
//todo grab the receiver from the main bus and clone
MessageReceiver = new MsmqMessageReceiver(),
IsTransactional = true,
NumberOfWorkerThreads = templateTransport.NumberOfWorkerThreads == 0 ? 1 : templateTransport.NumberOfWorkerThreads,
MaxRetries = templateTransport.MaxRetries,
FailureManager = templateTransport.FailureManager
};
transport.TransportMessageReceived += (s, e) =>
{
var transportMessage = e.Message;
var address = GetRemoteAddress(RemoteAddress, transportMessage);
//todo - why are we doing this?
if (!String.IsNullOrEmpty(transportMessage.IdForCorrelation))
{
transportMessage.IdForCorrelation = transportMessage.Id;
}
var headers = new NameValueCollection();
HeaderMapper.Map(transportMessage, headers);
channelSender.Send(address, headers, transportMessage.Body);
notifier.RaiseMessageForwarded(ChannelType.Msmq, channelSender.Type, transportMessage);
//todo get audit settings from the audit settings of the host (possibly allowing to override in config)
//if (!string.IsNullOrEmpty(audit))
// messageSender.Send(e.Message, audit);
};
transport.Start(InputQueue);
}
public void Start(string inputAddress)
{
localAddress = inputAddress;
var templateTransport = Configure.Instance.Builder.Build <TransactionalTransport>();
transport = new TransactionalTransport
{
//todo grab the receiver from the main bus and clone
MessageReceiver = new MsmqMessageReceiver(),
IsTransactional = true,
NumberOfWorkerThreads = templateTransport.NumberOfWorkerThreads == 0 ? 1 : templateTransport.NumberOfWorkerThreads,
MaxRetries = templateTransport.MaxRetries,
FailureManager = templateTransport.FailureManager
};
transport.TransportMessageReceived += OnTransportMessageReceived;
transport.Start(inputAddress);
}
public void Run()
{
if (!ConfigureTimeoutManager.TimeoutManagerEnabled)
{
return;
}
inputTransport = new TransactionalTransport
{
MessageReceiver = new MsmqMessageReceiver(),
IsTransactional = true,
NumberOfWorkerThreads = MainTransport.NumberOfWorkerThreads == 0 ? 1 : MainTransport.NumberOfWorkerThreads,
MaxRetries = MainTransport.MaxRetries,
FailureManager = MainTransport.FailureManager
};
inputTransport.TransportMessageReceived += OnTransportMessageReceived;
inputTransport.Start(ConfigureTimeoutManager.TimeoutManagerAddress);
}
public void Start(Address inputAddress)
{
localAddress = inputAddress;
addressOfAuditStore = settings.AddressOfAuditStore;
transport = new TransactionalTransport
{
MessageReceiver = settings.Receiver,
IsTransactional = true,
NumberOfWorkerThreads = settings.NumberOfWorkerThreads,
MaxRetries = settings.MaxRetries,
FailureManager = settings.FailureManager
};
transport.TransportMessageReceived += OnTransportMessageReceived;
transport.Start(localAddress);
Logger.InfoFormat("Gateway started listening on inputs on - {0}", localAddress);
}
public void Init()
{
var dataTransport = new TransactionalTransport
{
NumberOfWorkerThreads = NumberOfWorkerThreads,
IsTransactional = true,
MessageReceiver = new MsmqMessageReceiver()
};
distributor = new Unicast.Distributor.Distributor
{
MessageBusTransport = dataTransport,
MessageSender = new MsmqMessageSender(),
WorkerManager = WorkerAvailabilityManager,
DataTransportInputQueue = InputQueue
};
var bus = Configure.Instance.Builder.Build <IStartableBus>();
bus.Started += (x, y) => distributor.Start();
}
public void Run()
{
if (!ConfigureTimeoutManager.TimeoutManagerEnabled)
{
return;
}
var messageReceiver = MessageReceiverFactory != null?MessageReceiverFactory() : new MsmqMessageReceiver();
inputTransport = new TransactionalTransport
{
MessageReceiver = messageReceiver,
IsTransactional = true,
NumberOfWorkerThreads = MainTransport.NumberOfWorkerThreads == 0 ? 1 : MainTransport.NumberOfWorkerThreads,
MaxRetries = MainTransport.MaxRetries,
FailureManager = Builder.Build(MainTransport.FailureManager.GetType()) as IManageMessageFailures
};
inputTransport.TransportMessageReceived += OnTransportMessageReceived;
inputTransport.Start(ConfigureTimeoutManager.TimeoutManagerAddress);
}
public void Init()
{
endpointTransport = Configure.Instance.Builder.Build <ITransport>();
endpointTransport.FinishedMessageProcessing += (x, y) => SendReadyMessage(false);
var bus = Configure.Instance.Builder.Build <IStartableBus>();
bus.Started += (x, y) =>
{
SendReadyMessage(true);
controlTransport.Start(ControlQueue);
};
endpointBus = Configure.Instance.Builder.Build <IBus>();
controlTransport = new TransactionalTransport
{
IsTransactional = true,
FailureManager = Configure.Instance.Builder.Build <IManageMessageFailures>(),
MessageReceiver = new MsmqMessageReceiver(),
MaxRetries = 1,
NumberOfWorkerThreads = NumberOfWorkerThreads
};
var serializer = Configure.Instance.Builder.Build <IMessageSerializer>();
controlTransport.TransportMessageReceived +=
(obj, ev) =>
{
var messages = serializer.Deserialize(new MemoryStream(ev.Message.Body));
foreach (var msg in messages)
{
if (msg is ReadyMessage)
{
Handle(msg as ReadyMessage, ev.Message.ReturnAddress);
}
}
};
}
public MainEndpointSettings(TransactionalTransport masterNodeTransport,UnicastBus unicastBus)
{
this.masterNodeTransport = masterNodeTransport;
this.unicastBus = unicastBus;
}
public MainEndpointSettings(TransactionalTransport masterNodeTransport, UnicastBus unicastBus)
{
this.masterNodeTransport = masterNodeTransport;
this.unicastBus = unicastBus;
}
