public ReceiveTransportHandle Start(IPipe<ReceiveContext> receivePipe) { if (_log.IsDebugEnabled) _log.DebugFormat("Starting receive transport: {0}", new Uri(_host.Settings.ServiceUri, _settings.QueueDescription.Path)); var supervisor = new TaskSupervisor($"{TypeMetadataCache<ServiceBusReceiveTransport>.ShortName} - {_host.Settings.GetInputAddress(_settings.QueueDescription)}"); IPipe<ConnectionContext> connectionPipe = Pipe.New<ConnectionContext>(x => { x.UseFilter(new PrepareReceiveQueueFilter(_settings, _subscriptionSettings)); if (_settings.QueueDescription.RequiresSession) { x.UseFilter(new MessageSessionReceiverFilter(receivePipe, _receiveObservers, _endpointObservers, supervisor)); } else { x.UseFilter(new MessageReceiverFilter(receivePipe, _receiveObservers, _endpointObservers, supervisor)); } }); Receiver(connectionPipe, supervisor); return new Handle(supervisor); }
Task SendUsingNewConnection(IPipe<OwinHostContext> connectionPipe, OwinHostScope scope, CancellationToken stoppingToken) { try { if (_cacheTaskScope.StoppingToken.IsCancellationRequested) throw new TaskCanceledException($"The connection is being disconnected: {_settings.ToDebugString()}"); if (_log.IsDebugEnabled) _log.DebugFormat("Connecting: {0}", _settings.ToDebugString()); if (_log.IsDebugEnabled) { _log.DebugFormat("Connected: {0} (address: {1}, local: {2}", _settings.ToDebugString(), _settings.Host, _settings.Port); } var hostContext = new HttpOwinHostContext(_settings, _cacheTaskScope); hostContext.GetOrAddPayload(() => _settings); scope.Connected(hostContext); } catch (Exception ex) { Interlocked.CompareExchange(ref _scope, null, scope); scope.ConnectFaulted(ex); throw new HttpConnectionException("Connect failed: " + _settings.ToDebugString(), ex); } return SendUsingExistingConnection(connectionPipe, scope, stoppingToken); }
public void ProcessHandshake(int TimeOut, ref IPipe pipe) { //usar un waithandle por cada tipo de handshake. //Estos waithandles seran liberados cuando la maquina de estados //alcance un estado que libere el wait handle. try { LogCurrentState(); LogSession.LogMessage("Processing Handshake @ WEIGHT Station..."); this.Workflow.Start(); //if (!this.Workflow.WaitForResult(TimeOut)) //{ // throw new TimeoutException("Timeout waiting for StableState"); //} LogSession.LogMessage("Weight Workflow Done"); this.Workflow.Reset(); } catch (Exception exception) { LogSession.LogException(exception); throw exception; } }
public Receiver(MessageReceiver messageReceiver, Uri inputAddress, IPipe<ReceiveContext> receivePipe, ReceiveSettings receiveSettings, IReceiveObserver receiveObserver, ITaskSupervisor supervisor) { _messageReceiver = messageReceiver; _inputAddress = inputAddress; _receivePipe = receivePipe; _receiveSettings = receiveSettings; _receiveObserver = receiveObserver; _supervisor = supervisor; _participant = supervisor.CreateParticipant(); var options = new OnMessageOptions { AutoComplete = false, AutoRenewTimeout = receiveSettings.AutoRenewTimeout, MaxConcurrentCalls = receiveSettings.MaxConcurrentCalls }; options.ExceptionReceived += (sender, x) => { if (_log.IsErrorEnabled) _log.Error($"Exception received on receiver: {_inputAddress} during {x.Action}", x.Exception); _participant.SetComplete(); }; messageReceiver.OnMessageAsync(OnMessage, options); _participant.SetReady(); SetupStopTask(); }
async void Receiver(IPipe<ConnectionContext> transportPipe, TaskSupervisor supervisor) { await Repeat.UntilCancelled(supervisor.StopToken, async () => { try { await _host.ConnectionCache.Send(transportPipe, supervisor.StopToken).ConfigureAwait(false); } catch (RabbitMqConnectionException ex) { if (_log.IsErrorEnabled) _log.ErrorFormat("RabbitMQ connection failed: {0}", ex.Message); var inputAddress = _host.Settings.GetInputAddress(_settings); await _endpointObservers.Faulted(new Faulted(inputAddress, ex)).ConfigureAwait(false); } catch (TaskCanceledException) { } catch (Exception ex) { if (_log.IsErrorEnabled) _log.ErrorFormat("RabbitMQ receive transport failed: {0}", ex.Message); var inputAddress = _host.Settings.GetInputAddress(_settings); await _endpointObservers.Faulted(new Faulted(inputAddress, ex)).ConfigureAwait(false); } }).ConfigureAwait(false); }
public void HandleMessage(object message, IPipe pipe) { lock (this) { this.lastMessage = message; } waiter.Set(); }
public PipeInstancesAddedEventArgs(IPipe[] pipes) { if (pipes == null) _Pipes = new IPipe[0]; else _Pipes = pipes; }
public void HandleMessage(object message, IPipe pipe) { //TODO handle message in another thread using a queue foreach (IHandler handler in handlers) { handler.HandleMessage(message, this); } }
/// <summary> /// Initializes a new instance of the <see cref="BroadcastStream"/> class. /// </summary> /// <param name="name">The stream name.</param> /// <param name="scope">The stream scope.</param> public BroadcastStream(String name, IScope scope) { _name = name; _scope = scope; _livePipe = null; // We want to create a video codec when we get our first video packet. _codecInfo = new StreamCodecInfo(); _creationTime = -1; }
Task SendUsingNewConnection(IPipe<ConnectionContext> connectionPipe, ConnectionScope scope, CancellationToken cancellationToken) { try { if (_cacheTaskScope.StoppingToken.IsCancellationRequested) throw new TaskCanceledException($"The connection is being disconnected: {_settings.ToDebugString()}"); if (_log.IsDebugEnabled) _log.DebugFormat("Connecting: {0}", _settings.ToDebugString()); IConnection connection; if (_settings.ClusterMembers?.Any() ?? false) { connection = _connectionFactory.CreateConnection(_settings.ClusterMembers, _settings.ClientProvidedName); } else { var hostNames = Enumerable.Repeat(_settings.Host, 1).ToList(); connection = _connectionFactory.CreateConnection(hostNames, _settings.ClientProvidedName); } if (_log.IsDebugEnabled) { _log.DebugFormat("Connected: {0} (address: {1}, local: {2}", _settings.ToDebugString(), connection.Endpoint, connection.LocalPort); } EventHandler<ShutdownEventArgs> connectionShutdown = null; connectionShutdown = (obj, reason) => { Interlocked.CompareExchange(ref _scope, null, scope); scope.Shutdown(reason.ReplyText); connection.ConnectionShutdown -= connectionShutdown; }; connection.ConnectionShutdown += connectionShutdown; var connectionContext = new RabbitMqConnectionContext(connection, _settings, _cacheTaskScope); connectionContext.GetOrAddPayload(() => _settings); scope.Connected(connectionContext); } catch (BrokerUnreachableException ex) { Interlocked.CompareExchange(ref _scope, null, scope); scope.ConnectFaulted(ex); throw new RabbitMqConnectionException("Connect failed: " + _settings.ToDebugString(), ex); } return SendUsingExistingConnection(connectionPipe, scope, cancellationToken); }
public static void AddPipe(IPipe pipe) { if (Pipeline.Any(existingPipe => existingPipe.GetType() == pipe.GetType())) { return; } Pipeline.Add(pipe); }
public static void AddPipe(IPipe pipe) { foreach( var existingPipe in _pipeline ) { if( existingPipe.GetType () == pipe.GetType () ) return; } _pipeline.Add (pipe); }
public void CopyToArrayCopiesZeroPipesToArrayIfNoneAreSelected() { Guid[] ids = InitializeTestEntries(3); IPipe[] arr = new IPipe[0]; _selected.CopyTo(arr, 0); Assert.Equal(0, arr.Length); }
/// <summary> /// Adds a RabbitMQ Basic Consumer to the pipeline /// </summary> /// <param name="configurator"></param> /// <param name="pipe"></param> /// <param name="settings"></param> /// <param name="receiveObserver"></param> /// <param name="endpointObserver"></param> /// <param name="exchangeBindings"></param> /// <param name="taskSupervisor"></param> /// <param name="mediator"></param> public static void RabbitMqConsumer(this IPipeConfigurator<ConnectionContext> configurator, IPipe<ReceiveContext> pipe, ReceiveSettings settings, IReceiveObserver receiveObserver, IReceiveEndpointObserver endpointObserver, IEnumerable<ExchangeBindingSettings> exchangeBindings, ITaskSupervisor taskSupervisor, Mediator<ISetPrefetchCount> mediator) { if (configurator == null) throw new ArgumentNullException(nameof(configurator)); var pipeBuilderConfigurator = new RabbitMqConsumerPipeSpecification(pipe, settings, receiveObserver, endpointObserver, exchangeBindings, taskSupervisor, mediator); configurator.AddPipeSpecification(pipeBuilderConfigurator); }
/// <summary> /// Rescue exceptions via the alternate pipe /// </summary> /// <param name="configurator"></param> /// <param name="rescuePipe"></param> public static void UseDeadLetterQueue(this IPipeConfigurator<ReceiveContext> configurator, IPipe<ReceiveContext> rescuePipe) { if (configurator == null) throw new ArgumentNullException(nameof(configurator)); var rescueConfigurator = new DeadLetterPipeSpecification(rescuePipe); configurator.AddPipeSpecification(rescueConfigurator); }
async Task SendUsingNewModel(IPipe<ModelContext> modelPipe, ModelScope scope, CancellationToken cancellationToken) { IPipe<ConnectionContext> connectionPipe = Pipe.ExecuteAsync<ConnectionContext>(async connectionContext => { IModel model = await connectionContext.CreateModel().ConfigureAwait(false); EventHandler<ShutdownEventArgs> modelShutdown = null; modelShutdown = (obj, reason) => { model.ModelShutdown -= modelShutdown; Interlocked.CompareExchange(ref _scope, null, scope); scope.Close(); }; model.ModelShutdown += modelShutdown; var modelContext = new RabbitMqModelContext(connectionContext, model, connectionContext.CancellationToken); scope.Connected(modelContext); try { using (SharedModelContext context = await scope.Attach(cancellationToken).ConfigureAwait(false)) { await modelPipe.Send(context).ConfigureAwait(false); } } catch (Exception ex) { if (_log.IsDebugEnabled) _log.Debug("The existing model usage threw an exception", ex); Interlocked.CompareExchange(ref _scope, null, scope); scope.Close(); throw; } }); try { await _connectionCache.Send(connectionPipe, new CancellationToken()).ConfigureAwait(false); } catch (Exception exception) { if (_log.IsDebugEnabled) _log.Debug("The connection threw an exception", exception); Interlocked.CompareExchange(ref _scope, null, scope); throw; } }
/// <summary> /// Rescue exceptions via the alternate pipe /// </summary> /// <typeparam name="T"></typeparam> /// <param name="configurator"></param> /// <param name="rescuePipe"></param> /// <param name="exceptionFilter"></param> public static void UseRescue(this IPipeConfigurator<ReceiveContext> configurator, IPipe<ExceptionReceiveContext> rescuePipe, IPolicyExceptionFilter exceptionFilter = null) { if (configurator == null) throw new ArgumentNullException(nameof(configurator)); var rescueConfigurator = new ReceiveContextRescuePipeSpecification(rescuePipe, exceptionFilter); configurator.AddPipeSpecification(rescueConfigurator); }
/// <summary> /// Start the receive transport, returning a Task that can be awaited to signal the transport has /// completely shutdown once the cancellation token is cancelled. /// </summary> /// <param name="receivePipe"></param> /// <returns>A task that is completed once the transport is shut down</returns> public ReceiveTransportHandle Start(IPipe<ReceiveContext> receivePipe) { var stopTokenSource = new CancellationTokenSource(); IPipe<ConnectionContext> pipe = Pipe.New<ConnectionContext>(x => x.RabbitMqConsumer(receivePipe, _settings, _receiveObservers, _endpointObservers, _exchangeBindings)); Task receiverTask = Receiver(pipe, stopTokenSource.Token); return new Handle(stopTokenSource, receiverTask); }
/// <summary> /// Adds a RabbitMQ Basic Consumer to the pipeline /// </summary> /// <param name="configurator"></param> /// <param name="pipe"></param> /// <param name="settings"></param> /// <param name="receiveObserver"></param> /// <param name="transportObserver"></param> /// <param name="exchangeBindings"></param> /// <param name="supervisor"></param> /// <param name="managementPipe"></param> /// <param name="sendEndpointProvider"></param> /// <param name="publishEndpointProvider"></param> /// <param name="host"></param> public static void RabbitMqConsumer(this IPipeConfigurator<ConnectionContext> configurator, IPipe<ReceiveContext> pipe, ReceiveSettings settings, IReceiveObserver receiveObserver, IReceiveTransportObserver transportObserver, IEnumerable<ExchangeBindingSettings> exchangeBindings, ITaskSupervisor supervisor, IManagementPipe managementPipe, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider, IRabbitMqHost host) { if (configurator == null) throw new ArgumentNullException(nameof(configurator)); var pipeBuilderConfigurator = new RabbitMqConsumerPipeSpecification(pipe, settings, receiveObserver, transportObserver, exchangeBindings, supervisor, managementPipe, sendEndpointProvider, publishEndpointProvider, host); configurator.AddPipeSpecification(pipeBuilderConfigurator); }
async Task SendUsingNewModel(IPipe<ModelContext> modelPipe, ModelScope scope, CancellationToken cancellationToken) { IPipe<ConnectionContext> connectionPipe = Pipe.ExecuteAsync<ConnectionContext>(async connectionContext => { try { if (_log.IsDebugEnabled) _log.DebugFormat("Creating model: {0}", connectionContext.HostSettings.ToDebugString()); var model = await connectionContext.CreateModel().ConfigureAwait(false); EventHandler<ShutdownEventArgs> modelShutdown = null; modelShutdown = (obj, reason) => { model.ModelShutdown -= modelShutdown; Interlocked.CompareExchange(ref _scope, null, scope); scope.Shutdown(reason.ReplyText); }; model.ModelShutdown += modelShutdown; var modelContext = new RabbitMqModelContext(connectionContext, model, _cacheTaskScope, _modelSettings); scope.Created(modelContext); } catch (Exception ex) { Interlocked.CompareExchange(ref _scope, null, scope); scope.CreateFaulted(ex); throw; } await SendUsingExistingModel(modelPipe, scope, cancellationToken).ConfigureAwait(false); }); try { await _connectionCache.Send(connectionPipe, _cacheTaskScope.StoppedToken).ConfigureAwait(false); } catch (Exception exception) { if (_log.IsDebugEnabled) _log.Debug("The connection threw an exception", exception); Interlocked.CompareExchange(ref _scope, null, scope); scope.CreateFaulted(exception); throw; } }
/// <summary> /// Start the receive transport, returning a Task that can be awaited to signal the transport has /// completely shutdown once the cancellation token is cancelled. /// </summary> /// <param name="receivePipe"></param> /// <returns>A task that is completed once the transport is shut down</returns> public ReceiveTransportHandle Start(IPipe<ReceiveContext> receivePipe) { var supervisor = new TaskSupervisor(); var pipe = Pipe.New<ConnectionContext>( x => x.RabbitMqConsumer(receivePipe, _settings, _receiveObservers, _endpointObservers, _exchangeBindings, supervisor)); Receiver(pipe, supervisor); return new Handle(supervisor); }
/// <summary> /// Start the receive transport, returning a Task that can be awaited to signal the transport has /// completely shutdown once the cancellation token is cancelled. /// </summary> /// <param name="receivePipe"></param> /// <returns>A task that is completed once the transport is shut down</returns> public ReceiveTransportHandle Start(IPipe<ReceiveContext> receivePipe) { var supervisor = new TaskSupervisor(); IPipe<ConnectionContext> pipe = Pipe.New<ConnectionContext>(x => { x.RabbitMqConsumer(receivePipe, _settings, _receiveObservable, _receiveEndpointObservable, _bindings, supervisor, _mediator); }); Receiver(pipe, supervisor); return new Handle(supervisor); }
/// <summary> /// Adds a RabbitMQ Basic Consumer to the pipeline /// </summary> /// <param name="configurator"></param> /// <param name="receivePipe"></param> /// <param name="settings"></param> /// <param name="receiveSettings"></param> /// <param name="receiveObserver"></param> /// <param name="receiveTransportObserver"></param> /// <param name="supervisor"></param> /// <param name="sendPipe"></param> public static void HttpConsumer(this IPipeConfigurator<OwinHostContext> configurator, IPipe<ReceiveContext> receivePipe, HttpHostSettings settings, ReceiveSettings receiveSettings, IReceiveObserver receiveObserver, IReceiveTransportObserver receiveTransportObserver, ITaskSupervisor supervisor, ISendPipe sendPipe) { if (configurator == null) throw new ArgumentNullException(nameof(configurator)); var pipeBuilderConfigurator = new HttpConsumerPipeSpecification(settings, receiveSettings, receivePipe, receiveObserver, receiveTransportObserver, supervisor, sendPipe); configurator.AddPipeSpecification(pipeBuilderConfigurator); }
public SessionReceiver(ClientContext clientContext, IPipe<ReceiveContext> receivePipe, ClientSettings clientSettings, ITaskSupervisor supervisor, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider) { _clientContext = clientContext; _receivePipe = receivePipe; _clientSettings = clientSettings; _supervisor = supervisor; _sendEndpointProvider = sendEndpointProvider; _publishEndpointProvider = publishEndpointProvider; _tracker = new DeliveryTracker(HandleDeliveryComplete); _participant = supervisor.CreateParticipant($"{TypeMetadataCache<Receiver>.ShortName} - {clientContext.InputAddress}", Stop); }
/// <summary> /// Start the receive transport, returning a Task that can be awaited to signal the transport has /// completely shutdown once the cancellation token is cancelled. /// </summary> /// <param name="receivePipe"></param> /// <returns>A task that is completed once the transport is shut down</returns> public ReceiveTransportHandle Start(IPipe<ReceiveContext> receivePipe) { var supervisor = new TaskSupervisor($"{TypeMetadataCache<RabbitMqReceiveTransport>.ShortName} - {_host.Settings.GetInputAddress(_settings)}"); IPipe<ConnectionContext> pipe = Pipe.New<ConnectionContext>(x => { x.RabbitMqConsumer(receivePipe, _settings, _receiveObservable, _receiveEndpointObservable, _bindings, supervisor, _managementPipe); }); Receiver(pipe, supervisor); return new Handle(supervisor); }
/// <summary> /// Initializes a new instance of the <see cref="MonitoringChannel" /> class. /// </summary> /// <param name="keyBuilder">Builds up the final metric key.</param> /// <param name="formatter">The message formatter.</param> /// <param name="pipe">The pipe.</param> public MonitoringChannel(Func<string, string> keyBuilder, IMessageFormatter formatter, IPipe pipe) { if (pipe == null) throw new ArgumentNullException("pipe"); if (formatter == null) throw new ArgumentNullException("formatter"); this.pipe = pipe; this.formatter = formatter; this.keyBuilder = keyBuilder ?? (Func<string, string>)((string k) => k); }
public ReceiveTransportHandle Start(IPipe<ReceiveContext> receivePipe) { var supervisor = new TaskSupervisor($"{TypeMetadataCache<HttpReceiveTransport>.ShortName} - {_host.Settings.GetInputAddress()}"); IPipe<OwinHostContext> hostPipe = Pipe.New<OwinHostContext>(cxt => { cxt.HttpConsumer(receivePipe, _host.Settings, _receiveSettings, _receiveObservable, _receiveTransportObservable, supervisor, _sendPipe); }); var hostTask = _host.OwinHostCache.Send(hostPipe, supervisor.StoppingToken); return new Handle(supervisor, hostTask); }
public void CopyToArrayCopiesSelectedPipesToArray() { Guid[] ids = InitializeTestEntries(3); Guid id2 = ids[2]; IPipe el2 = _pipes[id2]; _pipes[id2].SetIsSelected(true, SelectionSource.Code, SelectionOrigin.None); IPipe[] arr = new IPipe[1]; _selected.CopyTo(arr, 0); Assert.NotNull(arr[0]); Assert.Same(el2, arr[0]); }
/// <summary> /// The basic consumer receives messages pushed from the broker. /// </summary> /// <param name="model">The model context for the consumer</param> /// <param name="inputAddress">The input address for messages received by the consumer</param> /// <param name="receivePipe">The receive pipe to dispatch messages</param> /// <param name="receiveObserver">The observer for receive events</param> /// <param name="taskSupervisor">The token used to cancel/stop the consumer at shutdown</param> public RabbitMqBasicConsumer(ModelContext model, Uri inputAddress, IPipe<ReceiveContext> receivePipe, IReceiveObserver receiveObserver, ITaskSupervisor taskSupervisor) { _model = model; _inputAddress = inputAddress; _receivePipe = receivePipe; _receiveObserver = receiveObserver; _receiveSettings = model.GetPayload<ReceiveSettings>(); _pending = new ConcurrentDictionary<ulong, RabbitMqReceiveContext>(); _participant = taskSupervisor.CreateParticipant(); }
public PipeTransitioningGameState(ICamera camera, IPipe warpPipe, Game1 game) { this.game = game; prevGameState = game.gameState; this.warpPipe = warpPipe; this.camera = camera; WorldManager.ReturnPlayer().Physics.ResetX(); WorldManager.ReturnPlayer().Physics.ResetY(); controllerList = new List<IController>(); timer = IGameStateConstants.PIPETRANSITIONINGGAMESTATETIMER; controllerList.Add(new KeyboardController(new PausedControls(game))); controllerList.Add(new GamePadController(new PausedControls(game))); }
public Task Publish <T>(object values, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken = default(CancellationToken)) where T : class { throw new NotImplementedException(); }
public ConnectHandle ConnectConsumePipe <T>(IPipe <ConsumeContext <T> > pipe) where T : class { throw new NotImplementedException(); }
protected override void SendTelemetryCore(IPipe <TelemetryMessage> pipe) { SendTelemetryComponent(pipe, Args.Trainer); base.SendTelemetryCore(pipe); }
public ConnectHandle ConnectConsumePipe <T>(IPipe <ConsumeContext <T> > pipe) where T : class { return(_bus.ConnectConsumePipe(pipe)); }
public ConnectHandle ConnectRequestPipe <T>(Guid requestId, IPipe <ConsumeContext <T> > pipe) where T : class { return(_bus.ConnectRequestPipe(requestId, pipe)); }
public Task Publish <T>(T message, IPipe <PublishContext <T> > publishPipe, CancellationToken cancellationToken = default) where T : class { Add(() => _publishEndpoint.Publish(message, publishPipe, cancellationToken)); return(Task.CompletedTask); }
public TopicSendEndpointContextFactory(IConnectionContextSupervisor supervisor, IPipe <SendEndpointContext> pipe, SendSettings settings) : base(supervisor, pipe) { _settings = settings; }
public static Task Publish(IPublishEndpoint endpoint, object message, Type messageType, IPipe <PublishContext> pipe, CancellationToken cancellationToken = default(CancellationToken)) { return(Cached.Converters.Value[messageType].Publish(endpoint, message, pipe, cancellationToken)); }
public static Task Send <TInstance, TData>(this BehaviorContext <TInstance, TData> context, object message, IPipe <SendContext> sendPipe) { return(GetConsumeContext(context).Send(message, sendPipe)); }
public static Task Send <TInstance, TData, T>(this BehaviorContext <TInstance, TData> context, T message, IPipe <SendContext> sendPipe) where T : class { return(GetConsumeContext(context).Send(message, sendPipe)); }
async Task ISendTransport.Send <T>(T message, IPipe <SendContext <T> > pipe, CancellationToken cancellationToken) { if (IsStopped) { throw new TransportUnavailableException($"The send transport is stopped: {_entityName}"); } IPipe <ClientContext> modelPipe = Pipe.New <ClientContext>(p => { p.UseFilter(_filter); p.UseExecuteAsync(async clientContext => { var sendContext = new TransportAmazonSqsSendContext <T>(message, cancellationToken); try { await pipe.Send(sendContext).ConfigureAwait(false); var transportMessage = clientContext.CreateSendRequest(_entityName, sendContext.Body); transportMessage.MessageAttributes.Set(sendContext.Headers); if (!string.IsNullOrEmpty(sendContext.DeduplicationId)) { transportMessage.MessageDeduplicationId = sendContext.DeduplicationId; } if (!string.IsNullOrEmpty(sendContext.GroupId)) { transportMessage.MessageGroupId = sendContext.GroupId; } if (sendContext.DelaySeconds.HasValue) { transportMessage.DelaySeconds = sendContext.DelaySeconds.Value; } transportMessage.MessageAttributes.Set("Content-Type", sendContext.ContentType.MediaType); transportMessage.MessageAttributes.Set(nameof(sendContext.MessageId), sendContext.MessageId); transportMessage.MessageAttributes.Set(nameof(sendContext.CorrelationId), sendContext.CorrelationId); transportMessage.MessageAttributes.Set(nameof(sendContext.TimeToLive), sendContext.TimeToLive); await _observers.PreSend(sendContext).ConfigureAwait(false); await clientContext.SendMessage(transportMessage, sendContext.CancellationToken).ConfigureAwait(false); sendContext.LogSent(); await _observers.PostSend(sendContext).ConfigureAwait(false); } catch (Exception ex) { sendContext.LogFaulted(ex); await _observers.SendFault(sendContext, ex).ConfigureAwait(false); throw; } }); }); await _clientSource.Send(modelPipe, cancellationToken).ConfigureAwait(false); }
public MessageSendFilter(IEnumerable <IFilter <SendContext <TMessage> > > filters) { _outputPipe = BuildFilterPipe(filters.ToArray()); _messageObservers = new SendMessageObservable <TMessage>(); }
ConnectHandle ConnectStartJobConsumer(IConsumePipeConnector consumePipe, IConsumerSpecification <StartJobConsumer <TJob> > specification, JobOptions <TJob> options, IJobService jobService, IPipe <ConsumeContext <TJob> > pipe) { var consumerFactory = new DelegateConsumerFactory <StartJobConsumer <TJob> >(() => new StartJobConsumer <TJob>(jobService, options, pipe)); return(_startJobConsumerConnector.ConnectConsumer(consumePipe, consumerFactory, specification)); }
public Task Publish <T>(object values, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken = default) where T : class { Add(() => _publishEndpoint.Publish <T>(values, publishPipe, cancellationToken)); return(Task.CompletedTask); }
public async Task <ScheduledMessage <T> > ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, Task <T> message, IPipe <SendContext <T> > pipe, CancellationToken cancellationToken) where T : class { var messageId = NewId.NextGuid(); IPipe <SendContext <T> > delayPipe = Pipe.ExecuteAsync <SendContext <T> >(async context => { context.MessageId = messageId; var rabbitSendContext = context.GetPayload <RabbitMqSendContext>(); var delay = Math.Max(0, (scheduledTime.Kind == DateTimeKind.Local ? scheduledTime - DateTime.Now : scheduledTime - DateTime.UtcNow).TotalMilliseconds); if (delay > 0) { rabbitSendContext.SetTransportHeader("x-delay", (long)delay); } await pipe.Send(context).ConfigureAwait(false); }); var payload = await message.ConfigureAwait(false); var schedulerEndpoint = await GetSchedulerEndpoint(destinationAddress).ConfigureAwait(false); await schedulerEndpoint.Send(payload, delayPipe, cancellationToken).ConfigureAwait(false); return(new ScheduledMessageHandle <T>(messageId, scheduledTime, destinationAddress, payload)); }
public RequestConfigurator(IPipe <RequestContext> pipe) { _pipe = pipe; }
public Task Publish(object message, Type messageType, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken = default) { Add(() => _publishEndpoint.Publish(message, messageType, publishPipe, cancellationToken)); return(Task.CompletedTask); }
public Task Publish <T>(T message, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken) where T : class { return(PublishInternal(cancellationToken, message, publishPipe)); }
Task IPublishEndpoint.Publish(object message, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken) { return(_context.Publish(message, publishPipe, cancellationToken)); }
Task <ScheduledMessage <T> > IMessageScheduler.ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, T message, IPipe <SendContext> pipe, CancellationToken cancellationToken) { if (destinationAddress == null) { throw new ArgumentNullException(nameof(destinationAddress)); } if (message == null) { throw new ArgumentNullException(nameof(message)); } if (pipe == null) { throw new ArgumentNullException(nameof(pipe)); } var pipeProxy = new ScheduleMessageContextPipe <T>(pipe); return(ScheduleSend(destinationAddress, scheduledTime, message, pipeProxy, cancellationToken)); }
public ConnectHandle ConnectConsumePipe <T>(IPipe <ConsumeContext <T> > pipe, ConnectPipeOptions options) where T : class { return(_bus.ConnectConsumePipe(pipe, options)); }
Task IPublishEndpoint.Publish <T>(object values, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken) { return(_context.Publish <T>(values, publishPipe, cancellationToken)); }
public Task Publish(object message, Type messageType, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); }
public ServiceBusScheduleSendPipe(IPipe <SendContext <T> > pipe, DateTime scheduledTime) : base(pipe) { _scheduledTime = scheduledTime; }
public Task Publish(object message, Type messageType, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken) { return(PublishEndpointConverterCache.Publish(this, message, messageType, publishPipe, cancellationToken)); }
public Task Publish <T>(T message, IPipe <PublishContext> publishPipe, CancellationToken cancellationToken = default(CancellationToken)) where T : class { return(Task.CompletedTask); }
public PipeAdapter(IPipe <PublishContext <T> > pipe) { _pipe = pipe; }
public ConnectHandle ConnectRequestPipe <T>(Guid requestId, IPipe <ConsumeContext <T> > pipe) where T : class { throw new NotImplementedException(); }
public async Task Send(T message, IPipe <SendContext <T> > pipe, CancellationToken cancellationToken) { var sendEndpoint = await _context.GetSendEndpoint(_destinationAddress).ConfigureAwait(false); await sendEndpoint.Send(message, pipe, cancellationToken).ConfigureAwait(false); }
public ScheduleMessageContextPipe(IPipe <SendContext <T> > pipe) { _pipe = pipe; }