public async Task <GeoLineResult> SendGeoLineRequest(GeoLineRequest geoLineRequest)
{
var sendOptions = new SendOptions();
sendOptions.SetDestination("GeoAPI.GeoCalcServer");
var geoLineResponse = await _messageSession.Request <GeoLineResult>(geoLineRequest, sendOptions);
return(geoLineResponse);
}
public static async Task <bool> TimeoutCommand(this IMessageSession ctx, ICommand command, TimeSpan timeout)
{
if (string.IsNullOrEmpty(Configuration.Settings.CommandDestination))
{
throw new ArgumentException($"Must use Configuration.SetCommandDestination to use destination-less extension methods");
}
var options = new SendOptions();
options.SetDestination(Configuration.Settings.CommandDestination);
options.SetHeader(Defaults.RequestResponse, "1");
var cancelation = new CancellationTokenSource(timeout);
try
{
var response = await ctx.Request <IMessage>(command, options, cancelation.Token).ConfigureAwait(false);
CheckResponse(command, response);
return(true);
}
catch (TaskCanceledException)
{
Logger.WarnEvent("TimeOut", "{CommandType}", command.GetType().FullName);
return(false);
}
}
public Invoice CalculateInvoice(Cart cart)
{
var items = cart.ToList();
var order = new Domain.Interface.Order
{
Equipment = items
.Select(item => new Domain.Interface.EquipmentOrder(item.Type, item.RentalDays))
.ToList()
};
var sendOptions = new SendOptions();
sendOptions.SetDestination("Bondora.Rental.Domain.Interface");
// since now message queue is used, it might be a good idea to "mark" all messages with some unique ID
// currently I have no confidence how messages from several running web instances will be handled,
// and if NServiceBus does this automatically
var reply = _messageSession
.Request <Domain.Interface.Invoice>(order, sendOptions)
.GetAwaiter()
.GetResult();
// expected that invoice keeps equipment in the same order
// following code will fail if ordering is broken
var invoiceLines = new List <InvoiceLine>();
for (var index = 0; index < items.Count; index++)
{
invoiceLines.Add(new InvoiceLine(items[index].Name, reply.Lines[index]));
}
return(new Invoice(invoiceLines, reply.Price, reply.LoyaltyPoints));
}
public async Task <IActionResult> OnPostAsync(string textField)
{
if (string.IsNullOrWhiteSpace(textField))
{
return(Page());
}
#region ActionHandling
if (!int.TryParse(textField, out var number))
{
return(Page());
}
var command = new Command
{
Id = number
};
var sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.AsyncPages.Server");
var code = await messageSession.Request <ErrorCodes>(command, sendOptions);
ResponseText = Enum.GetName(typeof(ErrorCodes), code);
return(Page());
#endregion
}
public static async Task CommandToDomain <T>(this IMessageSession bus, T message, bool timeout = true) where T : StampedCommand
{
var options = new SendOptions();
options.SetDestination("domain");
options.SetHeader(Aggregates.Defaults.RequestResponse, "1");
var response = bus.Request <Aggregates.Messages.IMessage>(message, options);
if (timeout)
{
await Task.WhenAny(
Task.Delay(TenSeconds), response)
.ConfigureAwait(false);
}
else
{
await response.ConfigureAwait(false);
}
if (!response.IsCompleted)
{
throw new CommandTimeoutException("Command timed out");
}
CheckResponse(message, response.Result);
}
public ActionResult Index(string textField)
{
ViewBag.Title = "SendAndBlock";
if (!int.TryParse(textField, out var number))
{
return(View());
}
#region SendAndBlockController
var command = new Command
{
Id = number
};
var sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Mvc.Server");
var status = messageSession.Request <ErrorCodes>(command, sendOptions).GetAwaiter().GetResult();
return(IndexCompleted(Enum.GetName(typeof(ErrorCodes), status)));
#endregion
}
public static async Task <object> RequestQuery <T, TResponse>(this IMessageSession bus, T message, bool timeout = true) where T : Query where TResponse : class
{
var options = new SendOptions();
options.SetDestination("mongodb");
options.SetHeader(Aggregates.Defaults.RequestResponse, "1");
var response = bus.Request <Reply>(message, options);
if (timeout)
{
await Task.WhenAny(
Task.Delay(TenSeconds), response)
.ConfigureAwait(false);
}
else
{
await response.ConfigureAwait(false);
}
if (!response.IsCompleted)
{
throw new CommandTimeoutException("Request timed out");
}
if (response.Result.Payload == null)
{
throw new QueryRejectedException("No results for query");
}
return(response.Result.RequestQuery <TResponse>());
}
public async Task <ActionResult> Index(GetUserByIdViewModel model)
{
var response = await _session.Request <GetUserByIdCommandReply>(model.GetUserByIdCommand);
model.Result = response.User?.Name ?? "User Not Found";
return(View(model));
}
public async Task <string> Get()
{
var message = new ProcessPayment {
ReferenceId = Guid.NewGuid().ToString(), AccountNumberEncrypted = "123456", RoutingNumber = "555555", Amount = 100.45M, RequestDate = DateTime.UtcNow
};
var response = await messageSession.Request <ProcessPaymentReply>(message);
return("Payment Status: " + JsonConvert.SerializeObject(response));
}
public async Task <JsonResult <ZResponse> > Get(Guid customerId)
{
var msg = new DoZSyncOverAsync {
CustomerId = customerId
};
var response = await _messageSession.Request <ZResponse>(msg);
return(Json(response));
}
public static async Task Command(this IMessageSession ctx, ICommand command)
{
var options = new SendOptions();
options.SetHeader(Defaults.RequestResponse, "1");
var response = await ctx.Request <IMessage>(command, options).ConfigureAwait(false);
response.CommandResponse();
}
public static async Task <R.ResponsesQuery <TResponse> > RequestToElastic <T, TResponse>(this IMessageSession bus, T message, Q.QueriesQuery <TResponse> query) where T : IQuery where TResponse : class
{
var options = new SendOptions();
options.SetDestination(RiakEndpoint);
options.SetHeader(Aggregates.Defaults.RequestResponse, "1");
var response = await bus.Request <IMessage>(message, options).ConfigureAwait(false);
return(response.RequestQuery(query));
}
public static async Task <R.ResponsesPaged <TResponse> > RequestToElastic <T, TResponse>(this IMessageSession bus, Action <T> messageConstructor, Q.QueriesPaged <TResponse> query) where T : IPaged where TResponse : class
{
var options = new SendOptions();
options.SetDestination(ElasticEndpoint);
options.SetHeader(Aggregates.Defaults.RequestResponse, "1");
var response = await bus.Request <IMessage>(messageConstructor, options).ConfigureAwait(false);
return(response.RequestPaged(query));
}
public static async Task CommandToDomain <T>(this IMessageSession bus, T message) where T : DemoCommand
{
var options = new SendOptions();
options.SetDestination(DomainEndpoint);
options.SetHeader(Aggregates.Defaults.RequestResponse, "1");
var response = await bus.Request <IMessage>(message, options).ConfigureAwait(false);
response.CommandResponse();
}
public static async Task DomainCommand(this IMessageSession ctx, ICommand command)
{
var options = new NServiceBus.SendOptions();
options.RouteToThisEndpoint();
options.SetHeader(Aggregates.Defaults.RequestResponse, "1");
var response = await ctx.Request <IMessage>(command, options).ConfigureAwait(false);
response.CommandResponse();
}
public async Task <SubmitOrderResponse> SubmitOrderAsync()
{
var command = new SubmitOrderCommand {
Number = DateTime.Now.Ticks
};
_log.LogInformation($"SubmitOrderCommand {command.Number}");
var response = await _messageSession.Request <SubmitOrderResponse>(command);
_log.LogInformation($"SubmitOrderResponse {response.Id}");
return(response);
}
public static async Task Command(this IMessageSession ctx, ICommand command)
{
if (string.IsNullOrEmpty(Configuration.Settings.CommandDestination))
{
throw new ArgumentException($"Must use Configuration.SetCommandDestination to use destination-less extension methods");
}
var options = new SendOptions();
options.SetDestination(Configuration.Settings.CommandDestination);
options.SetHeader(Defaults.RequestResponse, "1");
var response = await ctx.Request <IMessage>(command, options).ConfigureAwait(false);
CheckResponse(command, response);
}
public async Task RunSample(IServiceProvider provider, IMessageSession bus, string barValue)
{
var subscriber = provider.GetRequiredService <ISubscriber>();
var options = new SendOptions();
options.SetDestination("TestDestination");
var reply = await bus.Request <TestCommand, TestReply>(
subscriber, cmd =>
{
cmd.Property1 = "foo";
cmd.Property2 = barValue;
}, options).WithTimeout(TimeSpan.FromSeconds(60));
Console.WriteLine($"Instance {_instanceId} received reply \"{reply.ReplyValue}\"");
}
public async Task <IActionResult> Callback()
{
var guid = Guid.NewGuid();
var message = new RequestDataMessage
{
DataId = guid,
String = "String property value"
};
var response = await _messageSession.Request <DataResponseMessage>(message)
.ConfigureAwait(false);
return(new OkObjectResult(new
{
RequestId = guid,
ResponseId = response.Id,
}));
}
public static async Task <bool> TimeoutCommand(this IMessageSession ctx, ICommand command, TimeSpan timeout)
{
var options = new SendOptions();
options.SetHeader(Defaults.RequestResponse, "1");
var cancelation = new CancellationTokenSource(timeout);
try
{
var response = await ctx.Request <IMessage>(command, options, cancelation.Token).ConfigureAwait(false);
response.CommandResponse();
return(true);
}
catch (TaskCanceledException)
{
return(false);
}
}
public static async Task <Responses.Paged <TResponse> > Request <T, TResponse>(this IMessageSession bus, T message) where T : Paged where TResponse : class
{
var options = new SendOptions();
options.SetDestination("application2");
options.SetHeader(Aggregates.Defaults.RequestResponse, "1");
var response = bus.Request <PagedReply>(message, options);
await Task.WhenAny(
Task.Delay(TenSeconds), response)
.ConfigureAwait(false);
if (!response.IsCompleted)
{
throw new CommandTimeoutException("Request timed out");
}
return(response.Result.RequestPaged <TResponse>());
}
public async Task <ActionResult> Index(string textField)
{
if (!int.TryParse(textField, out var number))
{
return(View("Index"));
}
#region AsyncController
var command = new Command
{
Id = number
};
var sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Mvc.Server");
var status = await messageSession.Request <ErrorCodes>(command, sendOptions);
return(IndexCompleted(Enum.GetName(typeof(ErrorCodes), status)));
#endregion
}
public static async Task <bool> TimeoutCommand(this IMessageSession ctx, ICommand command, TimeSpan timeout)
{
var options = new SendOptions();
options.SetHeader(Defaults.RequestResponse, "1");
var cancelation = new CancellationTokenSource(timeout);
try
{
var response = await ctx.Request <IMessage>(command, options, cancelation.Token).ConfigureAwait(false);
CheckResponse(command, response);
return(true);
}
catch (TaskCanceledException)
{
Logger.WarnEvent("TimeOut", "{CommandType}", command.GetType().FullName);
return(false);
}
}
public static async Task <bool> TimeoutCommand(this IMessageSession ctx, string destination, ICommand command, TimeSpan timeout)
{
var options = new SendOptions();
options.SetDestination(destination);
options.SetHeader(Defaults.RequestResponse, "1");
var cancelation = new CancellationTokenSource(timeout);
try
{
var response = await ctx.Request <IMessage>(command, options, cancelation.Token).ConfigureAwait(false);
response.CommandResponse();
return(true);
}
catch (TaskCanceledException)
{
Logger.Warn($"Command {command.GetType().FullName} timed out");
return(false);
}
}
public async Task <IActionResult> Devace()
{
var id = Thread.CurrentThread.ManagedThreadId;
var clientId = HttpContext.ClientId();
var devices = await _devaceService.GetAllDevices(clientId);
if (devices.Count == 0)
{
return(NoContent());
}
var id2 = Thread.CurrentThread.ManagedThreadId;
List <Guid> serialNamber = new List <Guid>();
for (int i = 0; i < devices.Count; i++)
{
serialNamber.Add(devices[i].SirialNumber);
}
var response = await _message.Request <DeviceCallback>(new UserMessage(serialNamber));
string jsonData = JsonConvert.SerializeObject(response.Devices);
return(Content(jsonData));
}
public Task <Paged <Todo.Models.TodoResponse> > Any(Todo.AllTodos request)
{
return(_bus.Request <Todo.Queries.AllTodos, Todo.Models.TodoResponse>(new Todo.Queries.AllTodos
{
}));
}
public Task <Paged <Todo.Models.TodoResponse> > All()
{
return(_session.Request <Todo.Queries.AllTodos, Todo.Models.TodoResponse>(new Todo.Queries.AllTodos
{
}));
}
/// <summary>
/// Sends a <paramref name="requestMessage" /> to the configured destination and returns back a
/// <see cref="Task{TResponse}" /> which can be awaited.
/// </summary>
/// <remarks>
/// The task returned is non durable. When the AppDomain is unloaded or the response task is canceled.
/// Messages can still arrive to the requesting endpoint but in that case no handling code will be attached to consume
/// that response message and therefore the message will be moved to the error queue.
/// </remarks>
/// <typeparam name="TResponse">The response type.</typeparam>
/// <param name="session">The session.</param>
/// <param name="requestMessage">The request message.</param>
/// <param name="options">The options for the send.</param>
/// <returns>A task which contains the response when it is completed.</returns>
public static Task <TResponse> Request <TResponse>(this IMessageSession session, object requestMessage, SendOptions options)
{
return(session.Request <TResponse>(requestMessage, options, CancellationToken.None));
}
/// <summary>
/// Sends a <paramref name="requestMessage" /> to the configured destination and returns back a
/// <see cref="Task{TResponse}" /> which can be awaited.
/// </summary>
/// <remarks>
/// The task returned is non durable. When the AppDomain is unloaded or the response task is canceled.
/// Messages can still arrive to the requesting endpoint but in that case no handling code will be attached to consume
/// that response message and therefore the message will be moved to the error queue.
/// </remarks>
/// <typeparam name="TResponse">The response type.</typeparam>
/// <param name="session">The session.</param>
/// <param name="requestMessage">The request message.</param>
/// <param name="cancellationToken">The cancellation token used to cancel the request.</param>
/// <returns>A task which contains the response when it is completed.</returns>
public static Task <TResponse> Request <TResponse>(this IMessageSession session, object requestMessage, CancellationToken cancellationToken)
{
return(session.Request <TResponse>(requestMessage, new SendOptions(), cancellationToken));
}
