public async Task Execute(IMessagingRoot root, IChannelCallback channel, Envelope envelope,
IQueuedOutgoingMessages messages,
DateTime utcNow)
{
root.MessageLogger.NoHandlerFor(envelope);
foreach (var handler in _handlers)
{
try
{
await handler.Handle(envelope, root);
}
catch (Exception e)
{
root.MessageLogger.LogException(e);
}
}
if (envelope.AckRequested)
{
await root.Acknowledgements.SendAcknowledgement(envelope);
}
await channel.Complete(envelope);
envelope.MarkCompletion(false);
// These two lines are important to make the message tracking work
// if there is no handler
root.MessageLogger.ExecutionFinished(envelope);
root.MessageLogger.MessageSucceeded(envelope);
}
public void Start(IMessagingRoot root)
{
var settings = root.Options;
_settings = settings;
_logger = root.Logger;
_root = root;
organizeTransports(settings, root.Transports);
assertNoUnknownTransportsInSubscribers(settings);
assertNoUnknownTransportsInListeners(settings);
foreach (var transport in root.Transports)
{
transport.StartListening(root);
}
buildInitialSendingAgents(root);
GetOrBuild(TransportConstants.RetryUri);
}
protected internal ISendingAgent StartSending(IMessagingRoot root, ITransportRuntime runtime,
Uri replyUri)
{
var sender = root.Settings.StubAllOutgoingExternalSenders ? new NulloSender(Uri) : CreateSender(root);
return(runtime.AddSubscriber(replyUri, sender, this));
}
public override void Initialize(IMessagingRoot root)
{
if (AutoProvision)
{
InitializeAllObjects();
}
}
public void StartListening(IMessagingRoot root)
{
var settings = root.Settings;
if (settings.StateFor(Protocol) == TransportState.Disabled)
{
return;
}
WorkerQueue = root.Workers;
var incoming = settings.Listeners.Where(x => x.Scheme == Protocol).ToArray();
incoming = validateAndChooseReplyChannel(incoming);
foreach (var uri in incoming)
{
var agent = buildListeningAgent(uri, settings);
agent.Status = _status;
var listener = uri.IsDurable()
? _durableMessagingFactory.BuildListener(agent, root)
: new LightweightListener(WorkerQueue, logger, agent);
_listeners.Add(listener);
listener.Start();
}
}
public override void Initialize(IMessagingRoot root)
{
if (ConnectionString.IsEmpty() && _endpoints.Any())
{
throw new InvalidOperationException("No connection string for Azure Service Bus has been configured, or is empty");
}
}
public void StartListeners(IMessagingRoot root, ITransportRuntime runtime)
{
foreach (var endpoint in endpoints())
{
endpoint.StartListening(root, runtime);
}
}
void ITransport.StartSenders(IMessagingRoot root, ITransportRuntime runtime)
{
foreach (var queue in _queues)
{
addQueue(root, runtime, queue);
}
}
public void StartListeners(IMessagingRoot root, ITransportRuntime runtime)
{
foreach (var listener in _listeners)
{
Endpoints.FillDefault(listener);
}
}
public void Start(IMessagingRoot root, CapabilityGraph capabilities)
{
var settings = root.Settings;
_lookups = root.Lookup;
_settings = settings;
_logger = root.Logger;
_root = root;
organizeTransports(settings, root.Transports);
assertNoUnknownTransportsInSubscribers(settings);
assertNoUnknownTransportsInListeners(settings);
foreach (var transport in root.Transports)
{
transport.StartListening(root);
}
buildInitialSendingAgents(root);
GetOrBuildChannel(TransportConstants.RetryUri);
SystemReplyUri =
capabilities.DefaultReceiverLocation
?? tryGetReplyUri("http")
?? tryGetReplyUri("tcp")
?? _transports.Values.FirstOrDefault(x => x.LocalReplyUri != null)?.LocalReplyUri;
}
public static async Task <int> put__messages_durable(HttpRequest request, ILocalWorkerSender workers,
IMessageLogger logger, IMessagingRoot root)
{
if (root.ListeningStatus == ListeningStatus.TooBusy)
{
return(503);
}
try
{
// TODO -- optimize the reading here to reduce allocations
var bytes = await request.Body.ReadBytesAsync(request.ContentLength);
var envelopes = Envelope.ReadMany(bytes);
await workers.EnqueueDurably(envelopes);
return(200);
}
catch (Exception e)
{
var message = $"Error receiving envelopes from {request.Headers["x-jasper-envelope-sender"]}";
logger.LogException(e, message: message);
return(500);
}
}
public Task Handle(Envelope envelope, IMessagingRoot root)
{
Recorded.Add(envelope);
root.ShouldNotBeNull();
return(Task.CompletedTask);
}
private ISendingAgent buildAgent(LocalQueueSettings queue, IMessagingRoot root)
{
return(queue.IsDurable
? (ISendingAgent) new DurableLocalSendingAgent(queue, root.Pipeline, root.Settings, root.Persistence,
root.TransportLogger, root.Serialization, root.MessageLogger)
: new LightweightLocalSendingAgent(queue, root.TransportLogger, root.Pipeline, root.Settings,
root.MessageLogger));
}
protected override ISender CreateSender(IMessagingRoot root)
{
if (Parent.ConnectionString == null)
{
throw new InvalidOperationException("There is no configured connection string for Azure Service Bus, or it is empty");
}
return(new AzureServiceBusSender(this, Parent));
}
public override void AddRoute(MessageTypeRouting routing, IMessagingRoot root)
{
if (Agent == null)
{
throw new InvalidOperationException($"The agent has not been initialized for this endpoint");
}
routing.AddStaticRoute(Agent);
}
public void StartSenders(IMessagingRoot root, ITransportRuntime runtime)
{
var replyUri = ReplyEndpoint()?.ReplyUri();
foreach (var endpoint in endpoints().Where(x => x.Subscriptions.Any()))
{
endpoint.StartSending(root, runtime, replyUri);
}
}
public override void AddRoute(MessageTypeRouting routing, IMessagingRoot root)
{
if (Agent == null)
{
throw new InvalidOperationException();
}
routing.AddStaticRoute(Agent);
}
public MessageRouter(IMessagingRoot root, HandlerGraph handlers)
{
_serializers = root.Serialization;
_subscribers = root.Subscribers;
_handlers = handlers;
_logger = root.Logger;
_settings = root.Settings;
_workers = _handlers.Workers;
}
public override object Resolve(Scope scope)
{
if (_root == null)
{
_root = scope.GetInstance <IMessagingRoot>();
}
return(_root.NewContext());
}
public void StartListening(IMessagingRoot root)
{
_sockets = new WebSocketCollection(root.Workers);
foreach (var messageType in _handlers.Chains.Select(x => x.MessageType).Where(x => x.CanBeCastTo <ClientMessage>()))
{
JsonSerialization.RegisterType(messageType.ToMessageTypeName(), messageType);
}
}
public TopicRoute(ITopicRule rule, WriterCollection <IMessageSerializer> writers, ITopicRouter router,
IMessagingRoot root, MessageTypeRouting messageTypeRouting)
{
_rule = rule;
_writers = writers;
_router = router;
_root = root;
_messageTypeRouting = messageTypeRouting;
}
public HandlerPipeline(MessagingSerializationGraph serializers, HandlerGraph graph, IMessageLogger logger,
IEnumerable <IMissingHandler> missingHandlers, IMessagingRoot root)
{
_serializer = serializers;
_graph = graph;
_root = root;
_missingHandlers = missingHandlers.ToArray();
Logger = logger;
}
private ISendingAgent addQueue(IMessagingRoot root, ITransportRuntime runtime, LocalQueueSettings queue)
{
queue.Agent = buildAgent(queue, root);
_agents = _agents.AddOrUpdate(queue.Name, buildAgent(queue, root));
runtime.AddSendingAgent(buildAgent(queue, root));
runtime.AddSubscriber(queue);
return(queue.Agent);
}
protected internal override void StartListening(IMessagingRoot root, ITransportRuntime runtime)
{
if (!IsListener)
{
return;
}
var listener = new RabbitMqListener(root.TransportLogger, this, Parent);
runtime.AddListener(listener, this);
}
protected internal override void StartListening(IMessagingRoot root, ITransportRuntime runtime)
{
if (!IsListener)
{
return;
}
var listener = createListener(root);
runtime.AddListener(listener, this);
}
public void StartSenders(IMessagingRoot root, ITransportRuntime runtime)
{
var pipeline = root.Pipeline;
foreach (var endpoint in Endpoints)
{
endpoint.Start(pipeline, root.MessageLogger);
runtime.AddSubscriber(endpoint);
}
}
protected internal override void StartListening(IMessagingRoot root, ITransportRuntime runtime)
{
if (!IsListener)
{
return;
}
var listener = new ConfluentKafkaListener(this, root.TransportLogger, root.Cancellation);
runtime.AddListener(listener, this);
}
public HandlerPipeline(MessagingSerializationGraph serializers, HandlerGraph graph, IMessageLogger logger,
NoHandlerContinuation noHandlers, IMessagingRoot root)
{
_serializer = serializers;
_graph = graph;
_noHandlers = noHandlers;
_root = root;
_cancellation = root.Cancellation;
Logger = logger;
}
public MessageTypeRouting(Type messageType, IMessagingRoot root)
{
Writers = root.Serialization.WriterFor(messageType);
MessageType = messageType;
MessageTypeName = messageType.ToMessageTypeName();
_customizations = _customizations.AddRange(findMessageTypeCustomizations(messageType));
LocalQueue = determineLocalSendingAgent(messageType, root);
_root = root;
}
public void StartListening(IMessagingRoot root)
{
if (_runtime.HttpAddresses.Any())
{
var candidate = _runtime.HttpAddresses.Select(x => x.ToUri()).FirstOrDefault(x => x.Host == "localhost" || x.Host == "127.0.0.1")?.ToMachineUri();
if (candidate != null)
{
LocalReplyUri = candidate.ToString().TrimEnd('/').AppendUrl(_httpSettings.RelativeUrl).ToUri();
}
}
}
