/// <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);
IMessageInitializer <T> 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);
}
}
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());
}
public Controller()
{
//message initializer and message publisher will be resolved by unity container
IMessageInitializer _messgageInitializer = null;
IMessagePublisher _messagePublisher = null;
messageInitializer = _messgageInitializer;
messagePublisher = _messagePublisher;
}
public Floor(IMessageInitializer _messgageInitializer, IMessagePublisher _messagePublisher, string channelName, int floorId, string floorName)
{
messageInitializer = _messgageInitializer;
messagePublisher = _messagePublisher;
ChannelName = channelName;
FloorId = floorId;
FloorName = floorName;
Initialize();
}
void IPipeSpecification <ExecuteContext <TMessage> > .Apply(IPipeBuilder <ExecuteContext <TMessage> > builder)
{
if (Count > 0)
{
IMessageInitializer <TMessage> initializer = Build();
builder.AddFilter(new TransformFilter <TMessage>(initializer));
}
}
public Elevator(IMessageInitializer _messgageInitializer, IMessagePublisher _messagePublisher, string channelName, int elevatorId, string elevatorName)
{
messageInitializer = _messgageInitializer;
messagePublisher = _messagePublisher;
ChannelName = channelName;
ElevatorId = elevatorId;
ElevatorName = elevatorName;
SelectedInFloors = new List <int>();
SelectedOutFloors = new List <int>();
Initialize();
}
public bool TryGetConsumeTopology(out IMessageConsumeTopology <TMessage> topology)
{
if (Count > 0)
{
IMessageInitializer <TMessage> initializer = Build();
topology = new MessageDataMessageConsumeTopology <TMessage>(initializer);
return(true);
}
topology = default;
return(false);
}
public static async Task <TMessage> InitializeMessage(PipeContext context, object values)
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
IMessageInitializer <TMessage> initializer = Cached.InitializerCache.GetInitializer(values.GetType());
InitializeContext <TMessage> initializeContext = await initializer.Initialize(initializer.Create(context), values).ConfigureAwait(false);
return(initializeContext.Message);
}
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 Task Send <T>(object values, CancellationToken cancellationToken)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
IMessageInitializer <T> initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
InitializeContext <T> context = GetInitializeContext(initializer, cancellationToken);
return(initializer.Send(this, context, values));
}
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));
}
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);
}
static IMessageInitializer <TMessage, TInput> CreateMessageInitializer <TInput>()
where TInput : class
{
var builder = new MessageInitializerBuilder <TMessage, TInput>();
var inspectors = CreatePropertyInspectors <TInput>().ToArray();
var convention = new CopyMessageInitializerConvention();
foreach (var inspector in inspectors)
{
inspector.Apply(builder, convention);
}
IMessageInitializer <TMessage, TInput> messageInitializer = builder.Build();
return(messageInitializer);
}
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);
}
protected IMessageInitializer <TMessage> Build()
{
IMessageFactory <TMessage> messageFactory = null;
IEnumerable <IInitializerConvention> conventions = Enumerable.Repeat <IInitializerConvention>(_convention, 1);
if (Replace)
{
messageFactory = new ReplaceMessageFactory <TMessage>();
}
else
{
conventions = conventions.Concat(MessageInitializer.Conventions);
}
var initializerFactory = new MessageInitializerFactory <TMessage, TMessage>(messageFactory, conventions.ToArray());
IMessageInitializer <TMessage> messageInitializer = initializerFactory.CreateMessageInitializer();
return(messageInitializer);
}
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);
}
public static async Task <T> SendMessageToSubscriptions <T>(this FutureConsumeContext context, IEnumerable <FutureSubscription> subscriptions,
IMessageInitializer <T> initializer, InitializeContext <T> initializeContext, object values)
where T : class
{
List <Task <T> > tasks = subscriptions.Select(async sub =>
{
var endpoint = await context.GetSendEndpoint(sub.Address).ConfigureAwait(false);
if (sub.RequestId.HasValue)
{
var pipe = new FutureResultPipe <T>(sub.RequestId.Value);
return(await initializer.Send(endpoint, initializeContext, values, pipe).ConfigureAwait(false));
}
return(await initializer.Send(endpoint, initializeContext, values).ConfigureAwait(false));
}).ToList();
T[] messages = await Task.WhenAll(tasks).ConfigureAwait(false);
return(messages.FirstOrDefault());
}
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);
}
}
public MessageDataMessageConsumeTopology(IMessageInitializer <T> initializer)
{
_transformFilter = new TransformFilter <T>(initializer);
}
public InitializePropertyConverter()
{
_initializer = MessageInitializerCache <TProperty> .GetInitializer(typeof(TInput));
}
public TransformPropertyConverter(IMessageInitializer <TProperty> initializer)
{
_initializer = initializer;
}
protected virtual InitializeContext <T> GetInitializeContext <T>(IMessageInitializer <T> initializer, CancellationToken cancellationToken)
where T : class
{
return(initializer.Create(cancellationToken));
}
public TransformFilter(IMessageInitializer <T> initializer)
{
_initializer = initializer;
}
void IPipeSpecification <SendContext <TMessage> > .Apply(IPipeBuilder <SendContext <TMessage> > builder)
{
IMessageInitializer <TMessage> initializer = Build();
builder.AddFilter(new TransformFilter <TMessage>(initializer));
}
protected override InitializeContext <T> GetInitializeContext <T>(IMessageInitializer <T> initializer, CancellationToken cancellationToken)
{
return(initializer.Create(_context));
}
