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