public async Task SendFault(FutureConsumeContext <TInput> context, params FutureSubscription[] subscriptions)
{
InitializeContext <TFault> initializeContext;
if (context.Message is Fault fault)
{
var request = context.Instance.GetRequest <TRequest>();
context.SetFaulted(context.Instance.CorrelationId, fault.Timestamp);
initializeContext = await MessageInitializerCache <TFault> .Initialize(new
{
fault.FaultId,
fault.FaultedMessageId,
fault.Timestamp,
fault.Exceptions,
fault.Host,
fault.FaultMessageTypes,
Message = request
}, context.CancellationToken);
initializeContext = await MessageInitializerCache <TFault> .Initialize(initializeContext, context.Message);
}
else
{
context.SetFaulted(context.Instance.CorrelationId);
initializeContext = await MessageInitializerCache <TFault> .Initialize(context.Message, context.CancellationToken);
}
var values = _provider(context);
IMessageInitializer <TFault> initializer = MessageInitializerCache <TFault> .GetInitializer(values.GetType());
InitializeContext <TFault> messageContext = await initializer.Initialize(initializeContext, values).ConfigureAwait(false);
context.SetFault(context.Instance.CorrelationId, messageContext.Message);
await context.SendMessageToSubscriptions(subscriptions, initializer, initializeContext, values).ConfigureAwait(false);
}
public async Task Should_deserialize()
{
var contract = await MessageInitializerCache <RawContract> .InitializeMessage(new
{
Name = "Frank",
Value = 27,
InVar.Timestamp
});
await using var ms = new MemoryStream(4000);
XmlMessageSerializer.Serialize(ms, contract, typeof(RawContract));
var body = ms.ToArray();
SendRawMessage(body);
ConsumeContext <RawContract> received = await _receivedA;
Assert.AreEqual(contract.Name, received.Message.Name);
Assert.AreEqual(contract.Value, received.Message.Value);
Assert.AreEqual(contract.Timestamp, received.Message.Timestamp);
}
Task <ScheduledMessage <T> > IMessageScheduler.ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, object values, IPipe <SendContext> pipe,
CancellationToken cancellationToken)
{
if (destinationAddress == null)
{
throw new ArgumentNullException(nameof(destinationAddress));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
if (pipe == null)
{
throw new ArgumentNullException(nameof(pipe));
}
var message = MessageInitializerCache <T> .InitializeMessage(values, cancellationToken);
return(_provider.ScheduleSend(destinationAddress, scheduledTime, message, pipe, cancellationToken));
}
public async Task SendResponse(FutureConsumeContext <TResult> context, params FutureSubscription[] subscriptions)
{
context.SetCompleted(context.Instance.CorrelationId);
InitializeContext <TResponse> initializeContext = await MessageInitializerCache <TResponse> .Initialize(new
{
context.Instance.Canceled,
context.Instance.Completed,
context.Instance.Created,
context.Instance.Deadline,
context.Instance.Faulted,
context.Instance.Location,
}, context.CancellationToken);
var request = context.Instance.GetRequest <TRequest>();
if (request != null)
{
initializeContext = await MessageInitializerCache <TResponse> .Initialize(initializeContext, request);
}
if (context.Message != null)
{
initializeContext = await MessageInitializerCache <TResponse> .Initialize(initializeContext, context.Message);
}
// this is due to the way headers are propagated via the initializer
var values = _provider(context);
IMessageInitializer <TResponse> initializer = MessageInitializerCache <TResponse> .GetInitializer(values.GetType());
// initialize the message and save it as the response
InitializeContext <TResponse> messageContext = await initializer.Initialize(initializeContext, values).ConfigureAwait(false);
context.SetResult(context.Instance.CorrelationId, messageContext.Message);
await context.SendMessageToSubscriptions(subscriptions, initializer, initializeContext, values).ConfigureAwait(false);
}
async Task RespondAsyncInternal <T>(object values, IPipe <SendContext <T> > responsePipe = default)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var context = await MessageInitializerCache <T> .Initialize(Message, _context.CancellationToken).ConfigureAwait(false);
IMessageInitializer <T> initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
var responseEndpoint = await GetResponseEndpoint <T>().ConfigureAwait(false);
if (responsePipe.IsNotEmpty())
{
await ConsumeTask(initializer.Send(responseEndpoint, context, values, responsePipe)).ConfigureAwait(false);
}
else
{
await ConsumeTask(initializer.Send(responseEndpoint, context, values)).ConfigureAwait(false);
}
}
async Task RespondAsyncInternal <T>(object values, IPipe <SendContext <T> > responsePipe)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
IMessageInitializer <T> initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
var context = initializer.Create(this);
if (ResponseAddress != null)
{
var endpoint = await GetSendEndpoint(ResponseAddress).ConfigureAwait(false);
await ConsumeTask(initializer.Send(endpoint, context, values, responsePipe)).ConfigureAwait(false);
}
else
{
await ConsumeTask(initializer.Publish(_publishEndpoint.Value, context, values, responsePipe)).ConfigureAwait(false);
}
}
async Task RespondAsyncInternal <T>(object values, IPipe <SendContext <T> > responsePipe)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var context = await MessageInitializerCache <T> .Initialize(Message, _context.CancellationToken).ConfigureAwait(false);
IMessageInitializer <T> initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
if (_context.ResponseAddress != null)
{
var endpoint = await _context.GetSendEndpoint(_context.ResponseAddress).ConfigureAwait(false);
await ConsumeTask(initializer.Send(endpoint, context, values, responsePipe)).ConfigureAwait(false);
}
else
{
await ConsumeTask(initializer.Publish(_context, context, values, responsePipe)).ConfigureAwait(false);
}
}
Task <ScheduledRecurringMessage <T> > IRecurringMessageScheduler.ScheduleRecurringSend <T>(Uri destinationAddress, RecurringSchedule schedule,
object values,
IPipe <SendContext> pipe,
CancellationToken cancellationToken)
{
if (destinationAddress == null)
{
throw new ArgumentNullException(nameof(destinationAddress));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
if (pipe == null)
{
throw new ArgumentNullException(nameof(pipe));
}
Task <T> message = MessageInitializerCache <T> .InitializeMessage(values, cancellationToken);
return(ScheduleRecurringSend(destinationAddress, schedule, message, pipe, cancellationToken));
}
/// <summary>
/// Initialize a message using the specified input values (via an anonymous object, or an actual object)
/// </summary>
/// <param name="context"></param>
/// <param name="values"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Task <T> Init <T>(this ConsumeContext context, object values)
where T : class
{
return(MessageInitializerCache <T> .InitializeMessage(context, values));
}
public async Task Should_convert_value_types_to_strings()
{
InitializeContext <TestStringMessage> context = await MessageInitializerCache <TestStringMessage> .Initialize(new { Text = _intValue });
Assert.That(context.Message.Text, Is.EqualTo(_intValue.ToString()));
}
public InitializePropertyConverter()
{
_initializer = MessageInitializerCache <TProperty> .GetInitializer(typeof(TInput));
}
public async Task Should_initialize_object_with_readonly_property()
{
var model1 = new { ReadWrite = "Some Property Value" };
await MessageInitializerCache <ReadWriteReadOnly> .Initialize(model1);
}
