bool Disconnect(string key, IPipelineSink <T> sink) { return(_output.Set(sinks => { MessageRouter <T> router; if (sinks.TryGetValue(key, out router) == false) { return sinks; } var result = new Dictionary <string, MessageRouter <T> >(sinks); List <IPipelineSink <T> > outputSinks = router.Sinks.Where(x => x != sink).ToList(); if (outputSinks.Count == 0) { result.Remove(key); } else { result[key] = new MessageRouter <T>(outputSinks); } return result; }) != null); }
public OutboundMessageInterceptor(Func <IPipelineSink <ISendContext>, IPipelineSink <ISendContext> > insertAfter, IOutboundMessageInterceptor interceptor) { _interceptor = interceptor; _output = insertAfter(this); }
public UnsubscribeAction Connect(string key, IPipelineSink <T> sink) { _output.Set(sinks => { MessageRouter <T> router; if (sinks.TryGetValue(key, out router) == false) { router = new MessageRouter <T>(); router.Connect(sink); return(new Dictionary <string, MessageRouter <T> >(sinks) { { key, router } }); } var result = new Dictionary <string, MessageRouter <T> >(sinks); router = new MessageRouter <T>(router.Sinks); router.Connect(sink); result[key] = router; return(result); }); return(() => Disconnect(key, sink)); }
public static UnsubscribeAction ConnectToRouter <T>(this IPipelineSink <T> pipeline, IPipelineSink <T> sink, Func <bool> unsubscribe) where T : class { UnsubscribeAction result = pipeline.ConnectToRouter(sink); return(() => result() && unsubscribe()); }
public InboundMessageInterceptor(Func <IPipelineSink <IConsumeContext>, IPipelineSink <IConsumeContext> > insertAfter, IInboundMessageInterceptor interceptor) { _interceptor = interceptor; _output = insertAfter(this); }
public UnsubscribeAction Connect <TMessage>(IMessagePipeline pipeline, IPipelineSink <TMessage> sink) where TMessage : class { MessageRouterConfigurator routerConfigurator = For(pipeline); return(routerConfigurator.FindOrCreate <TMessage>().Connect(sink)); }
public UnsubscribeAction Connect(TKey correlationId, IPipelineSink <T> sink) { _output.Set(sinks => { CorrelatedMessageSinkRouter <T, TMessage, TKey> keySink; if (sinks.TryGetValue(correlationId, out keySink) == false) { keySink = new CorrelatedMessageSinkRouter <T, TMessage, TKey>(correlationId); keySink.Connect(sink); return(new Dictionary <TKey, CorrelatedMessageSinkRouter <T, TMessage, TKey> >(sinks) { { correlationId, keySink } }); } var result = new Dictionary <TKey, CorrelatedMessageSinkRouter <T, TMessage, TKey> >(sinks); keySink = new CorrelatedMessageSinkRouter <T, TMessage, TKey>(correlationId, keySink.Sinks); keySink.Connect(sink); result[correlationId] = keySink; return(result); }); return(() => Disconnect(correlationId, sink)); }
private static bool DisconnectIfEmpty(IDictionary <TKey, IPipelineSink <TMessage> > sinks, TKey correlationId) { IPipelineSink <TMessage> keySink = null; if (!sinks.TryGetValue(correlationId, out keySink)) { return(false); } CorrelatedMessageSinkRouter <TMessage, TKey> router = keySink as CorrelatedMessageSinkRouter <TMessage, TKey>; if (router == null) { return(false); } if (router.SinkCount != 0) { return(false); } sinks.Remove(correlationId); router.Dispose(); return(sinks.Count == 0); }
bool Disconnect(TKey correlationId, IPipelineSink <T> sink) { return(_output.Set(sinks => { CorrelatedMessageSinkRouter <T, TMessage, TKey> keySink; if (sinks.TryGetValue(correlationId, out keySink) == false) { return sinks; } var result = new Dictionary <TKey, CorrelatedMessageSinkRouter <T, TMessage, TKey> >(sinks); List <IPipelineSink <T> > outputSinks = keySink.Sinks.Where(x => x != sink).ToList(); if (outputSinks.Count == 0) { result.Remove(correlationId); } else { result[correlationId] = new CorrelatedMessageSinkRouter <T, TMessage, TKey>(correlationId, outputSinks); } return result; }) != null); }
private UnsubscribeAction ConnectTo <TMessage>(DataEvent <TSaga, TMessage> eevent, IEnumerable <State> states) where TMessage : class { var factory = new SagaStateMachineMessageSinkFactory <TSaga, TMessage>(_context, _policyFactory); IPipelineSink <TMessage> sink = factory.Create(eevent, states); return(_context.Pipeline.ConnectToRouter(sink, () => _context.SubscribedTo <TMessage>())); }
public IPipelineSink <TOutput> ReplaceOutputSink(IPipelineSink <TOutput> sink) { IPipelineSink <TOutput> result = _outputSink; _outputSink = sink; return(result); }
public static UnsubscribeAction Connect <TOutput>(this IOutboundMessagePipeline pipeline, IPipelineSink <IBusPublishContext <TOutput> > sink) where TOutput : class { var routerConfigurator = new OutboundMessageRouterConfigurator(pipeline); return(routerConfigurator.FindOrCreate <TOutput>().Connect(sink)); }
public bool Inspect <TMessage>(IPipelineSink <TMessage> sink) where TMessage : class { Append(string.Format("Unknown Message Sink {0} ({1})", sink.GetType().ToFriendlyName(), typeof(TMessage).ToFriendlyName())); return(true); }
public static void Trace <T>(IPipelineSink <T> pipeline, Action <string> callback) where T : class { var viewer = new PipelineViewer(); pipeline.Inspect(viewer); callback(viewer.Text); }
public UnsubscribeAction Connect(IPipelineSink <T> sink) { _output.Set(sinks => new List <IPipelineSink <T> >(sinks) { sink }); return(() => _output.Set(sinks => sinks.Where(x => x != sink).ToList()) != null); }
public static void Trace <T>(IPipelineSink <T> pipeline) where T : class { var viewer = new PipelineViewer(); pipeline.Inspect(viewer); System.Diagnostics.Trace.WriteLine(viewer.Text); }
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, IWorker worker) { IWorkerLoad <TMessage> workerLoad = worker.GetWorkerLoad <TMessage>(); IPipelineSink <IConsumeContext <TMessage> > consumerSink = GetConsumerSink(_consumerFactory); var sink = new WorkerMessageSink <TMessage>(workerLoad, consumerSink); return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <Distributed <TMessage> >())); }
private UnsubscribeAction ConnectToSink <TSaga, TMessage>(ISubscriberContext context, ISagaWorker <TSaga> worker, DataEvent <TSaga, TMessage> eevent, IEnumerable <State> states) where TSaga : SagaStateMachine <TSaga>, ISaga where TMessage : class { var factory = new SagaStateMachineMessageSinkFactory <TSaga, TMessage>(context, _policyFactory); IPipelineSink <TMessage> sink = factory.Create(eevent, states); var workerSink = new SagaWorkerMessageSink <TSaga, TMessage>(worker, sink); return(context.Pipeline.ConnectToRouter(workerSink, () => context.SubscribedTo <Distributed <TMessage> >())); }
private static void SendMessages(IPipelineSink <object> sink, int primeLoopCount) { for (int i = 0; i < primeLoopCount; i++) { var message = new PingMessage(); foreach (var item in sink.Enumerate(message)) { item(message); } } }
public static UnsubscribeAction ConnectToRouter <TOutput>(this IPipelineSink <ISendContext> pipeline, IPipelineSink <IBusPublishContext <TOutput> > sink) where TOutput : class { var routerConfigurator = new OutboundMessageRouterConfigurator(pipeline); MessageRouter <IBusPublishContext <TOutput> > router = routerConfigurator.FindOrCreate <TOutput>(); UnsubscribeAction result = router.Connect(sink); return(() => result() && (router.SinkCount == 0)); }
private static UnsubscribeAction ConnectToRouter <T, V>(this IPipelineSink <V> pipeline, IPipelineSink <T> sink) where T : class where V : class { MessageRouterConfigurator routerConfigurator = MessageRouterConfigurator.For(pipeline); MessageRouter <T> router = routerConfigurator.FindOrCreate <T>(); UnsubscribeAction result = router.Connect(sink); return(() => result() && (router.SinkCount == 0)); }
private static void SendMessages(IPipelineSink <IConsumeContext> sink, int primeLoopCount) { var message = new PingMessage(); var context = new ConsumeContext <PingMessage>(ReceiveContext.Empty(), message); for (int i = 0; i < primeLoopCount; i++) { foreach (var item in sink.Enumerate(context)) { item(context); } } }
public static UnsubscribeAction ConnectToRouter <TOutput>(this IInboundMessagePipeline pipeline, IPipelineSink <IConsumeContext <TOutput> > sink, Func <UnsubscribeAction> subscribedTo) where TOutput : class { var routerConfigurator = new InboundMessageRouterConfigurator(pipeline); MessageRouter <IConsumeContext <TOutput> > router = routerConfigurator.FindOrCreate <TOutput>(); UnsubscribeAction result = router.Connect(sink); UnsubscribeAction remove = subscribedTo(); return(() => result() && (router.SinkCount == 0) && remove()); }
protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { if (_outputSink != null) { _outputSink.Dispose(); _outputSink = null; } } _disposed = true; }
public void Nested_router_performance_measurement() { IPipelineSink <object> router = SetupTwoRoutersOnly(); const int primeLoopCount = 10; SendMessages(router, primeLoopCount); Stopwatch timer = Stopwatch.StartNew(); const int loopCount = 1500000; SendMessages(router, loopCount); timer.Stop(); Trace.WriteLine("Elapsed Time: " + timer.ElapsedMilliseconds + "ms"); Trace.WriteLine("Messages Per Second: " + loopCount * 1000 / timer.ElapsedMilliseconds); }
public override IEnumerable <Action <TMessage> > Enumerate(TMessage message) { IPipelineSink <TMessage> sink = null; _sinks.UpgradeableReadLock(x => { if (x.TryGetValue(message.BatchId, out sink) == false) { _sinks.WriteLock(y => { if (x.TryGetValue(message.BatchId, out sink) == false) { _log.Debug("Adding a new message router for batchId " + message.BatchId); var batchMessage = new Batch <TMessage, TBatchId>(message.BatchId, message.BatchLength, null); // we need to create a sink for this batch and get it wired up var router = new MessageRouter <TMessage>(); foreach (var messageSink in _consumerSinks.ReadLock(z => z)) { foreach (var consumes in messageSink.Enumerate(batchMessage)) { router.Connect(new BatchCombiner <TMessage, TBatchId>(message.BatchId, message.BatchLength, consumes)); } } x.Add(message.BatchId, router); sink = router; } }); } }); if (sink == null) { yield break; } foreach (var consumer in sink.Enumerate(message)) { yield return(consumer); } }
protected IEnumerable <Action <TMessage> > EnumerateSinks(TMessage message, TKey batchId) { IPipelineSink <TMessage> sink = null; if (_sinks.ReadLock(x => x.TryGetValue(batchId, out sink)) == false) { yield break; } if (sink == null) { yield break; } foreach (var consumer in sink.Enumerate(message)) { yield return(consumer); } }
public UnsubscribeAction Connect(TKey correlationId, IPipelineSink <TMessage> sink) { IPipelineSink <TMessage> keySink = null; if (_sinks.ReadLock(x => x.TryGetValue(correlationId, out keySink)) == false) { // we need to add the sink if it doesn't exist _sinks.WriteLock(x => { if (x.TryGetValue(correlationId, out keySink) == false) { MessageRouter <TMessage> keyRouter = new CorrelatedMessageSinkRouter <TMessage, TKey>(correlationId); x.Add(correlationId, keyRouter); keySink = keyRouter; } }); } return(keySink.ConnectToRouter(sink, () => _sinks.WriteLock(x => DisconnectIfEmpty(x, correlationId)))); }
public static MessageRouterConfigurator For <TMessage>(IPipelineSink <TMessage> sink) where TMessage : class { return(new MessageRouterConfigurator(sink)); }
public static MessageRouterConfigurator For(IPipelineSink <object> sink) { return(new MessageRouterConfigurator(sink)); }
public IPipelineSink<ISendContext> ReplaceOutputSink(IPipelineSink<ISendContext> sink) { return _output.Set(output => sink); }
public OutboundMessagePipeline(IPipelineSink<ISendContext> output) { _output = Atomic.Create(output); }
public OutboundMessageInterceptorConfigurator(IPipelineSink<ISendContext> sink) { _sink = sink; }
public ILinearPipeline Build(IPipelineSource soruceUnit, IList<IPipelineIntermediate> intermediatesUnit, IPipelineSink sinkUnit) { var unitsList = GetNewLinearPipeline(soruceUnit, intermediatesUnit, sinkUnit); linker.Link(unitsList); return new LinearPipeline(unitsList); }