Task <TProperty> IPropertyConverter <TProperty, TInput> .Convert <TMessage>(InitializeContext <TMessage> context, TInput input)
{
if (input == null)
{
return(TaskUtil.Default <TProperty>());
}
InitializeContext <TProperty> messageContext = MessageFactoryCache <TProperty> .Factory.Create(context);
IMessageInitializer <TProperty> initializer = typeof(TInput) == typeof(object)
? MessageInitializerCache <TProperty> .GetInitializer(input.GetType())
: MessageInitializerCache <TProperty> .GetInitializer(typeof(TInput));
Task <InitializeContext <TProperty> > initTask = initializer.Initialize(messageContext, input);
if (initTask.IsCompleted)
{
return(Task.FromResult(initTask.Result.Message));
}
async Task <TProperty> ConvertAsync()
{
InitializeContext <TProperty> result = await initTask.ConfigureAwait(false);
return(result.Message);
}
return(ConvertAsync());
}
/// <summary>
/// Send a message
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="provider"></param>
/// <param name="values"></param>
/// <param name="pipe"></param>
/// <param name="cancellationToken"></param>
/// <returns>The task which is completed once the Send is acknowledged by the broker</returns>
public static async Task Send <T>(this ISendEndpointProvider provider, object values, IPipe <SendContext> pipe,
CancellationToken cancellationToken = default)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
if (!EndpointConvention.TryGetDestinationAddress <T>(out var destinationAddress))
{
throw new ArgumentException($"A convention for the message type {TypeMetadataCache<T>.ShortName} was not found");
}
var endpoint = await provider.GetSendEndpoint(destinationAddress).ConfigureAwait(false);
var initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
if (provider is ConsumeContext context)
{
await initializer.Send(endpoint, initializer.Create(context), values, pipe).ConfigureAwait(false);
}
else
{
await initializer.Send(endpoint, values, pipe, cancellationToken).ConfigureAwait(false);
}
}
public Task <InitializeContext <TMessage> > CreateMessage(object values, CancellationToken cancellationToken)
{
var initializer = MessageInitializerCache <TMessage> .GetInitializer(values.GetType());
return(_consumeContext != null
? initializer.Initialize(initializer.Create(_consumeContext), values)
: initializer.Initialize(values, cancellationToken));
}
public async Task <T> CreateMessage(object values, CancellationToken cancellationToken)
{
var initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
if (_sendEndpointProvider is ConsumeContext context)
{
return((await initializer.Initialize(initializer.Create(context), values).ConfigureAwait(false)).Message);
}
return((await initializer.Initialize(values, cancellationToken).ConfigureAwait(false)).Message);
}
public Task Send <T>(object values, CancellationToken cancellationToken)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
return(initializer.Send(this, values, cancellationToken));
}
public Task <TRequest> Send(Guid requestId, object values, IPipe <SendContext <TRequest> > pipe, CancellationToken cancellationToken)
{
IMessageInitializer <TRequest> initializer = MessageInitializerCache <TRequest> .GetInitializer(values.GetType());
if (_consumeContext != null)
{
InitializeContext <TRequest> initializeContext = initializer.Create(_consumeContext);
return(initializer.Send(_endpoint, initializeContext, values, new ConsumeSendPipeAdapter <TRequest>(_consumeContext, pipe, requestId)));
}
return(initializer.Send(_endpoint, values, pipe, cancellationToken));
}
public async Task <TRequest> Send(Guid requestId, object values, IPipe <SendContext <TRequest> > pipe, CancellationToken cancellationToken)
{
var endpoint = await GetPublishSendEndpoint().ConfigureAwait(false);
IMessageInitializer <TRequest> initializer = MessageInitializerCache <TRequest> .GetInitializer(values.GetType());
if (_consumeContext != null)
{
InitializeContext <TRequest> initializeContext = initializer.Create(_consumeContext);
return(await initializer.Send(endpoint, initializeContext, values, new ConsumeSendPipeAdapter <TRequest>(_consumeContext, pipe, requestId))
.ConfigureAwait(false));
}
return(await initializer.Send(endpoint, values, pipe, cancellationToken).ConfigureAwait(false));
}
Task IPublishEndpoint.Publish <T>(object values, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken)
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
if (_consumeContext != null)
{
return(initializer.Publish(this, initializer.Create(_consumeContext), values, publishPipe));
}
return(initializer.Publish(this, values, publishPipe, cancellationToken));
}
async Task <TProperty> IPropertyConverter <TProperty, TInput> .Convert <TMessage>(InitializeContext <TMessage> context, TInput input)
{
if (input == null)
{
return(null);
}
InitializeContext <TProperty> messageContext = MessageFactoryCache <TProperty> .Factory.Create(context);
IMessageInitializer <TProperty> initializer = typeof(TInput) == typeof(object)
? MessageInitializerCache <TProperty> .GetInitializer(input.GetType())
: MessageInitializerCache <TProperty> .GetInitializer(typeof(TInput));
InitializeContext <TProperty> result = await initializer.Initialize(messageContext, input).ConfigureAwait(false);
return(result.Message);
}
public Task Send <T>(object values, IPipe <SendContext> pipe, CancellationToken cancellationToken)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
if (pipe == null)
{
throw new ArgumentNullException(nameof(pipe));
}
var initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
return(initializer.Send(this, initializer.Create(_context), values, pipe));
}
public Task Send <T>(object values, IPipe <SendContext <T> > pipe, CancellationToken cancellationToken)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
if (pipe == null)
{
throw new ArgumentNullException(nameof(pipe));
}
IMessageInitializer <T> initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
InitializeContext <T> context = GetInitializeContext(initializer, cancellationToken);
return(initializer.Send(this, context, values, pipe));
}
public async Task SendResponse(FutureConsumeContext <TResponse> context, params FutureSubscription[] subscriptions)
{
context.SetCompleted(context.Instance.CorrelationId);
InitializeContext <TResult> initializeContext = await MessageInitializerCache <TResult> .Initialize(new
{
context.Instance.Completed,
context.Instance.Created,
context.Instance.Faulted,
context.Instance.Location,
}, context.CancellationToken);
var request = context.Instance.GetCommand <TCommand>();
if (request != null)
{
initializeContext = await MessageInitializerCache <TResult> .Initialize(initializeContext, request);
}
if (context.Message != null)
{
initializeContext = await MessageInitializerCache <TResult> .Initialize(initializeContext, context.Message);
}
// this is due to the way headers are propagated via the initializer
var values = _provider(context);
IMessageInitializer <TResult> initializer = MessageInitializerCache <TResult> .GetInitializer(values.GetType());
var result = await context.SendMessageToSubscriptions(subscriptions, initializer, initializeContext, values).ConfigureAwait(false);
if (result == null)
{
// initialize the message and save it as the response
InitializeContext <TResult> messageContext = await initializer.Initialize(initializeContext, values).ConfigureAwait(false);
result = messageContext.Message;
}
context.SetResult(context.Instance.CorrelationId, result);
}
public async Task SendFault(FutureConsumeContext <TInput> context, params FutureSubscription[] subscriptions)
{
InitializeContext <TFault> initializeContext;
if (context.Message is Fault fault)
{
var request = context.Instance.GetCommand <TCommand>();
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);
}
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);
}
}
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);
}
}
public InitializePropertyConverter()
{
_initializer = MessageInitializerCache <TProperty> .GetInitializer(typeof(TInput));
}