async Task AsyncOnStart()
{
BusConfiguration busConfiguration = new BusConfiguration();
//other bus configuration. endpoint name, logging, transport, persistence etc
busConfiguration.EnableInstallers();
endpointInstance = await Endpoint.Start(busConfiguration);
}
static async Task Run(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press 'F' to send a message with a file stream");
Console.WriteLine("Press 'H' to send a message with a http stream");
Console.WriteLine("Press any key to exit");
while (true)
{
var key = Console.ReadKey();
if (key.Key == ConsoleKey.F)
{
await SendMessageWithFileStream(endpointInstance)
.ConfigureAwait(false);
continue;
}
if (key.Key == ConsoleKey.H)
{
await SendMessageWithHttpStream(endpointInstance)
.ConfigureAwait(false);
continue;
}
break;
}
}
async Task AsyncOnStart()
{
var endpointConfiguration = new EndpointConfiguration("EndpointName");
endpointConfiguration.EnableInstallers();
endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
}
protected void Application_Start()
{
#region ApplicationStart
ContainerBuilder builder = new ContainerBuilder();
// Register MVC controllers.
builder.RegisterControllers(typeof(MvcApplication).Assembly);
// Set the dependency resolver to be Autofac.
IContainer container = builder.Build();
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("Samples.MvcInjection.WebApplication");
// instruct NServiceBus to use a custom AutoFac configuration
endpointConfiguration.UseContainer<AutofacBuilder>(c => c.ExistingLifetimeScope(container));
endpointConfiguration.UseSerialization<JsonSerializer>();
endpointConfiguration.UsePersistence<InMemoryPersistence>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.SendFailedMessagesTo("error");
endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
ContainerBuilder updater = new ContainerBuilder();
updater.RegisterInstance(endpoint);
updater.Update(container);
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
#endregion
}
static async Task Run(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press 'J' to send a JSON message");
Console.WriteLine("Press 'X' to send a XML message");
Console.WriteLine("Press any key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.X)
{
await SendXmlMessage(endpointInstance)
.ConfigureAwait(false);
continue;
}
if (key.Key == ConsoleKey.J)
{
await SendJsonMessage(endpointInstance)
.ConfigureAwait(false);
continue;
}
break;
}
}
protected void Application_Start()
{
#region ApplicationStart
ContainerBuilder builder = new ContainerBuilder();
// Register your MVC controllers.
builder.RegisterControllers(typeof(MvcApplication).Assembly);
// Set the dependency resolver to be Autofac.
IContainer container = builder.Build();
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MvcInjection.WebApplication");
// ExistingLifetimeScope() ensures that IBus is added to the container as well,
// allowing you to resolve IBus from your own components.
busConfiguration.UseContainer<AutofacBuilder>(c => c.ExistingLifetimeScope(container));
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
endpoint = Endpoint.Start(busConfiguration).GetAwaiter().GetResult();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
#endregion
}
static async Task SendOrder(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
break;
}
Guid id = Guid.NewGuid();
PlaceOrder placeOrder = new PlaceOrder
{
Product = "New shoes",
Id = id
};
await endpointInstance.Send("Samples.StepByStep.Server", placeOrder);
Console.WriteLine("Sent a new PlaceOrder message with id: {0}", id.ToString("N"));
}
}
public static async Task Run(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press 's' to send a valid message");
Console.WriteLine("Press 'e' to send a failed message");
Console.WriteLine("Press any key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
Console.WriteLine();
switch (key.Key)
{
case ConsoleKey.S:
#region SendingSmall
var createProductCommand = new CreateProductCommand
{
ProductId = "XJ128",
ProductName = "Milk",
ListPrice = 4,
// 7MB. MSMQ should throw an exception, but it will not since the buffer will be compressed
// before it reaches MSMQ.
Image = new byte[1024 * 1024 * 7]
};
await endpointInstance.SendLocal(createProductCommand)
.ConfigureAwait(false);
#endregion
break;
case ConsoleKey.E:
try
{
#region SendingLarge
var productCommand = new CreateProductCommand
{
ProductId = "XJ128",
ProductName = "Really long product name",
ListPrice = 15,
// 7MB. MSMQ should throw an exception, but it will not since the buffer will be compressed
// before it reaches MSMQ.
Image = new byte[1024 * 1024 * 7]
};
await endpointInstance.SendLocal(productCommand)
.ConfigureAwait(false);
#endregion
}
catch
{
//so the console keeps on running
}
break;
default:
{
return;
}
}
}
}
// Shut down server before sending this message, after 30 seconds, the message will be moved to Transactional dead-letter messages queue.
static async Task Expiration(IEndpointInstance endpointInstance)
{
await endpointInstance.Send(new MessageThatExpires
{
RequestId = new Guid()
});
Console.WriteLine("message with expiration was sent");
}
public static void SetInstance(IEndpointInstance endpoint)
{
if (Endpoint != null)
{
throw new Exception("Endpoint already set.");
}
Endpoint = endpoint;
}
static IDisposable StartWcfHost(IEndpointInstance endpointInstance)
{
WcfMapper wcfMapper = new WcfMapper(endpointInstance, "http://localhost:8080");
wcfMapper.StartListening<EnumMessage, Status>();
wcfMapper.StartListening<ObjectMessage, ReplyMessage>();
wcfMapper.StartListening<IntMessage, int>();
return wcfMapper;
}
Task DefaultAction(IEndpointInstance endpoint)
{
#region DefaultCriticalErrorAction
return endpoint.Stop();
#endregion
}
async Task Subscribe(IEndpointInstance endpoint)
{
#region ExplicitSubscribe
await endpoint.Subscribe<MyEvent>();
await endpoint.Unsubscribe<MyEvent>();
#endregion
}
static async Task SendMessage(IEndpointInstance endpointInstance)
{
Message message = new Message();
await endpointInstance.SendLocal(message);
Console.WriteLine();
Console.WriteLine("Message sent");
}
async void Simple(IEndpointInstance endpoint, SendOptions sendOptions, ILog log)
{
#region EnumCallback
Message message = new Message();
Status response = await endpoint.Request<Status>(message, sendOptions);
log.Info("Callback received with response:" + response);
#endregion
}
static async Task SendJsonMessage(IEndpointInstance endpointInstance)
{
MessageWithJson message = new MessageWithJson
{
SomeProperty = "Some content in a json message",
};
await endpointInstance.Send("Samples.MultiSerializer.Receiver", message);
Console.WriteLine("Json Message sent");
}
static async Task SendXmlMessage(IEndpointInstance endpointInstance)
{
var message = new MessageWithXml
{
SomeProperty = "Some content in a Xml message",
};
await endpointInstance.Send("Samples.MultiSerializer.Receiver", message)
.ConfigureAwait(false);
Console.WriteLine("XML message sent");
}
// Shut down server before sending this message, after 30 seconds, the message will be moved to Transactional dead-letter messages queue.
static async Task Expiration(IEndpointInstance endpointInstance)
{
var messageThatExpires = new MessageThatExpires
{
RequestId = new Guid()
};
await endpointInstance.Send(messageThatExpires)
.ConfigureAwait(false);
Console.WriteLine("message with expiration was sent");
}
async Task AsyncOnStart()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.WindowsServiceAndConsole");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.EnableInstallers();
endpoint = await Endpoint.Start(busConfiguration);
}
static async Task PublishEvent(IEndpointInstance endpointInstance)
{
Guid eventId = Guid.NewGuid();
await endpointInstance.Publish<IMyEvent>(m =>
{
m.EventId = eventId;
});
Console.WriteLine("Event published, id: " + eventId);
}
Scheduling(IEndpointInstance endpointInstance)
{
#region ScheduleTask
// To send a message every 5 minutes
endpointInstance.ScheduleEvery(TimeSpan.FromMinutes(5), b => b.Send(new CallLegacySystem()));
// Name a schedule task and invoke it every 5 minutes
endpointInstance.ScheduleEvery(TimeSpan.FromMinutes(5), "MyCustomTask", SomeCustomMethod);
#endregion
}
async Task AsyncOnStart()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("Samples.WindowsServiceAndConsole");
endpointConfiguration.UseSerialization<JsonSerializer>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.UsePersistence<InMemoryPersistence>();
endpointConfiguration.EnableInstallers();
endpoint = await Endpoint.Start(endpointConfiguration);
// run any startup actions on the bus
await endpoint.SendLocal(new MyMessage());
}
async Task StartBus()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration();
endpointConfiguration.EndpointName("Samples.Callbacks.WebSender");
endpointConfiguration.UseSerialization<JsonSerializer>();
endpointConfiguration.UsePersistence<InMemoryPersistence>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.SendFailedMessagesTo("error");
Endpoint = await NServiceBus.Endpoint.Start(endpointConfiguration);
}
async Task SendDelayedMessage(IEndpointInstance endpoint, IMessageHandlerContext handlerContext)
{
#region delayed-delivery-datetime
SendOptions options = new SendOptions();
options.DoNotDeliverBefore(new DateTime(2016, 12, 25));
await handlerContext.Send(new MessageToBeSentLater(), options);
// OR
await endpoint.Send(new MessageToBeSentLater(), options);
#endregion
}
static async Task SendRequest(IEndpointInstance endpointInstance)
{
Guid requestId = Guid.NewGuid();
await endpointInstance.Send(new Request
{
RequestId = requestId
});
Console.WriteLine("Request sent id: " + requestId);
}
internal void SetEndpoint(IEndpointInstance endpointInstance)
{
lock (endpointCriticalLock)
{
endpoint = endpointInstance;
foreach (var latentCritical in criticalErrors)
{
RaiseForEndpoint(latentCritical.Message, latentCritical.Exception);
}
criticalErrors.Clear();
}
}
static async Task SendMessageTooLargePayload(IEndpointInstance endpointInstance)
{
#region SendMessageTooLargePayload
AnotherMessageWithLargePayload message = new AnotherMessageWithLargePayload
{
LargeBlob = new byte[1024*1024*5] //5MB
};
await endpointInstance.Send("Samples.DataBus.Receiver", message);
#endregion
}
static async Task SendEnumMessage(IEndpointInstance endpointInstance)
{
Console.WriteLine("Message sent");
#region SendEnumMessage
EnumMessage message = new EnumMessage();
SendOptions sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Callbacks.Receiver");
Status status = await endpointInstance.Request<Status>(message, sendOptions);
Console.WriteLine("Callback received with status:" + status);
#endregion
}
static async Task Start(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press '1' to publish IEvent");
Console.WriteLine("Press '2' to publish EventMessage");
Console.WriteLine("Press '3' to publish AnotherEventMessage");
Console.WriteLine("Press any other key to exit");
#region PublishLoop
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var eventId = Guid.NewGuid();
switch (key.Key)
{
case ConsoleKey.D1:
await endpointInstance.Publish<IMyEvent>(m =>
{
m.EventId = eventId;
m.Time = DateTime.Now.Second > 30 ? (DateTime?) DateTime.Now : null;
m.Duration = TimeSpan.FromSeconds(99999D);
})
.ConfigureAwait(false);
Console.WriteLine($"Published IMyEvent with Id {eventId}.");
continue;
case ConsoleKey.D2:
var eventMessage = new EventMessage
{
EventId = eventId,
Time = DateTime.Now.Second > 30 ? (DateTime?) DateTime.Now : null,
Duration = TimeSpan.FromSeconds(99999D)
};
await endpointInstance.Publish(eventMessage)
.ConfigureAwait(false);
Console.WriteLine($"Published EventMessage with Id {eventId}.");
continue;
case ConsoleKey.D3:
var anotherEventMessage = new AnotherEventMessage
{
EventId = eventId,
Time = DateTime.Now.Second > 30 ? (DateTime?) DateTime.Now : null,
Duration = TimeSpan.FromSeconds(99999D)
};
await endpointInstance.Publish(anotherEventMessage)
.ConfigureAwait(false);
Console.WriteLine($"Published AnotherEventMessage with Id {eventId}.");
continue;
default:
return;
}
}
#endregion
}
static async Task Data(IEndpointInstance endpointInstance)
{
Guid requestId = Guid.NewGuid();
await endpointInstance.Send(new LargeMessage
{
RequestId = requestId,
LargeDataBus = new byte[1024*1024*5]
});
Console.WriteLine("Request sent id: " + requestId);
}
public async Task Write()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration(endpointName);
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterAudit>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.EnableInstallers();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.AuditProcessedMessagesTo(endpointName);
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
await endpoint.SendLocal(new MessageToSend());
ManualResetEvent.WaitOne();
await endpoint.Stop();
}
static Task SendStartMessages(IEndpointInstance endpoint)
{
var tasks = new List <Task>();
for (var i = 0; i < iterations; i++)
{
var sendOptions = new SendOptions();
sendOptions.RouteToThisEndpoint();
var sendMessage = new SendMessage
{
Blob = new DataBusProperty <byte[]>(Helpers.Buffer)
};
var send = endpoint.Send(sendMessage, sendOptions);
tasks.Add(send);
Console.WriteLine("Sending " + i);
}
return(Task.WhenAll(tasks));
}
public async Task Write()
{
BusConfiguration config = new BusConfiguration();
config.EndpointName(endpointName);
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterSaga>();
config.SetTypesToScan(typesToScan);
config.SendFailedMessagesTo("error");
config.EnableInstallers();
config.UsePersistence <InMemoryPersistence>();
config.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
IEndpointInstance endpoint = await Endpoint.Start(config);
await endpoint.SendLocal(new StartSaga1Message());
CountdownEvent.Wait();
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc();
var builder = new ContainerBuilder();
builder.Populate(services);
var endpointConfiguration = new EndpointConfiguration(endpointName: "OrderAPI");
var transport = endpointConfiguration.UseTransport <LearningTransport>();
var routing = transport.Routing();
routing.RouteToEndpoint(typeof(PlaceOrder), "Order");
IEndpointInstance endpointInstance = Endpoint.Start(endpointConfiguration).Result;
builder.RegisterInstance(endpointInstance).As <IEndpointInstance>().PropertiesAutowired();
//TODO: Register
this.ApplicationContainer = builder.Build();
return(new AutofacServiceProvider(this.ApplicationContainer));
}
static async Task SendMessageWithHttpStream(IEndpointInstance endpointInstance)
{
#region send-message-with-http-stream
using (WebClient webClient = new WebClient())
{
MessageWithStream message = new MessageWithStream
{
SomeProperty = "This message contains a stream",
StreamProperty = webClient.OpenRead("http://www.particular.net")
};
await endpointInstance.Send("Samples.PipelineStream.Receiver", message);
}
#endregion
Console.WriteLine();
Console.WriteLine("Message with http stream sent");
}
private static void Main(string[] args)
{
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddEnvironmentVariables("TODOMVC_");
Configuration = configurationBuilder.Build();
Console.Title = "Application";
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Warning()
.WriteTo.Console(outputTemplate: "[{Level}] {Message}{NewLine}{Exception}")
.CreateLogger();
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper;
NServiceBus.Logging.LogManager.Use <SerilogFactory>();
_container = new Container(x =>
{
x.For <IValidatorFactory>().Use <StructureMapValidatorFactory>();
x.Scan(y =>
{
y.TheCallingAssembly();
y.WithDefaultConventions();
});
});
// Start the bus
_bus = InitBus().Result;
Console.WriteLine("Press CTRL+C to exit...");
Console.CancelKeyPress += (sender, eArgs) =>
{
QuitEvent.Set();
eArgs.Cancel = true;
};
QuitEvent.WaitOne();
_bus.Stop().Wait();
}
static async Task RunLoop(IEndpointInstance endpointInstance)
{
var lastOrder = string.Empty;
while (true)
{
log.Info("Press 'P' to place an order, Press 'C' to cancel a placed order, or 'Q' to quit the program");
var key = Console.ReadKey();
Console.WriteLine();
switch (key.Key)
{
case ConsoleKey.P:
var command = new PlaceOrder
{
OrderId = Guid.NewGuid().ToString()
};
log.Info($"Sending PlaceOrder command, OrderId {command.OrderId}");
//await endpointInstance.SendLocal(command);
lastOrder = command.OrderId;
await endpointInstance.Send(command);
break;
case ConsoleKey.C:
var cancelCommand = new CancelOrder
{
OrderId = lastOrder
};
await endpointInstance.Send(cancelCommand);
log.Info($"Sent a correlated message to {cancelCommand.OrderId}");
break;
case ConsoleKey.Q:
return;
default:
log.Info("Unknown command. Please try again");
break;
}
}
}
Usage(EndpointConfiguration endpointConfiguration, IEndpointInstance endpoint)
{
#region GatewayConfiguration
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableFeature <Gateway>();
#endregion
#region GatewayDefaultRetryPolicyConfiguration
endpointConfiguration.Gateway().Retries(5, TimeSpan.FromMinutes(1));
#endregion
#region GatewayCustomRetryPolicyConfiguration
endpointConfiguration.Gateway().CustomRetryPolicy((message, exception, currentRetry) => { return(currentRetry > 4 ? TimeSpan.MinValue : TimeSpan.FromSeconds(currentRetry * 60)); });
#endregion
#region GatewayDisableRetriesConfiguration
endpointConfiguration.Gateway().DisableRetries();
#endregion
#region GatewayChannelFactoriesConfiguration
endpointConfiguration.Gateway().ChannelFactories(channelType => { return(new CustomChannelSender()); }, channelType => { return(new CustomChannelReceiver()); });
#endregion
#region SendToSites
endpoint.SendToSites(new[]
{
"SiteA",
"SiteB"
}, new MyMessage());
#endregion
}
static async Task AsyncMain()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration();
endpointConfiguration.EndpointName("Store.CustomerRelations");
endpointConfiguration.ApplyCommonConfiguration();
endpointConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
try
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
async Task Simple(IEndpointInstance endpoint)
{
#region CancelCallback
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(5));
var message = new Message();
try
{
var response = await endpoint.Request <int>(message, cancellationTokenSource.Token)
.ConfigureAwait(false);
}
catch (OperationCanceledException)
{
// Exception that is raised when the CancellationTokenSource is canceled
}
#endregion
}
static async Task Start(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press 'p' to publish event");
Console.WriteLine("Press any other key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var myEvent = new MyEvent
{
Consumer1Property = "Consumer1Info",
Consumer2Property = "Consumer2Info"
};
await endpointInstance.Publish(myEvent)
.ConfigureAwait(false);
}
}
public async Task Send()
{
var randomName = Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
var endpointName = $"send-{randomName}";
var errorQueueName = $"send-{randomName}-error";
var state = new State();
IEndpointInstance endpoint = null;
try
{
endpoint = await StartEndpoint(state, endpointName, errorQueueName).ConfigureAwait(false);
var message = @"{ Property: 'Value' }";
var headers = new Dictionary <string, string>
{
{ "NServiceBus.EnclosedMessageTypes", typeof(MessageToSend).FullName },
{ "NServiceBus.MessageId", Guid.NewGuid().ToString() }
};
using (var client = ClientFactory.CreateSqsClient())
{
await NativeSend.SendMessage(client, endpointName, message, headers)
.ConfigureAwait(false);
}
Assert.AreEqual("Value", await state.Signal.Task.ConfigureAwait(false));
}
finally
{
if (endpoint != null)
{
await endpoint.Stop().ConfigureAwait(false);
}
await DeleteEndpointQueues.DeleteQueuesForEndpoint(endpointName, includeRetries : true)
.ConfigureAwait(false);
await QueueDeletionUtils.DeleteQueue(errorQueueName)
.ConfigureAwait(false);
}
}
static async Task Run(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press 'Enter' to send a Message");
Console.WriteLine("Press any other key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key != ConsoleKey.Enter)
{
return;
}
Message message = new Message();
await endpointInstance.SendLocal(message);
Console.WriteLine();
Console.WriteLine("Message sent");
}
}
public override async Task Start(CancellationToken token)
{
ScenarioContext.CurrentEndpoint = configuration.EndpointName;
try
{
endpointInstance = await startCallback(startable).ConfigureAwait(false);
if (token.IsCancellationRequested)
{
throw new OperationCanceledException("Endpoint start was aborted");
}
}
catch (Exception ex)
{
Logger.Error("Failed to start endpoint " + configuration.EndpointName, ex);
throw;
}
}
static async Task AsyncRun()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Headers");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.RegisterComponents(components =>
{
components.ConfigureComponent <MutateIncomingMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateIncomingTransportMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateOutgoingMessages>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent <MutateOutgoingTransportMessages>(DependencyLifecycle.InstancePerCall);
});
#region global-all-outgoing
busConfiguration.AddHeaderToAllOutgoingMessages("AllOutgoing", "ValueAllOutgoing");
#endregion
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
#region sending
MyMessage myMessage = new MyMessage();
await endpoint.SendLocal(myMessage);
#endregion
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
public async Task Run()
{
if (endpointConfiguration == null)
{
var message = $"{nameof(EndpointCommunicationListener)} Run() method should be invoked after communication listener has been opened and not before.";
Logger.Log(message);
throw new Exception(message);
}
var zipcodeVotes = await stateManager.GetOrAddAsync <IReliableDictionary <Guid, SagaEntry> >("zipcode-votes")
.ConfigureAwait(false);
await zipcodeVotes.ClearAsync()
.ConfigureAwait(false);
endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
}
public static async Task RunTests(IEndpointInstance bus)
{
await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
await bus.Initiate().ConfigureAwait(false);
for (var i = 0; i < 10; i++)
{
await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false);
if (Verifier.IsFinished())
{
break;
}
}
await bus.Stop().ConfigureAwait(false);
Verifier.AssertExpectations();
}
static async Task Main()
{
Console.Title = "Samples.Autofac";
#region ContainerConfiguration
var endpointConfiguration = new EndpointConfiguration("Samples.Autofac");
var builder = new ContainerBuilder();
IEndpointInstance endpoint = null;
builder.Register(x => endpoint)
.As <IEndpointInstance>()
.SingleInstance();
builder.RegisterInstance(new MyService());
var container = builder.Build();
endpointConfiguration.UseContainer <AutofacBuilder>(
customizations: customizations =>
{
customizations.ExistingLifetimeScope(container);
});
#endregion
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.UseTransport <LearningTransport>();
endpoint = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
var endpointInstance = container.Resolve <IEndpointInstance>();
var myMessage = new MyMessage();
await endpointInstance.SendLocal(myMessage)
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public async Task Write()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration(endpointName);
Type[] callbackTypes = typeof(RequestResponseExtensions).Assembly.GetTypes();
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterReturn>(callbackTypes);
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.ScaleOut().InstanceDiscriminator("A");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
await endpoint.SendLocal(new MessageToSend());
ManualResetEvent.WaitOne();
}
public async Task Write()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration(EndpointName);
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterPublish>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
//give time for the subscription to happen
Thread.Sleep(3000);
await endpoint.Publish(new MessageToPublish());
ManualResetEvent.WaitOne();
await endpoint.Stop();
}
public static Task SendWithSignalRMetaData(this IEndpointInstance endpointInstance, ICommand command, HttpRequestMessage request, SendOptions incomingOptions = null)
{
var sendOptions = incomingOptions ?? new SendOptions();
if (request.Headers.Contains(MetaDataConstants.SignalRConnectionId))
{
var connectionId = request.Headers.GetValues(MetaDataConstants.SignalRConnectionId).Single();
sendOptions.SetHeader(MetaDataConstants.SignalRConnectionId, connectionId);
if (request.Properties.ContainsKey(MetaDataConstants.SignalRCorrelationId))
{
var correlationId = request.Properties[MetaDataConstants.SignalRCorrelationId] as string;
sendOptions.SetHeader(MetaDataConstants.SignalRCorrelationId, correlationId);
}
}
sendOptions.SetHeader(MetaDataConstants.CommandSentUtc, ZaphodTime.UtcNow.SerializeViewModel());
sendOptions.SetUserInfoOnHeader();
return(endpointInstance.Send(command, sendOptions));
}
public async Task <IEndpointInstance> StartAsync()
{
var sbConnString = ConfigurationManager.AppSettings["AzureServiceBusConnString"];
var endpointName = ConfigurationManager.AppSettings["QueueName"];
var storageConnString = ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ConnectionString;
var endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.EnableInstallers();
var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>();
transport.ConnectionString(sbConnString);
endpointConfiguration.SendFailedMessagesTo($"{endpointName}_errors");
/*endpointConfiguration.AuditProcessedMessagesTo("audit");
* endpointConfiguration.SendHeartbeatTo("Particular.ServiceControl");
* var metrics = endpointConfiguration.EnableMetrics();
* metrics.SendMetricDataToServiceControl("Particular.Monitoring", TimeSpan.FromMilliseconds(500));*/
transport.UseForwardingTopology();
var builder = new ContainerBuilder();
builder.Register(x => _endpointInstance).As <IEndpointInstance>().SingleInstance();
builder.Register(x => new StorageRepository(storageConnString)).AsSelf();
var container = builder.Build();
endpointConfiguration.UseContainer <AutofacBuilder>(
customizations =>
{
customizations.ExistingLifetimeScope(container);
});
_endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
return(_endpointInstance);
}
async Task Simple(EndpointConfiguration endpointConfiguration, IEndpointInstance endpoint, SendOptions sendOptions, ILog log)
{
#region Callbacks-InstanceId
endpointConfiguration.ScaleOut()
.InstanceDiscriminator("uniqueId");
#endregion
#region ObjectCallback
var message = new Message();
var response = await endpoint.Request <ResponseMessage>(message, sendOptions)
.ConfigureAwait(false);
log.Info("Callback received with response:" + response.Property);
#endregion
}
static async Task AsyncMain()
{
LogManager.Use <DefaultFactory>()
.Level(LogLevel.Warn);
#region DisableSLR
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.ErrorHandling.WithoutSLR");
busConfiguration.DisableFeature <SecondLevelRetries>();
#endregion
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusContext busContext = endpoint.CreateBusContext();
Console.WriteLine("Press enter to send a message that will throw an exception.");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key != ConsoleKey.Enter)
{
return;
}
MyMessage m = new MyMessage
{
Id = Guid.NewGuid()
};
await busContext.SendLocal(m);
}
}
finally
{
await endpoint.Stop();
}
}
public static async Task Start(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press 'C' to send a command");
Console.WriteLine("Press 'R' to send a request");
Console.WriteLine("Press 'D' to send a large message that is marked to be sent using Data Bus");
Console.WriteLine("Press 'X' to send a message that is marked with expiration time.");
Console.WriteLine("Press any other key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
switch (key.Key)
{
case ConsoleKey.C:
await SendCommand(endpointInstance)
.ConfigureAwait(false);
continue;
case ConsoleKey.R:
await SendRequest(endpointInstance)
.ConfigureAwait(false);
continue;
case ConsoleKey.D:
await Data(endpointInstance)
.ConfigureAwait(false);
continue;
case ConsoleKey.X:
await Expiration(endpointInstance)
.ConfigureAwait(false);
continue;
}
return;
}
}
static async Task Start()
{
var config = new EndpointConfiguration("Sender");
config.UseSerialization <NewtonsoftSerializer>();
config.SendFailedMessagesTo("error");
config.EnableInstallers();
config.UsePersistence <InMemoryPersistence>();
var useRouter = SettingsReader <bool> .Read("UseRouter", true);
var connectionString = SettingsReader <string> .Read("SqlConnectionString", "data source=(local); initial catalog=loadtest; integrated security=true");
var bodySize = SettingsReader <int> .Read("BodySize");
var maxConcurrency = SettingsReader <int> .Read("MaxConcurrency", 32);
config.RegisterComponents(c => c.RegisterSingleton(new LoadGenerator((info, token) => GenerateMessages(bodySize, info, token, maxConcurrency), 10000, 20000)));
var senderTransport = config.UseTransport <SqlServerTransport>();
senderTransport.UseNativeDelayedDelivery().DisableTimeoutManagerCompatibility();
senderTransport.ConnectionString(connectionString);
senderTransport.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
if (useRouter)
{
var senderRouterConnector = senderTransport.Routing().ConnectToRouter("Sender.Router");
senderRouterConnector.RouteToEndpoint(typeof(MyMessage), "Receiver");
}
else
{
senderTransport.Routing().RouteToEndpoint(typeof(MyMessage), "Receiver");
}
endpointInstance = await Endpoint.Start(config);
Console.WriteLine("Press <enter> to exit.");
Console.ReadLine();
await endpointInstance.Stop();
}
static async Task RunLoop(IEndpointInstance endpointInstance)
{
int currentFloor = 0;
log.Info("Press 'U' to go to Up, 'D' to go Down, or 'Q' to quit.");
while (true)
{
log.Info($"You are on floor {currentFloor}. {hallwayButtonPanel.StatusText()}");
var key = Console.ReadKey();
Console.WriteLine();
switch (key.Key)
{
case ConsoleKey.U:
case ConsoleKey.D:
// Instantiate the command
var command = new SummonElevator
{
CurrentFloor = new Floor()
{
Id = currentFloor
},
RequestedDirection = key.Key == ConsoleKey.U? Direction.Up : Direction.Down
};
// Send the command to the local endpoint
//log.Info($"Sending GoToFloor command, Floor = {command.Floor}");
await endpointInstance.Send(command)
.ConfigureAwait(false);
break;
case ConsoleKey.Q:
return;
default:
log.Info("Unknown input. Please try again.");
break;
}
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.PerfCounters");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
#region enable-counters
busConfiguration.EnableCriticalTimePerformanceCounter();
busConfiguration.EnableSLAPerformanceCounter(TimeSpan.FromSeconds(100));
#endregion
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
Console.WriteLine("Press enter to send 10 messages with random sleep");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
break;
}
for (int i = 0; i < 10; i++)
{
await endpoint.SendLocal(new MyMessage());
}
}
}
finally
{
await endpoint.Stop();
}
}
static async Task Main(string[] args)
{
var configuration = new EndpointConfiguration(Shared.Configuration.SenderEndpointName);
configuration.UseTransport <SqlServerTransport>()
.ConnectionString(() => Shared.Configuration.ConnectionString)
.Routing().RouteToEndpoint(typeof(TestCommand).Assembly, Shared.Configuration.ReceiverEndpointName);
configuration.UsePersistence <InMemoryPersistence>();
configuration.Conventions().DefiningCommandsAs(t => t == typeof(TestCommand));
configuration.EnableInstallers();
endpoint = await Endpoint.Start(configuration);
var rootCommand = new RootCommand();
rootCommand.AddCommand(CreateChildCommand(nameof(Send), "send"));
rootCommand.AddCommand(CreateChildCommand(nameof(ThrottledSend), "throttled-send"));
rootCommand.AddCommand(CreateChildCommand(nameof(FillQueue), "fill"));
rootCommand.AddCommand(CreateChildCommand(nameof(ResetStatistics), "reset"));
var ctSource = new CancellationTokenSource();
ct = ctSource.Token;
var task = rootCommand.InvokeAsync(args);
while (ctSource.IsCancellationRequested == false && task.IsCompleted == false)
{
if (Console.KeyAvailable && Console.ReadKey().Key == ConsoleKey.Enter)
{
ctSource.Cancel();
break;
}
await Task.Delay(TimeSpan.FromMilliseconds(500));
}
await task;
}
static async Task MainAsync()
{
Console.Title = "Samples.ASB.Polymorphic.Subscriber";
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("Samples.ASB.Polymorphic.Subscriber");
var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>();
transport.UseTopology <EndpointOrientedTopology>();
transport.ConnectionString(Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString"));
endpointConfiguration.SendFailedMessagesTo("error");
#region DisableAutoSubscripton
endpointConfiguration.DisableFeature <AutoSubscribe>();
#endregion
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.DisableFeature <SecondLevelRetries>();
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
try
{
#region ControledSubscriptions
await endpoint.Subscribe <BaseEvent>();
#endregion
Console.WriteLine("Subscriber is ready to receive events");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
