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