public async Task PublishAsync(EventPublishData data, PublishPreferences preferences)
{
var eventDesc = new EventDescriptor {
Service = data.Service, Event = data.Event
};
var subscribers = _eventSubscriber.GetSubscribers(eventDesc).ToList();
if (subscribers.Count == 0)
{
return;
}
foreach (var subscriber in subscribers)
{
var invokeData = new MethodInvocationData
{
IntentId = _idGenerator.NewId(),
Service = subscriber.Service,
Method = subscriber.Method,
Parameters = data.Parameters,
FlowContext = data.FlowContext,
Caller = new CallerDescriptor(data.Service, data.Event, data.IntentId)
};
InvokeInBackground(invokeData, preferences);
}
}
public static void Write(Message message, EventPublishData data, PublishPreferences preferences, ISerializer serializer)
{
message.Data["IntentId"] = data.IntentId;
message.Data["Service"] = data.Service.Clone();
message.Data["Event"] = data.Event.Clone();
message.Data["Format"] = serializer.Format;
message.Data["Parameters"] = serializer.SerializeToString(data.Parameters);
message.Data["Caller"] = data.Caller?.Clone();
message.Data["SkipLocal"] = preferences.SkipLocalSubscribers;
}
public Task PublishAsync(EventPublishData data, PublishPreferences preferences)
{
var message = new Message
{
Type = MessageType.Event,
};
EventPublishDataTransformer.Write(message, data, preferences, _serializer);
_messageHub.Schedule(message);
return(Task.CompletedTask);
}
private async void InvokeInBackground(MethodInvocationData data, PublishPreferences preferences)
{
if (!_serviceResolver.TryResolve(data.Service, out var service) ||
service.Definition.Type == Modeling.ServiceType.External)
{
var communicator = _communicatorProvider.GetCommunicator(data.Service, data.Method, assumeExternal: true);
await communicator.InvokeAsync(data, default);
}
else if (!preferences.SkipLocalSubscribers)
{
var message = new HttpCommunicatorMessage {
IsRetry = false
};
await _localMethodRunner.RunAsync(data, message);
}
}
public async Task PublishAsync(EventPublishData data, PublishPreferences preferences)
{
var exchangeName = _settings.ExchangeName
.Replace("{serviceName}", data.Service.Name)
.Replace("{eventName}", data.Event.Name);
// TODO: declare once? what's the penalty?
_channel.ExchangeDeclare(
exchangeName,
type: "fanout",
durable: true,
autoDelete: false,
arguments: null);
var properties = CreateMessageProperties(_channel);
properties.Type = MessageTypes.Event;
SetIntentId(properties, data.IntentId);
SetFormat(properties, _serializer);
properties.Headers.Add("X-Service-Name", data.Service.Name);
properties.Headers.Add("X-Event-Name", data.Event.Name);
if (preferences.SkipLocalSubscribers)
{
properties.Headers.Add("X-Skip-Local", true);
}
var payload = SerializePayload(data);
_channel.BasicPublish(
exchange: exchangeName,
routingKey: "",
basicProperties: properties,
body: payload);
_channel.WaitForConfirms(); // no async version :(
}
public async Task PublishAsync(EventPublishData data, PublishPreferences preferences)
{
await LocalPublisher.PublishAsync(data, default);
await ExternalPublisher.PublishAsync(data, new PublishPreferences { SkipLocalSubscribers = true });
}
