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); }