public async Task Publish <T>(string bucket, string streamId, IEnumerable <IWritableEvent> events, IDictionary <string, string> commitHeaders) where T : class, IEventSource
{
var options = new PublishOptions();
foreach (var header in commitHeaders)
{
if (header.Key == Headers.OriginatingHostId)
{
//is added by bus in v5
continue;
}
options.SetHeader(header.Key, header.Value);
}
await events.WhenAllAsync(async @event =>
{
options.SetHeader("EventId", @event.EventId.ToString());
options.SetHeader("EntityType", @event.Descriptor.EntityType);
options.SetHeader("Timestamp", @event.Descriptor.Timestamp.ToString(CultureInfo.InvariantCulture));
options.SetHeader("Version", @event.Descriptor.Version.ToString());
options.SetHeader("Bucket", bucket);
options.SetHeader("StreamId", streamId);
foreach (var header in @event.Descriptor.Headers)
{
options.SetHeader(header.Key, header.Value);
}
await _endpoint.Publish(@event.Event, options).ConfigureAwait(false);
}).ConfigureAwait(false);
}
static async Task Loop(IEndpointInstance endpoint)
{
(int x, int y) = Test();
int i = 0;
while (true)
{
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("Pingu"), null);
var publishOptions = new PublishOptions();
var sendOptions = new SendOptions();
publishOptions.SetHeader("Test", "Test");
await Task.Delay(1000);
await endpoint.Send(new Shared.TheCommand {
StringProperty = "Hello", IntProperty = i++
}, sendOptions);
await Task.Delay(1000);
await endpoint.Publish(new Shared.TheMessage {
StringProperty = "Hello", IntProperty = i++
}, publishOptions);
}
}
static async Task Main()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Sender");
endpointConfiguration.SendFailedMessagesTo("error");
var connection = @"Data Source=.\SqlExpress;Database=NsbSamplesMultiTenantSender;Integrated Security=True";
var persistence = endpointConfiguration.UsePersistence <NHibernatePersistence>();
persistence.ConnectionString(connection);
endpointConfiguration.UseTransport <MsmqTransport>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.EnableOutbox();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
Console.WriteLine("Press Escape to exit");
var acceptableInput = new List <char> {
'A', 'B'
};
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.Escape)
{
break;
}
var uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
var options = new PublishOptions();
options.SetHeader("TenantId", uppercaseKey.ToString());
await endpointInstance.Publish(message, options)
.ConfigureAwait(false);
}
else
{
Console.WriteLine($"[{uppercaseKey}] is not a valid tenant identifier.");
}
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public static async Task PublishWithSequenceHeader <TMessage>(this IEndpointInstance endpoint, long seq)
{
var pubOptions = new PublishOptions();
pubOptions.SetHeader("NSB.OrderedProcessing.Sequence", seq.ToString());
await endpoint.Publish <TMessage>(evt => { }, pubOptions);
}
public async Task Publish <T>(string streamName, IEnumerable <IFullEvent> events, IDictionary <string, string> commitHeaders) where T : class, IEventSource
{
await events.WhenAllAsync(@event =>
{
var options = new PublishOptions();
foreach (var header in commitHeaders)
{
if (header.Key == Headers.OriginatingHostId)
{
//is added by bus in v5
continue;
}
options.SetHeader(header.Key, header.Value);
}
options.SetHeader($"{Defaults.PrefixHeader}.EventId", @event.EventId.ToString());
options.SetHeader($"{Defaults.PrefixHeader}.EntityType", @event.Descriptor.EntityType);
options.SetHeader($"{Defaults.PrefixHeader}.Timestamp", @event.Descriptor.Timestamp.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture));
options.SetHeader($"{Defaults.PrefixHeader}.Version", @event.Descriptor.Version.ToString());
options.SetHeader($"{Defaults.PrefixHeader}.EventStream", streamName);
foreach (var header in @event.Descriptor.Headers)
{
options.SetHeader(header.Key, header.Value);
}
return(Bus.Instance.Publish(@event.Event, options));
}).ConfigureAwait(false);
}
public async Task Handle(PlaceOrder message, IMessageHandlerContext context)
{
log.Info($"Received PlaceOrder, OrderId = {message.OrderId}");
var orderPlaced = new OrderPlaced
{
OrderId = message.OrderId,
ClientId = message.ClientId
};
var publishOptions = new PublishOptions();
publishOptions.SetHeader("insider", GetInsiderProgramValue(message));
publishOptions.SetHeader("membership", GetMembership(message));
// -- Echange : amq.topic, Queue : Syeremy-Messages-Events-OrderPlaced -- binding needed.
await context.Publish(orderPlaced, publishOptions);
}
static async Task AsyncMain()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Sender");
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.UsePersistence <NHibernatePersistence>();
endpointConfiguration.EnableOutbox();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
var acceptableInput = new List <char> {
'A', 'B'
};
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
var options = new PublishOptions();
options.SetHeader("TenantId", uppercaseKey.ToString());
await endpointInstance.Publish(message, options)
.ConfigureAwait(false);
}
else
{
Console.WriteLine($"[{uppercaseKey}] is not a valid tenant identifier.");
}
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
public Task Handle(PlaceOrder message, IMessageHandlerContext context)
{
logger.Info($"Received PlaceOrder, OrderId = {message.OrderId}");
// This is normally where some business logic would occur
var orderPlaced = new OrderPlaced
{
OrderId = message.OrderId,
ClientId = message.ClientId
};
var publishOptions = new PublishOptions();
publishOptions.SetHeader("insider", GetInsiderProgramValue(message));
publishOptions.SetHeader("membership", GetMembership(message));
return(context.Publish(orderPlaced, publishOptions));
}
static async Task AsyncMain()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Sender");
endpointConfiguration.UseSerialization<JsonSerializer>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.UsePersistence<NHibernatePersistence>();
endpointConfiguration.EnableOutbox();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
var acceptableInput = new List<char> { 'A', 'B' };
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
var options = new PublishOptions();
options.SetHeader("TenantId", uppercaseKey.ToString());
await endpointInstance.Publish(message, options)
.ConfigureAwait(false);
}
else
{
Console.WriteLine($"[{uppercaseKey}] is not a valid tenant identifier.");
}
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
public Task Handle(ShipOrder message, IMessageHandlerContext context)
{
Log.Info($"Order Shipped. OrderId {message.OrderId}");
var orderShippingInformation = StoreOrderShippingInformation(message, context);
var options = new PublishOptions();
options.SetHeader("Sample.CosmosDB.Transaction.OrderId", message.OrderId.ToString());
return(context.Publish(new OrderShipped {
OrderId = orderShippingInformation.OrderId, ShippingDate = orderShippingInformation.ShippedAt
}, options));
}
public async Task Should_be_delivered_to_all_subscribers()
{
await Scenario.Define <Context>()
.WithEndpoint <Publisher>(b =>
b.When(c => c.Subscriber1Subscribed && c.Subscriber2Subscribed, (session, c) =>
{
c.AddTrace("Both subscribers is subscribed, going to publish MyEvent");
var options = new PublishOptions();
options.SetHeader("MyHeader", "SomeValue");
return(session.Publish(new MyEvent(), options));
})
)
.WithEndpoint <Subscriber1>(b => b.When(async(session, context) =>
{
await session.Subscribe <MyEvent>();
if (context.HasNativePubSubSupport)
{
context.Subscriber1Subscribed = true;
context.AddTrace("Subscriber1 is now subscribed (at least we have asked the broker to be subscribed)");
}
else
{
context.AddTrace("Subscriber1 has now asked to be subscribed to MyEvent");
}
}))
.WithEndpoint <Subscriber2>(b => b.When(async(session, context) =>
{
await session.Subscribe <MyEvent>();
if (context.HasNativePubSubSupport)
{
context.Subscriber2Subscribed = true;
context.AddTrace("Subscriber2 is now subscribed (at least we have asked the broker to be subscribed)");
}
else
{
context.AddTrace("Subscriber2 has now asked to be subscribed to MyEvent");
}
}))
.Done(c => c.Subscriber1GotTheEvent && c.Subscriber2GotTheEvent)
.Repeat(r => r.For(Transports.Default))
.Should(c =>
{
Assert.True(c.Subscriber1GotTheEvent);
Assert.True(c.Subscriber2GotTheEvent);
})
.Run(TimeSpan.FromSeconds(10));
}
public void ShouldShallowCloneHeaders()
{
var message = new OutgoingLogicalMessage(typeof(object), new object());
var options = new PublishOptions();
options.SetHeader("someHeader", "someValue");
var testee = new OutgoingPublishContext(message, options, new RootContext(null, null, null));
testee.Headers["someHeader"] = "updatedValue";
testee.Headers["anotherHeader"] = "anotherValue";
Assert.AreEqual("someValue", options.OutgoingHeaders["someHeader"]);
Assert.IsFalse(options.OutgoingHeaders.ContainsKey("anotherHeader"));
Assert.AreEqual("updatedValue", testee.Headers["someHeader"]);
Assert.AreEqual("anotherValue", testee.Headers["anotherHeader"]);
}
public void Handle(MyMessage message)
{
SendOptions sendOptions = new SendOptions();
sendOptions.SetHeader("MyCustomHeader", "My custom value");
bus.Send(new SomeOtherMessage(), sendOptions);
ReplyOptions replyOptions = new ReplyOptions();
replyOptions.SetHeader("MyCustomHeader", "My custom value");
bus.Reply(new SomeOtherMessage(), replyOptions);
PublishOptions publishOptions = new PublishOptions();
publishOptions.SetHeader("MyCustomHeader", "My custom value");
bus.Publish(new SomeOtherMessage(), publishOptions);
}
public void When_publishing_should_clone_headers()
{
var publishPipeline = new FakePipeline <IOutgoingPublishContext>();
var messageOperations = CreateMessageOperations(publishPipeline: publishPipeline);
var publishOptions = new PublishOptions();
publishOptions.SetHeader("header1", "header1 value");
messageOperations.Publish <MyMessage>(new FakeRootContext(), m => { }, publishOptions);
publishPipeline.ReceivedContext.Headers.Add("header2", "header2 value");
publishPipeline.ReceivedContext.Headers["header1"] = "updated header1 value";
var optionsHeaders = publishOptions.GetHeaders();
Assert.AreEqual(1, optionsHeaders.Count);
Assert.AreEqual("header1 value", optionsHeaders["header1"]);
}
public async Task Handle(MyMessage message, IMessageHandlerContext context)
{
SendOptions sendOptions = new SendOptions();
sendOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Send(new SomeOtherMessage(), sendOptions);
ReplyOptions replyOptions = new ReplyOptions();
replyOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Reply(new SomeOtherMessage(), replyOptions);
PublishOptions publishOptions = new PublishOptions();
publishOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Publish(new SomeOtherMessage(), publishOptions);
}
public void ShouldShallowCloneHeaders()
{
var message = new OutgoingLogicalMessage(typeof(object), new object());
var options = new PublishOptions();
options.SetHeader("someHeader", "someValue");
var testee = new OutgoingPublishContext(message, options, new RootContext(null, null, null));
testee.Headers["someHeader"] = "updatedValue";
testee.Headers["anotherHeader"] = "anotherValue";
Assert.AreEqual("someValue", options.OutgoingHeaders["someHeader"]);
Assert.IsFalse(options.OutgoingHeaders.ContainsKey("anotherHeader"));
Assert.AreEqual("updatedValue", testee.Headers["someHeader"]);
Assert.AreEqual("anotherValue", testee.Headers["anotherHeader"]);
}
public async Task Handle(MyMessage message, IMessageHandlerContext context)
{
var sendOptions = new SendOptions();
sendOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Send(new SomeOtherMessage(), sendOptions)
.ConfigureAwait(false);
var replyOptions = new ReplyOptions();
replyOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Reply(new SomeOtherMessage(), replyOptions)
.ConfigureAwait(false);
var publishOptions = new PublishOptions();
publishOptions.SetHeader("MyCustomHeader", "My custom value");
await context.Publish(new SomeOtherMessage(), publishOptions)
.ConfigureAwait(false);
}
public Task Handle(ShipOrder message, IMessageHandlerContext context)
{
var orderShippingInformation = new OrderShippingInformation
{
Id = Guid.NewGuid(),
OrderId = message.OrderId,
ShippedAt = DateTimeOffset.UtcNow,
};
Store(orderShippingInformation, context);
Log.Info($"Order Shipped. OrderId {message.OrderId}");
var options = new PublishOptions();
options.SetHeader("Sample.CosmosDB.Transaction.OrderId", message.OrderId.ToString());
return(context.Publish(new OrderShipped {
OrderId = orderShippingInformation.OrderId, ShippingDate = orderShippingInformation.ShippedAt
}, options));
}
public Task Publish(IFullMessage message, IDictionary <string, string> headers = null)
{
Logger.Write(LogLevel.Debug, () => $"Publishing message of type [{message.Message.GetType().FullName}]");
var options = new PublishOptions();
if (headers != null)
{
foreach (var header in message.Headers.Merge(headers))
{
if (header.Key == Headers.OriginatingHostId)
{
//is added by bus in v5
continue;
}
options.SetHeader(header.Key, header.Value);
}
}
_metrics.Mark("Dispatched Messages", Unit.Message);
return(Bus.Instance.Publish(message.Message, options));
}
/// <summary>
/// Uses the non-persistent delivery mode to publish the message.
/// </summary>
public static void UseNonPersistentDeliveryMode(this PublishOptions options)
{
Guard.AgainstNull(nameof(options), options);
options.SetHeader(BasicPropertiesExtensions.UseNonPersistentDeliveryHeader, bool.TrueString);
}
