public DurableWorkerQueue(Endpoint endpoint, IHandlerPipeline pipeline,
AdvancedSettings settings, IEnvelopePersistence persistence, ITransportLogger logger)
{
_settings = settings;
_persistence = persistence;
_logger = logger;
endpoint.ExecutionOptions.CancellationToken = settings.Cancellation;
_receiver = new ActionBlock <Envelope>(async envelope =>
{
try
{
envelope.ContentType = envelope.ContentType ?? "application/json";
await pipeline.Invoke(envelope, this);
}
catch (Exception e)
{
// This *should* never happen, but of course it will
logger.LogException(e);
}
}, endpoint.ExecutionOptions);
_policy = Policy
.Handle <Exception>()
.WaitAndRetryForeverAsync(i => (i * 100).Milliseconds()
, (e, timeSpan) => {
_logger.LogException(e);
});
}
public LightweightWorkerQueue(Endpoint endpoint, ITransportLogger logger,
IHandlerPipeline pipeline, AdvancedSettings settings)
{
_logger = logger;
_settings = settings;
Pipeline = pipeline;
_scheduler = new InMemoryScheduledJobProcessor(this);
endpoint.ExecutionOptions.CancellationToken = settings.Cancellation;
_receiver = new ActionBlock <Envelope>(async envelope =>
{
try
{
if (envelope.ContentType.IsEmpty())
{
envelope.ContentType = "application/json";
}
await Pipeline.Invoke(envelope);
}
catch (Exception e)
{
// This *should* never happen, but of course it will
logger.LogException(e);
}
}, endpoint.ExecutionOptions);
}
public void StartTransports(IHandlerPipeline pipeline, BusSettings settings, ITransport[] transports)
{
Name = settings.ServiceName;
ValidTransports = transports.Select(x => x.Protocol).ToArray();
foreach (var transport in transports)
{
var channels = transport.Start(pipeline, settings, this);
foreach (var channel in channels)
{
_channels[channel.Uri] = channel;
}
}
if (settings.DefaultChannelAddress != null)
{
DefaultChannel = this[settings.DefaultChannelAddress];
}
assertNoUnknownTransportsInSubscribers(settings);
assertNoUnknownTransportsInListeners(settings);
}
// TODO -- just pull in MessagingRoot?
public MessageContext(IMessageRouter router, IReplyWatcher watcher, IHandlerPipeline pipeline, MessagingSerializationGraph serialization, MessagingSettings settings, IChannelGraph channels, IDurableMessagingFactory factory, IMessageLogger logger, Envelope originalEnvelope)
{
_router = router;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
_settings = settings;
_channels = channels;
Factory = factory;
_logger = logger;
Envelope = originalEnvelope;
_sagaId = originalEnvelope.SagaId;
var persistor = new InMemoryEnvelopeTransaction();
EnlistedInTransaction = true;
Transaction = persistor;
if (Envelope.AckRequested)
{
var ack = buildAcknowledgement();
persistor.Queued.Fill(ack);
_outstanding.Add(ack);
}
}
public MartenBackedListenerContext()
{
theStore = DocumentStore.For(_ =>
{
_.Connection(Servers.PostgresConnectionString);
_.PLV8Enabled = false;
});
theSettings = new AdvancedSettings(null);
EnvelopeStorageAdmin.RebuildSchemaObjects();
var persistence =
new PostgresqlEnvelopePersistence(
new PostgresqlSettings {
ConnectionString = Servers.PostgresConnectionString
}, theSettings);
thePipeline = Substitute.For <IHandlerPipeline>();
theWorkerQueue = new DurableWorkerQueue(new LocalQueueSettings("temp"), thePipeline, theSettings,
persistence, TransportLogger.Empty());
var agent = Substitute.For <IListener>();
theWorkerQueue.StartListening(agent);
}
public ServiceBus(IEnvelopeSender sender, IReplyWatcher watcher, IHandlerPipeline pipeline, SerializationGraph serialization)
{
_sender = sender;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
}
public Receiver(IHandlerPipeline pipeline, ChannelGraph graph, ChannelNode node)
{
_pipeline = pipeline;
_graph = graph;
_node = node;
_address = node.Channel.Address;
}
public Receiver(IHandlerPipeline pipeline, ChannelGraph graph, ChannelNode node)
{
_pipeline = pipeline;
_graph = graph;
_node = node;
_address = node.Uri;
}
public QueueCollection(IBusLogger logger, IQueueProvider provider, IHandlerPipeline pipeline, CancellationToken cancellationToken)
{
_logger = logger;
_pipeline = pipeline;
_cancellationToken = cancellationToken;
_provider = provider;
}
public TransportActivator(ChannelGraph graph, IServiceLocator services, IHandlerPipeline pipeline, IEnumerable<ITransport> transports)
{
_graph = graph;
_services = services;
_pipeline = pipeline;
_transports = transports;
}
public LightweightLocalSendingAgent(Endpoint endpoint, ITransportLogger logger,
IHandlerPipeline pipeline, AdvancedSettings settings, IMessageLogger messageLogger) : base(endpoint, logger, pipeline, settings)
{
_messageLogger = messageLogger;
Destination = Address = endpoint.Uri;
Endpoint = endpoint;
}
private async Task ConsumeAsync(IHandlerPipeline pipeline)
{
await foreach (Message message in _consumer.Messages(_cancellation))
{
Envelope envelope;
try
{
envelope = _protocol.ReadEnvelope(new DotPulsarMessage(message.Data, message.Properties));
}
catch (Exception ex)
{
_logger.LogException(ex, message: $"Error trying to map an incoming Pulsar {_endpoint.Topic} Topic message to an Envelope. See the Dead Letter Queue");
continue;
}
try
{
IChannelCallback channelCallback = new DotPulsarChannelCallback(message.MessageId, _consumer);
await pipeline.Invoke(envelope, channelCallback);
}
catch (Exception e)
{
// DotPulsar currently doesn't support Nack so will likely just keep retrying message for now.
_logger.LogException(e, envelope.Id, "Error trying to receive a message from " + Address);
}
}
}
public void StartHandlingInline(IHandlerPipeline pipeline)
{
_consumer.Subscribe(new[] { _endpoint.TopicName });
_consumerTask = ConsumeAsync(pipeline);
_logger.ListeningStatusChange(ListeningStatus.Accepting);
}
public TransportActivator(ChannelGraph graph, IServiceLocator services, IHandlerPipeline pipeline, IEnumerable <ITransport> transports, IEnumerable <IFubuTransportActivator> fubuTransportActivators)
{
_graph = graph;
_services = services;
_pipeline = pipeline;
_transports = transports;
_fubuTransportActivators = fubuTransportActivators;
}
public EnvelopeContext(ILogger logger, ISystemTime systemTime, IChainInvoker invoker, IOutgoingSender outgoing, IHandlerPipeline pipeline)
{
this.logger = logger;
_systemTime = systemTime;
_invoker = invoker;
Outgoing = outgoing;
_pipeline = pipeline;
}
public TestEnvelopeContext(IHandlerPipeline handlerPipeline)
: base(new RecordingLogger(), new SettableClock(), MockRepository.GenerateMock<IChainInvoker>(),
new RecordingEnvelopeSender(), handlerPipeline)
{
SystemTime.As<SettableClock>().LocalNow(DateTime.Today.AddHours(5));
HandlerPipeline = handlerPipeline;
}
public ProductionDiagnosticEnvelopeContext(ILogger logger, ISystemTime systemTime, IChainInvoker invoker, IOutgoingSender outgoing, IHandlerPipeline pipeline, Envelope envelope, IExecutionLogger executionLogger)
: base(logger, systemTime, invoker, outgoing, pipeline)
{
_envelope = envelope;
_executionLogger = executionLogger;
_log = new ChainExecutionLog();
_envelope.Log = _log;
}
public TestEnvelopeContext(IHandlerPipeline handlerPipeline)
: base(
new RecordingLogger(), new SettableClock(), MockRepository.GenerateMock <IChainInvoker>(),
new RecordingEnvelopeSender(), handlerPipeline)
{
SystemTime.As <SettableClock>().LocalNow(DateTime.Today.AddHours(5));
HandlerPipeline = handlerPipeline;
}
public TransportActivator(ChannelGraph graph, IServiceLocator services, IHandlerPipeline pipeline, ILogger logger, IEnumerable<ITransport> transports, IEnumerable<IFubuTransportActivator> fubuTransportActivators)
{
_graph = graph;
_services = services;
_pipeline = pipeline;
_logger = logger;
_transports = transports;
_fubuTransportActivators = fubuTransportActivators;
}
public StubTransport(IHandlerPipeline pipeline)
{
_pipeline = pipeline;
LocalReplyUri = new Uri($"stub://replies");
Channels =
new LightweightCache <Uri, StubChannel>(uri => new StubChannel(uri, pipeline, this));
}
public ServiceBus(IEnvelopeSender sender, IReplyWatcher watcher, IHandlerPipeline pipeline, BusMessageSerializationGraph serialization, BusSettings settings, IChannelGraph channels, IPersistence persistence)
{
_sender = sender;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
_settings = settings;
_channels = channels;
_persistence = persistence;
}
public ServiceBusActivator(BusSettings settings, IHandlerPipeline pipeline, IDelayedJobProcessor delayedJobs, SerializationGraph serialization, IEnumerable <ITransport> transports, UriAliasLookup lookups, INodeDiscovery nodes)
{
_settings = settings;
_pipeline = pipeline;
_delayedJobs = delayedJobs;
_serialization = serialization;
_transports = transports.ToArray();
_lookups = lookups;
_nodes = nodes;
}
public void StartReceiving(IHandlerPipeline pipeline, ILogger logger, ChannelGraph graph)
{
if (Channel == null)
{
throw new InvalidOperationException("Cannot receive on node {0} without a matching channel".ToFormat(SettingAddress));
}
var receiver = new Receiver(pipeline, graph, this);
StartReceiving(receiver, logger);
}
public ServiceBus(IMessageRouter router, IReplyWatcher watcher, IHandlerPipeline pipeline, BusMessageSerializationGraph serialization, BusSettings settings, IChannelGraph channels, IPersistence persistence, CompositeMessageLogger logger)
{
_router = router;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
_settings = settings;
_channels = channels;
Persistence = persistence;
_logger = logger;
}
// TODO -- just pull in MessagingRoot?
public MessageContext(IMessageRouter router, IReplyWatcher watcher, IHandlerPipeline pipeline, MessagingSerializationGraph serialization, MessagingSettings settings, IChannelGraph channels, IDurableMessagingFactory factory, IMessageLogger logger)
{
_router = router;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
_settings = settings;
_channels = channels;
Factory = factory;
_logger = logger;
}
public ServiceBusActivator(BusSettings settings, IHandlerPipeline pipeline, IDelayedJobProcessor delayedJobs, BusMessageSerializationGraph serialization, IEnumerable <ITransport> transports, UriAliasLookup lookups, IWorkerQueue workerQueue, CompositeLogger logger, IPersistence persistence)
{
_settings = settings;
_pipeline = pipeline;
_delayedJobs = delayedJobs;
_serialization = serialization;
_transports = transports.ToArray();
_lookups = lookups;
_workerQueue = workerQueue;
_logger = logger;
_persistence = persistence;
}
public IChannel[] Start(IHandlerPipeline pipeline, BusSettings settings, OutgoingChannels channels)
{
_pipeline = pipeline;
foreach (var messageType in _handlers.Chains.Select(x => x.MessageType).Where(x => x.CanBeCastTo <ClientMessage>()))
{
JsonSerialization.RegisterType(messageType.ToMessageAlias(), messageType);
}
_retries = channels.DefaultRetryChannel;
return(new IChannel[] { new OutgoingWebSocketChannel(this) });
}
public WorkerQueue(CompositeMessageLogger logger, IHandlerPipeline pipeline, BusSettings settings, CancellationToken cancellationToken)
{
_logger = logger;
_pipeline = pipeline;
_settings = settings;
_cancellationToken = cancellationToken;
foreach (var worker in _settings.Workers.AllWorkers)
{
AddQueue(worker.Name, worker.Parallelization);
}
ScheduledJobs = InMemoryScheduledJobProcessor.ForQueue(this);
}
public DurableLocalSendingAgent(Endpoint endpoint, IHandlerPipeline pipeline,
AdvancedSettings settings, IEnvelopePersistence persistence, ITransportLogger logger,
MessagingSerializationGraph serializers, IMessageLogger messageLogger) : base(endpoint, pipeline, settings, persistence, logger)
{
_settings = settings;
_persistence = persistence;
_logger = logger;
_serializers = serializers;
_messageLogger = messageLogger;
Destination = endpoint.Uri;
Endpoint = endpoint;
ReplyUri = TransportConstants.RepliesUri;
}
public WorkerQueue(IMessageLogger logger, IHandlerPipeline pipeline, MessagingSettings settings)
{
_logger = logger;
Pipeline = pipeline;
_settings = settings;
_cancellationToken = _settings.Cancellation;
foreach (var worker in Pipeline.Workers.AllWorkers)
{
AddQueue(worker.Name, worker.Parallelization);
}
ScheduledJobs = new InMemoryScheduledJobProcessor(this);
}
private async Task ConsumeAsync(IHandlerPipeline pipeline)
{
while (!_cancellation.IsCancellationRequested)
{
ConsumeResult <byte[], byte[]> message;
try
{
message = await Task.Run(() => _consumer.Consume(), _cancellation);
}
catch (Confluent.Kafka.ConsumeException cex)
{
if (cex.Error.Code == ErrorCode.PolicyViolation)
{
throw;
}
continue;
}
catch (Exception ex)
{
_logger.LogException(ex, message: $"Error consuming message from Kafka topic {_endpoint.TopicName}");
continue;
}
Envelope envelope;
try
{
envelope = _protocol.ReadEnvelope(message.Message);
}
catch (Exception ex)
{
_logger.LogException(ex, message: $"Error trying to map an incoming Kafka {_endpoint.TopicName} Topic message to an Envelope. See the Dead Letter Queue");
continue;
}
try
{
await pipeline.Invoke(envelope, new KafkaChannelCallback(message, _consumer));
}
catch (Exception e)
{
// TODO -- Got to either discard this or defer it back to the queue
_logger.LogException(e, envelope.Id, "Error trying to receive a message from " + Address);
}
}
}
public QueueReceiver(IHandlerPipeline pipeline, string queueName, int maximumParallelization, IQueueProvider provider, CancellationToken cancellationToken)
{
_pipeline = pipeline;
_provider = provider;
_cancellationToken = cancellationToken;
QueueName = queueName;
var options = new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = maximumParallelization,
CancellationToken = cancellationToken
};
_block = new ActionBlock <Envelope>(receive, options);
}
public void Start(IHandlerPipeline pipeline, ChannelGraph channels)
{
foreach (var node in channels.IncomingChannelsFor(Protocol))
{
var receiver = new Receiver(pipeline, channels, node);
ReceiveAt(node, receiver);
}
var replyNode = new ChannelNode(ReplyChannel.Address);
var replyReceiver = new Receiver(pipeline, channels, replyNode);
ReceiveAt(replyNode, replyReceiver);
channels.Where(x => x.Uri.Scheme == Protocol).Each(x => {
x.ReplyUri = ReplyChannel.Address;
x.Destination = x.Uri;
});
}
public IChannel[] Start(IHandlerPipeline pipeline, BusSettings settings, OutgoingChannels channels)
{
_pipeline = pipeline;
foreach (var address in settings.KnownSubscribers.Where(x => x.Uri.Scheme == Protocol))
{
Channels[address.Uri] = new StubChannel(address.Uri, _replyUri, pipeline, address);
}
foreach (var node in settings.Listeners.Where(x => x.Uri.Scheme == Protocol))
{
Channels.FillDefault(node.Uri);
}
return(Channels.GetAll().OfType <IChannel>().ToArray());
}
public SqlServerBackedListenerContext()
{
new SqlServerEnvelopeStorageAdmin(new SqlServerSettings{ConnectionString = Servers.SqlServerConnectionString}).RecreateAll();
theSettings = new AdvancedSettings(null);
mssqlSettings = new SqlServerSettings
{
ConnectionString = Servers.SqlServerConnectionString
};
ThePersistence = new SqlServerEnvelopePersistence(mssqlSettings, theSettings);
thePipeline = Substitute.For<IHandlerPipeline>();
theWorkerQueue = new DurableWorkerQueue(new LocalQueueSettings("temp"), thePipeline, theSettings, ThePersistence, TransportLogger.Empty());
}
public void StartReceiving(IHandlerPipeline pipeline, ILogger logger, ChannelGraph graph)
{
if (Channel == null) throw new InvalidOperationException("Cannot receive on node {0} without a matching channel".ToFormat(SettingAddress));
var receiver = new Receiver(pipeline, graph, this);
StartReceiving(receiver, logger);
}
