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 Execute(BehaviorContext <TInstance, TData> context, Behavior <TInstance, TData> next) { ConsumeEventContext <TInstance, TData> consumeContext = context.CreateConsumeContext(); InitializeContext <RequestStarted <TData> > initializeContext = await MessageInitializerCache <RequestStarted <TData> > .Initialize(new { context.Instance.CorrelationId, consumeContext.RequestId, consumeContext.ResponseAddress, consumeContext.FaultAddress, consumeContext.ExpirationTime, PayloadType = TypeMetadataCache <TData> .MessageTypeNames, Payload = context.Data }).ConfigureAwait(false); object message = initializeContext.Message; await consumeContext.Publish(message, typeof(RequestStarted)).ConfigureAwait(false); await next.Execute(context).ConfigureAwait(false); }
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 = 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)); } 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 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 async Task Should_initialize_object_with_readonly_property() { var model1 = new { ReadWrite = "Some Property Value" }; await MessageInitializerCache <ReadWriteReadOnly> .Initialize(model1); }