public virtual void TearDown()
{
Queue.Stop();
Queue = null;
Consumer.Dispose();
Consumer = null;
}
private void SetupMessaging(ISubscriber subscriber)
{
var storageReaderBus = new InMemoryBus("StorageReaderBus");
storageReaderBus.Subscribe <SystemMessage.SystemInit>(this);
storageReaderBus.Subscribe <SystemMessage.BecomeShuttingDown>(this);
storageReaderBus.Subscribe <ClientMessage.ReadEvent>(this);
storageReaderBus.Subscribe <ClientMessage.ReadStreamEventsBackward>(this);
storageReaderBus.Subscribe <ClientMessage.ReadStreamEventsForward>(this);
storageReaderBus.Subscribe <ClientMessage.ReadAllEventsForward>(this);
storageReaderBus.Subscribe <ClientMessage.ReadAllEventsBackward>(this);
storageReaderBus.Subscribe <ClientMessage.ListStreams>(this);
subscriber.Subscribe(this.WidenFrom <SystemMessage.SystemInit, Message>());
subscriber.Subscribe(this.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
subscriber.Subscribe(this.WidenFrom <ClientMessage.ReadEvent, Message>());
subscriber.Subscribe(this.WidenFrom <ClientMessage.ReadStreamEventsBackward, Message>());
subscriber.Subscribe(this.WidenFrom <ClientMessage.ReadStreamEventsForward, Message>());
subscriber.Subscribe(this.WidenFrom <ClientMessage.ReadAllEventsForward, Message>());
subscriber.Subscribe(this.WidenFrom <ClientMessage.ReadAllEventsBackward, Message>());
subscriber.Subscribe(this.WidenFrom <ClientMessage.ListStreams, Message>());
_storageReaderQueues = new QueuedHandler[_threadCount];
for (int i = 0; i < _threadCount; ++i)
{
var queue = new QueuedHandler(storageReaderBus, string.Format("StorageReaderQueue #{0}", i));
_storageReaderQueues[i] = queue;
queue.Start();
}
}
static void Main(string[] args)
{
var outputBus = new InMemoryBus("OutputBus");
var controller = new NodeController(outputBus);
var mainQueue = new QueuedHandler(controller, "Main Queue");
controller.SetMainQueue(mainQueue);
// Hello world service
var hello = new HelloWorldService(mainQueue);
outputBus.Subscribe<SystemMessage.SystemInit>(hello);
outputBus.Subscribe<SystemMessage.StartShutdown>(hello);
outputBus.Subscribe<HelloWorldMessage.Hi>(hello);
// TIMER
var timer = new TimerService(new ThreadBasedScheduler(new RealTimeProvider()));
outputBus.Subscribe<TimerMessage.Schedule>(timer);
Console.WriteLine("Starting everything. Press enter to initiate shutdown");
mainQueue.Start();
mainQueue.Publish(new SystemMessage.SystemInit());
Console.ReadLine();
mainQueue.Publish(new SystemMessage.StartShutdown());
Console.ReadLine();
}
protected override void Create()
{
base.Create();
var db = this.TfDb;
_coreInputBus = new InMemoryBus("bus");
_coreQueue = new QueuedHandler(_coreInputBus, "ProjectionCoreQueue");
_readerInputBus = new InMemoryBus("Reader Input");
_projectionNode = new ProjectionWorkerNode(db, _coreQueue, Node.HttpService);
_projectionNode.SetupMessaging(_coreInputBus, _readerInputBus);
_forwarder = new RequestResponseQueueForwarder(inputQueue: _coreQueue, externalRequestQueue: Node.MainQueue);
// forwarded messages
_projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEvent>(_forwarder);
_projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEventsBackwards>(_forwarder);
_projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEventsForward>(_forwarder);
_projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEventsFromTF>(_forwarder);
_projectionNode.CoreOutput.Subscribe <ClientMessage.WriteEvents>(_forwarder);
_coreInputBus.Subscribe(new UnwrapEnvelopeHandler());
Node.Bus.Subscribe(Forwarder.Create <SystemMessage.BecomeShuttingDown>(_coreQueue));
Node.Bus.Subscribe(Forwarder.Create <SystemMessage.SystemInit>(_coreQueue));
Node.Bus.Subscribe(Forwarder.Create <SystemMessage.SystemStart>(_coreQueue));
_projectionNode.CoreOutput.Subscribe(Node.TimerService);
_coreInputBus.Subscribe <SystemMessage.SystemStart>(this);
}
public void can_filter_out_message_types()
{
// server side
var serverInbound = new QueuedHandler(
new AdHocHandler <IMessage>(_tcs.SetResult),
"InboundMessageQueuedHandler",
true,
TimeSpan.FromMilliseconds(1000));
var tcpBusServerSide = new TcpBusServerSide(
_hostAddress,
port,
inboundNondiscardingMessageTypes: new[] { typeof(WoftamEvent) },
inboundNondiscardingMessageQueuedHandler: serverInbound);
serverInbound.Start();
// client side
var tcpBusClientSide = new TcpBusClientSide(_hostAddress, port);
// wait for tcp connection to be established
AssertEx.IsOrBecomesTrue(() => tcpBusClientSide.IsConnected, 200);
// put disallowed message into client
tcpBusClientSide.Handle(new WoftamCommand("abc"));
// expect to receive it in the server but drop it on the floor
var gotMessage = _tcs.Task.Wait(TimeSpan.FromMilliseconds(1000));
Assert.False(gotMessage);
tcpBusClientSide.Dispose();
tcpBusServerSide.Dispose();
}
public StorageWriter(IPublisher bus, ISubscriber subscriber, TFChunkWriter writer, IReadIndex readIndex)
{
Ensure.NotNull(bus, "bus");
Ensure.NotNull(subscriber, "subscriber");
Ensure.NotNull(writer, "writer");
Ensure.NotNull(readIndex, "readIndex");
Bus = bus;
_subscriber = subscriber;
ReadIndex = readIndex;
_flushDelay = 0;
_lastFlush = _watch.ElapsedTicks;
Writer = writer;
Writer.Open();
_writerBus = new InMemoryBus("StorageWriterBus", watchSlowMsg: true, slowMsgThresholdMs: 500);
_storageWriterQueue = new QueuedHandler(_writerBus, "StorageWriterQueue", watchSlowMsg: false);
_storageWriterQueue.Start();
SubscribeToMessage <SystemMessage.SystemInit>();
SubscribeToMessage <SystemMessage.BecomeShuttingDown>();
SubscribeToMessage <StorageMessage.WritePrepares>();
SubscribeToMessage <StorageMessage.WriteDelete>();
SubscribeToMessage <StorageMessage.WriteTransactionStart>();
SubscribeToMessage <StorageMessage.WriteTransactionData>();
SubscribeToMessage <StorageMessage.WriteTransactionPrepare>();
SubscribeToMessage <StorageMessage.WriteCommit>();
}
public Projections(
TFChunkDb db, QueuedHandler mainQueue, InMemoryBus mainBus, TimerService timerService,
HttpService httpService, int projectionWorkerThreadCount)
{
_projectionWorkerThreadCount = projectionWorkerThreadCount;
SetupMessaging(db, mainQueue, mainBus, timerService, httpService);
}
static void Main()
{
var bus = new TopicBasedPubSub();
var messageListener = new MessageListener(bus);
var startables = new List <IStartable>();
var midgetFactory = new MidgetFactory();
var midgetHouse = new MidgetHouse(bus, midgetFactory);
var consolePrinter = new QueuedHandler <OrderPaid>(Messages.Paid, new ConsolePrintingOrderHandler(bus));
bus.Subscribe(consolePrinter);
startables.Add(consolePrinter);
var cashier = new Cashier(bus);
var queuedCashier = new QueuedHandler <TakePayment>(Messages.OrderBilled, cashier);
bus.Subscribe(queuedCashier);
startables.Add(queuedCashier);
startables.Add(cashier);
var assistantManager = new QueuedHandler <PriceOrder>(Messages.OrderPrepared, new AssistantManager(bus));
bus.Subscribe(assistantManager);
startables.Add(assistantManager);
var chefs = new List <QueuedHandler <CookFood> >();
var rand = new Random();
for (int i = 0; i < NumberOfChefs; i++)
{
var chef = new TimeToLiveDispatcher <CookFood>(new Chef(bus, rand.Next(1000)));
var queuedHandler = new QueuedHandler <CookFood>(string.Format("Chef {0}", i), chef);
chefs.Add(queuedHandler);
startables.Add(queuedHandler);
}
var distributionStrategy = new QueuedDispatcher <CookFood>(bus, chefs);
startables.Add(distributionStrategy);
foreach (var startable in startables)
{
startable.Start();
}
var monitor = new Monitor(startables);
monitor.Start();
var waiter = new Waiter(bus);
for (int i = 0; i < 10; i++)
{
var correlationId = Guid.NewGuid();
var orderId = waiter.PlaceOrder(correlationId);
}
Console.ReadKey();
}
private void SetupMessaging(ISubscriber subscriber)
{
var storageWriterBus = new InMemoryBus("StorageWriterBus", watchSlowMsg: true, slowMsgThresholdMs: 500);
storageWriterBus.Subscribe <SystemMessage.SystemInit>(this);
storageWriterBus.Subscribe <SystemMessage.BecomeShuttingDown>(this);
storageWriterBus.Subscribe <ReplicationMessage.WritePrepares>(this);
storageWriterBus.Subscribe <ReplicationMessage.WriteDelete>(this);
storageWriterBus.Subscribe <ReplicationMessage.WriteTransactionStart>(this);
storageWriterBus.Subscribe <ReplicationMessage.WriteTransactionData>(this);
storageWriterBus.Subscribe <ReplicationMessage.WriteTransactionPrepare>(this);
storageWriterBus.Subscribe <ReplicationMessage.WriteCommit>(this);
storageWriterBus.Subscribe <ReplicationMessage.LogBulk>(this);
_storageWriterQueue = new QueuedHandler(storageWriterBus, "StorageWriterQueue", watchSlowMsg: false);
_storageWriterQueue.Start();
subscriber.Subscribe(this.WidenFrom <SystemMessage.SystemInit, Message>());
subscriber.Subscribe(this.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
subscriber.Subscribe(this.WidenFrom <ReplicationMessage.WritePrepares, Message>());
subscriber.Subscribe(this.WidenFrom <ReplicationMessage.WriteDelete, Message>());
subscriber.Subscribe(this.WidenFrom <ReplicationMessage.WriteTransactionStart, Message>());
subscriber.Subscribe(this.WidenFrom <ReplicationMessage.WriteTransactionData, Message>());
subscriber.Subscribe(this.WidenFrom <ReplicationMessage.WriteTransactionPrepare, Message>());
subscriber.Subscribe(this.WidenFrom <ReplicationMessage.WriteCommit, Message>());
subscriber.Subscribe(this.WidenFrom <ReplicationMessage.LogBulk, Message>());
}
public void Register(StandardComponents standardComponents)
{
_leaderInputQueue = QueuedHandler.CreateQueuedHandler(_leaderMainBus, "Projections Leader",
standardComponents.QueueStatsManager);
_leaderOutputBus = new InMemoryBus("ProjectionManagerAndCoreCoordinatorOutput");
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.RestartSubsystem>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.ComponentStarted>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.ComponentStopped>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.IODispatcherDrained>(this);
_leaderMainBus.Subscribe <SystemMessage.SystemCoreReady>(this);
_leaderMainBus.Subscribe <SystemMessage.StateChangeMessage>(this);
var projectionsStandardComponents = new ProjectionsStandardComponents(
_projectionWorkerThreadCount,
_runProjections,
_leaderOutputBus,
_leaderInputQueue,
_leaderMainBus, _faultOutOfOrderProjections);
CreateAwakerService(standardComponents);
_coreQueues =
ProjectionCoreWorkersNode.CreateCoreWorkers(standardComponents, projectionsStandardComponents);
_queueMap = _coreQueues.ToDictionary(v => v.Key, v => (IPublisher)v.Value);
ProjectionManagerNode.CreateManagerService(standardComponents, projectionsStandardComponents, _queueMap,
_projectionsQueryExpiry);
projectionsStandardComponents.LeaderMainBus.Subscribe <CoreProjectionStatusMessage.Stopped>(this);
projectionsStandardComponents.LeaderMainBus.Subscribe <CoreProjectionStatusMessage.Started>(this);
}
private void DispatchSingleMessage(IMessage message, QueueMessageDisptaching queueMessageDispatching)
{
var messageHandlerDataList = _handlerProvider.GetHandlers(message.GetType());
if (!messageHandlerDataList.Any())
{
queueMessageDispatching.OnMessageHandled(message);
return;
}
foreach (var messageHandlerData in messageHandlerDataList)
{
var singleMessageDispatching = new SingleMessageDisptaching(message, queueMessageDispatching, messageHandlerData.AllHandlers, _typeNameProvider);
if (messageHandlerData.ListHandlers != null && messageHandlerData.ListHandlers.IsNotEmpty())
{
foreach (var handler in messageHandlerData.ListHandlers)
{
DispatchSingleMessageToHandlerAsync(singleMessageDispatching, handler, null, 0);
}
}
if (messageHandlerData.QueuedHandlers != null && messageHandlerData.QueuedHandlers.IsNotEmpty())
{
var queueHandler = new QueuedHandler <IMessageHandlerProxy1>(messageHandlerData.QueuedHandlers, (queuedHandler, nextHandler) => DispatchSingleMessageToHandlerAsync(singleMessageDispatching, nextHandler, queuedHandler, 0));
DispatchSingleMessageToHandlerAsync(singleMessageDispatching, queueHandler.DequeueHandler(), queueHandler, 0);
}
}
}
public void SetMainQueue(QueuedHandler mainQueue)
{
Ensure.NotNull(mainQueue, "mainQueue");
_mainQueue = mainQueue;
_publishEnvelope = new PublishEnvelope(mainQueue);
}
public void while_queue_is_busy_should_crash_with_timeout()
{
var consumer = new WaitingConsumer(1);
var busyQueue = QueuedHandler.CreateQueuedHandler(consumer, "busy_test_queue", new QueueStatsManager(), watchSlowMsg: false,
threadStopWaitTimeout: TimeSpan.FromMilliseconds(100));
var waitHandle = new ManualResetEvent(false);
var handledEvent = new ManualResetEvent(false);
try {
busyQueue.Start();
busyQueue.Publish(new DeferredExecutionTestMessage(() => {
handledEvent.Set();
waitHandle.WaitOne();
}));
handledEvent.WaitOne();
Assert.Throws <TimeoutException>(() => busyQueue.Stop());
} finally {
waitHandle.Set();
consumer.Wait();
busyQueue.Stop();
waitHandle.Dispose();
handledEvent.Dispose();
consumer.Dispose();
}
}
public TcpOutboundMessageHandler(
IDispatcher messageBus,
QueuedHandler outboundMessageQueuedHandler)
{
_messageBus = messageBus;
_outboundMessageQueuedHandler = outboundMessageQueuedHandler;
_messageBus.Subscribe(this);
}
public TcpOutboundMessageHandler(
IGeneralBus messageBus,
QueuedHandler outboundMessageQueuedHandler)
{
_messageBus = messageBus;
_outboundMessageQueuedHandler = outboundMessageQueuedHandler;
_messageBus.Subscribe(this);
}
public void Register(
TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService,
ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendService)
{
_projections = new EventStore.Projections.Core.Projections(
db, mainQueue, mainBus, timerService, timeProvider, httpForwarder, httpServices, networkSendService,
projectionWorkerThreadCount: _projectionWorkerThreadCount, runProjections: _runProjections);
}
public ProjectionWorkerNode(TFChunkDb db, QueuedHandler inputQueue)
{
Ensure.NotNull(db, "db");
_coreOutput = new InMemoryBus("Core Output");
_projectionCoreService = new ProjectionCoreService(CoreOutput, inputQueue, 10, db.Config.WriterCheckpoint);
}
public void stoped_not_starting_server()
{
//GIVEN
var controller = new SleepTestController1();
var mainQueue = new QueuedHandler(controller, "Main Queue", 1000);
//WHEN
mainQueue.Stop();
}
protected ReadModelBase(string name, Func <IListener> getListener)
{
Ensure.NotNull(getListener, nameof(getListener));
_getListener = getListener;
_listeners = new List <IListener>();
_bus = new InMemoryBus($"{nameof(ReadModelBase)}:{name} bus", false);
_queue = new QueuedHandler(_bus, $"{nameof(ReadModelBase)}:{name} queue");
_queue.Start();
}
public static ProjectionManagerNode Create(TFChunkDb db, QueuedHandler inputQueue, HttpService httpService, IPublisher[] queues)
{
var projectionManagerNode =
new ProjectionManagerNode(inputQueue, queues, db.Config.WriterCheckpoint);
httpService.SetupController(new ProjectionsController(inputQueue));
return(projectionManagerNode);
}
public Projections(
TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider,
IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue,
int projectionWorkerThreadCount, RunProjections runProjections)
{
_projectionWorkerThreadCount = projectionWorkerThreadCount;
SetupMessaging(
db, mainQueue, mainBus, timerService, timeProvider, httpForwarder, httpServices, networkSendQueue,
runProjections);
}
/// <summary>
/// Creates a read model using the provided stream store connection. Reads existing events using a
/// reader, then transitions to a listener for live events.
/// </summary>
/// <param name="name">The name of the read model. Also used as the name of the listener and reader.</param>
/// <param name="connection">A connection to a stream store.</param>
protected ReadModelBase(string name, IConfiguredConnection connection)
{
Ensure.NotNull(connection, nameof(connection));
_getListener = () => connection.GetListener(name);
_getReader = () => connection.GetReader(name, Handle);
_listeners = new List <IListener>();
_bus = new InMemoryBus($"{nameof(ReadModelBase)}:{name} bus", false);
_queue = new QueuedHandler(_bus, $"{nameof(ReadModelBase)}:{name} queue");
_queue.Start();
}
public SynchronizableStreamListener(
string name,
ICatchupSteamSubscriber subscriptionTarget,
bool sync = false,
string busName = null) :
base(name, subscriptionTarget, busName)
{
Sync = sync;
SyncQueue = new QueuedHandler(this, "SyncListenerQueue");
}
public void multiple_start()
{
//GIVEN
var mainQueue = new QueuedHandler(null, "Main Queue");
mainQueue.Start();
//WHEN
mainQueue.Start();
}
static void Main()
{
var bus = new TopicBasedPubSub();
var messageListener = new MessageListener(bus);
var startables = new List<IStartable>();
var midgetFactory = new MidgetFactory();
var midgetHouse = new MidgetHouse(bus, midgetFactory);
var consolePrinter = new QueuedHandler<OrderPaid>(Messages.Paid, new ConsolePrintingOrderHandler(bus));
bus.Subscribe(consolePrinter);
startables.Add(consolePrinter);
var cashier = new Cashier(bus);
var queuedCashier = new QueuedHandler<TakePayment>(Messages.OrderBilled, cashier);
bus.Subscribe(queuedCashier);
startables.Add(queuedCashier);
startables.Add(cashier);
var assistantManager = new QueuedHandler<PriceOrder>(Messages.OrderPrepared, new AssistantManager(bus));
bus.Subscribe(assistantManager);
startables.Add(assistantManager);
var chefs = new List<QueuedHandler<CookFood>>();
var rand = new Random();
for (int i = 0; i < NumberOfChefs; i++)
{
var chef = new TimeToLiveDispatcher<CookFood>(new Chef(bus, rand.Next(1000)));
var queuedHandler = new QueuedHandler<CookFood>(string.Format("Chef {0}", i), chef);
chefs.Add(queuedHandler);
startables.Add(queuedHandler);
}
var distributionStrategy = new QueuedDispatcher<CookFood>(bus, chefs);
startables.Add(distributionStrategy);
foreach (var startable in startables)
{
startable.Start();
}
var monitor = new Monitor(startables);
monitor.Start();
var waiter = new Waiter(bus);
for (int i = 0; i < 10; i++)
{
var correlationId = Guid.NewGuid();
var orderId = waiter.PlaceOrder(correlationId);
}
Console.ReadKey();
}
public virtual void TestFixtureSetUp()
{
var _queue = QueuedHandler.CreateQueuedHandler(_bus, "TestQueuedHandler", new QueueStatsManager());
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_queue));
IODispatcherTestHelpers.SubscribeIODispatcher(_ioDispatcher, _bus);
_bus.Subscribe <ClientMessage.ReadStreamEventsForward>(this);
_bus.Subscribe <ClientMessage.ReadStreamEventsBackward>(this);
_bus.Subscribe <TimerMessage.Schedule>(this);
_queue.Start();
}
public void starting_stoped_server()
{
//GIVEN
var mainQueue = new QueuedHandler(null, "Main Queue");
mainQueue.Start();
Thread.Sleep(1000);
mainQueue.Stop();
//WHEN
mainQueue.Start();
}
public QueuedStreamListener(
string name,
IStreamStoreConnection connection,
IStreamNameBuilder streamNameBuilder,
IEventSerializer serializer,
string busName = null,
Action <Unit> liveProcessingStarted = null,
Action <SubscriptionDropReason, Exception> subscriptionDropped = null) :
base(name, connection, streamNameBuilder, serializer, busName, liveProcessingStarted, subscriptionDropped)
{
SyncQueue = new QueuedHandler(this, "SyncListenerQueue");
}
public static ProjectionManagerNode Create(
TFChunkDb db, QueuedHandler inputQueue, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue,
IPublisher[] queues, RunProjections runProjections)
{
var projectionManagerNode = new ProjectionManagerNode(inputQueue, queues, runProjections);
var projectionsController = new ProjectionsController(httpForwarder, inputQueue, networkSendQueue);
foreach (var httpService in httpServices)
{
httpService.SetupController(projectionsController);
}
return(projectionManagerNode);
}
public void throw_exception_on_timeout()
{
//GIVEN
var controller = new SleepTestController1();
var mainQueue = new QueuedHandler(controller, "Main Queue", 1000);
mainQueue.Start();
mainQueue.Enqueue(new QueuedTestMessage1());
//WHEN
Assert.AreEqual(false, controller.MessageHandled());
mainQueue.Stop();
}
public ProjectionsStandardComponents(
int projectionWorkerThreadCount,
ProjectionType runProjections,
InMemoryBus masterOutputBus,
QueuedHandler masterInputQueue,
InMemoryBus masterMainBus)
{
_projectionWorkerThreadCount = projectionWorkerThreadCount;
_runProjections = runProjections;
_masterOutputBus = masterOutputBus;
_masterInputQueue = masterInputQueue;
_masterMainBus = masterMainBus;
}
public TcpBusServerSide(
IPAddress hostIp,
int commandPort,
IEnumerable <Type> inboundDiscardingMessageTypes = null,
QueuedHandlerDiscarding inboundDiscardingMessageQueuedHandler = null,
IEnumerable <Type> inboundNondiscardingMessageTypes = null,
QueuedHandler inboundNondiscardingMessageQueuedHandler = null,
Dictionary <Type, IMessageSerializer> messageSerializers = null)
: base(
hostIp,
commandPort,
inboundDiscardingMessageTypes,
inboundDiscardingMessageQueuedHandler,
inboundNondiscardingMessageTypes,
inboundNondiscardingMessageQueuedHandler,
messageSerializers)
{
Log.Debug($"Configuring TCP Listener at {CommandEndpoint.AddressFamily}, {CommandEndpoint}.");
var listener = new TcpServerListener(CommandEndpoint);
listener.StartListening(
(endPoint, socket) =>
{
var connectionId = Guid.NewGuid();
var conn = TcpConnection.CreateAcceptedTcpConnection(connectionId, endPoint, socket, verbose: true);
var framer = new LengthPrefixMessageFramer();
framer.RegisterMessageArrivedCallback(TcpMessageArrived);
Action <ITcpConnection, IEnumerable <ArraySegment <byte> > > callback = null;
callback = (x, data) =>
{
try
{
framer.UnFrameData(x.ConnectionId, data);
}
catch (PackageFramingException exc)
{
Log.ErrorException(exc, "LengthPrefixMessageFramer.UnFrameData() threw an exception:");
return;
}
x.ReceiveAsync(callback);
};
conn.ReceiveAsync(callback);
AddConnection(conn);
},
"Standard");
Log.Debug($"TCP Listener at {CommandEndpoint.AddressFamily}, {CommandEndpoint} successfully configured.");
_commandPortListener = listener;
}
public static NodeEntryPoint StartWithOptions(NodeOptions options, Action<int> termination)
{
var slim = new ManualResetEventSlim(false);
var list = String.Join(Environment.NewLine,
options.GetPairs().Select(p => String.Format("{0} : {1}", p.Key, p.Value)));
Log.Info(list);
var bus = new InMemoryBus("OutputBus");
var controller = new NodeController(bus);
var mainQueue = new QueuedHandler(controller, "Main Queue");
controller.SetMainQueue(mainQueue);
Application.Start(i =>
{
slim.Set();
termination(i);
});
var http = new PlatformServerApiService(mainQueue, String.Format("http://{0}:{1}/", options.LocalHttpIp, options.HttpPort));
bus.Subscribe<SystemMessage.Init>(http);
bus.Subscribe<SystemMessage.StartShutdown>(http);
var timer = new TimerService(new ThreadBasedScheduler(new RealTimeProvider()));
bus.Subscribe<TimerMessage.Schedule>(timer);
// switch, based on configuration
AzureStoreConfiguration azureConfig;
if (AzureStoreConfiguration.TryParse(options.StoreLocation, out azureConfig))
{
var storageService = new AzureStorageService(azureConfig, mainQueue);
bus.Subscribe<ClientMessage.AppendEvents>(storageService);
bus.Subscribe<SystemMessage.Init>(storageService);
bus.Subscribe<ClientMessage.ImportEvents>(storageService);
bus.Subscribe<ClientMessage.RequestStoreReset>(storageService);
}
else
{
var storageService = new FileStorageService(options.StoreLocation, mainQueue);
bus.Subscribe<ClientMessage.AppendEvents>(storageService);
bus.Subscribe<SystemMessage.Init>(storageService);
bus.Subscribe<ClientMessage.ImportEvents>(storageService);
bus.Subscribe<ClientMessage.RequestStoreReset>(storageService);
}
mainQueue.Start();
mainQueue.Enqueue(new SystemMessage.Init());
return new NodeEntryPoint(mainQueue,slim);
}
static void Main(string[] args)
{
var bus = new Bus(new Dispatcher.Dispatcher());
var printers = new[] { new Printer(bus, 1), new Printer(bus, 2), new Printer(bus, 3), new Printer(bus, 4) };
var printerPool = printers
.Select(printer => new WideningHandler<PrintJob, Message>(printer))
.Select(printer => new QueuedHandler(printer, bus) { MaxQueueLength = 1 })
.ToArray();
var refillPool = printers
.Select(printer => new WideningHandler<RefillPaper, Message>(printer))
.Select(printer => new QueuedHandler(printer, bus) { MaxQueueLength = 1 })
.ToArray();
foreach (var printer in refillPool)
{
bus.Subscribe<RefillPaper>(new NarrowingHandler<RefillPaper, Message>(printer));
// subscribe the printer directly to RefillPaper as we don't want to distribute that with the print jobs
}
var office = Enumerable.Range(0, 50)
.Select(i => new Employee(bus, i))
.ToArray();
var loadBalancer = new RoundRobinLoadBalancer(printerPool);
var printerRetryHandler = new RetryHandler(loadBalancer, bus);
var retryManager = new RetryManager(bus);
var timerService = new TimerService(bus);
bus.Subscribe<FutureMessage>(timerService);
bus.Subscribe<RetryMessage>(retryManager);
bus.Subscribe<SuccessMessage>(retryManager);
bus.Subscribe(new NarrowingHandler<PrintJob, Message>(printerRetryHandler));
var console = new QueuedHandler(new WideningHandler<LogMessage, Message>(new ConsoleHandler()), bus);
bus.Subscribe<LogMessage>(new NarrowingHandler<LogMessage, Message>(console));
var porter = new Porter(bus);
bus.Subscribe(porter);
var converter = new LogConverter(bus);
bus.Subscribe<PrintJob>(converter);
bus.Subscribe<OutOfPaper>(converter);
bus.Subscribe<PagePrinted>(converter);
bus.Subscribe<RetryMessage>(converter);
}
public ReconnectionHandler Build()
{
var outputBus = new InMemoryBus("OutputBus");
var mainQueue = new QueuedHandler(outputBus, "Main Queue");
// TIMER
var timer = new TimerService(new ThreadBasedScheduler(new RealTimeProvider()));
outputBus.Subscribe(timer);
//ALERTER
var alerter = new Alerter();
outputBus.Subscribe<AlertReconnectingForTooLong>(alerter);
outputBus.Subscribe<AlertFalseAlarm>(alerter);
var connectionHandler = new ReconnectionHandler(mainQueue);
outputBus.Subscribe(connectionHandler);
mainQueue.Start();
return connectionHandler;
}
static void Main()
{
// this Client App uses a standard "Windows Forms" application as its host
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
#region This WinForms host uses its own in-memory message bus to manage the UI...
// It uses this in-memory bus to wire user-interface "UI" elements ("controls") to the
// logic (in controllers) that will be triggered when the user interacts with those elements.
// This allows us to send messages to the uiBus so that interested UI classes can
// subscribe to the messages they care about, and react to them
// when the bus publishes the messages to tell the UI controls what happened.
#endregion
var uiBus = new InMemoryBus("UI");
// .dat file to write Domain Events to this session
var fileToStoreEventsIn =
new FileAppendOnlyStore(new DirectoryInfo(Directory.GetCurrentDirectory()));
fileToStoreEventsIn.Initialize();
// provide serialization stuff for our file storage
var messageStore = new MessageStore(fileToStoreEventsIn);
messageStore.LoadDataContractsFromAssemblyOf(typeof(ActionDefined));
// this WinForm App's own local file-based event storage
var appEventStore = new AppEventStore(messageStore);
#region Does App care about this msg? This class controls the App's "main message loop"...
// It reads all msgs from in-memory queue (mainQueue below) and determines which messages
// the App will/will not handle at a given time (based on specific app state).
// For each queued message that it determines should be handled by
// uiBus subscribers, it passes the messages through to our in-memory uiBus,
// so bus subscribers can be called to react to the current message when the bus publishes it.
#endregion
var appController = new AppController(uiBus, appEventStore);
#region In-memory structure that all events we defined will go through...
// All domain & system messages we defined are captured
// and accumulated in this queue until some code picks up
// each message and processes it.
// (ex: AppController, declared above, will do that processing in this case).
#endregion
var mainQueue = new QueuedHandler(appController, "Main Queue");
appController.SetMainQueue(mainQueue);
appEventStore.SetDispatcher(mainQueue);
var provider = new ClientPerspective();
ClientModelController.WireTo(appEventStore, provider, uiBus, mainQueue);
// create services and bind them to the bus
// we wire all controls together in a native way.
// then we add adapters on top of that
var form = new MainForm();
var navigation = new NavigationView();
form.NavigationRegion.RegisterDock(navigation, "nav");
form.NavigationRegion.SwitchTo("nav");
LogController.Wire(form, uiBus);
#region View Controllers - Decoupling (UI) Views from their Controllers...
// The intent with this design was to enable us to
// write components or UI elements in a separated manner.
// Provide the ability to develop new functionality independently and
// it will sit in its own kind of "sandbox" so you can work on your stuff
// without impacting everyone else.
// It also sets us up for potential controller/code reuse and sharing in the future.
// The UI is broken down into kinda "SEDA standalone controllers"
// that communicate with each other via events. This event-driven
// separation allows for cleanly implementing logic like:
// "If the Inbox is selected, then only display these two menu items,
// but if a project is displayed, then display these additional menu items."
// See the Handle methods inside of MainFormController.cs for an example.
// Event-centric approaches are one of the nicest ways to build
// plug-in systems because plug-ins have services and contracts which are linked
// to behaviors (and in our case, these are events).
// Example: All CaptureThoughtController knows is that it gets handed a View
// that it controls (CaptureThoughtForm) and then it has two other injections points,
// a Bus and a MainQueue.
// See CaptureThoughtController for more comments on how this design works.
// The big idea here is that in the future, a controller can be passed an
// INTERFACE (say, ICaptureThoughtForm) INSTEAD OF a concrete Windows Forms
// implementation (CaptureThoughtForm) like it currently uses.
// So we may have a WPF form in the future that implements ICaptureThoughtForm
// and we could use that View implementation with the SAME CONTROLLER we already have.
// Very similar to how you could use the MVVM pattern with MvvmCross to
// reuse common code from the ViewModel down, but implement
// platform-specific Views on top of that common/shared code.
#endregion
#region Wiring up our Views to Controllers...
// A "Controller" or "Service" in this client-side ecosystem would usually
// define at least two parameters:
// MainQueue
// and
// "Bus"
// MainQueue is the place where it would send events that happen inside of it.
// Bus is what it subscribes to so that it will be called when specifc events happen.
// "Wire" is a static method defined on these controllers that our setup
// can call to let them know which form they control,
// the bus they can use as a source to subscribe to UI events to react to,
// and the target queue that they can use tell the rest of the world about events they generate.
#endregion
MainFormController.Wire(form, mainQueue, uiBus);
AddStuffToInboxController.Wire(new AddStuffToInboxForm(form), uiBus, mainQueue);
AddActionToProjectController.Wire(new AddActionToProjectForm(form),uiBus, mainQueue );
DefineProjectController.Wire(new DefineProjectForm(form), uiBus, mainQueue);
InboxController.Wire(form.MainRegion, mainQueue, uiBus, provider);
NavigationController.Wire(navigation, mainQueue, uiBus, provider);
ProjectController.Wire(form.MainRegion, mainQueue, uiBus, provider);
NavigateBackController.Wire(uiBus, mainQueue, form);
mainQueue.Enqueue(new AppInit());
mainQueue.Start();
Application.Run(form);
}
static void Main(string[] args)
{
var d = new Dispatcher();
var midgetHouse = new MidgetHouse(d);
d.Subscribe<OrderPlaced>(midgetHouse);
d.Subscribe<DodgyOrderPlaced>(midgetHouse);
var manager = new Manager();
var cashier = new Cashier(d);
var ass = new AssMan(d);
var cookDispatcher = new SmartDispatcher<CookFood>();
var cookTtlGate = new TimeToLiveGate<CookFood>(cookDispatcher);
var cookQueudHandler = new QueuedHandler<CookFood>(cookTtlGate, "cook ttl gate");
var cookLimiter = new Limiter<CookFood>(cookQueudHandler);
//var cookScrewsUp = new ScrewsUp<CookFood>(cookLimiter);
var alarmClock = new AlarmClock(d);
var messageMonitor = new MessageMonitor(d);
var fmm = new FilePerOrderMonitor(d);
d.Subscribe(alarmClock);
d.Subscribe(cookLimiter);
d.Subscribe(ass);
d.Subscribe(cashier);
d.Subscribe(manager);
d.Subscribe<OrderPlaced>(messageMonitor);
d.Subscribe<DodgyOrderPlaced>(messageMonitor);
d.Subscribe<OrderPlaced>(fmm);
d.Subscribe<DodgyOrderPlaced>(fmm);
var cookQueudHandler1 = new QueuedHandler<CookFood>(new Cook(d, 10000), "c1");
cookDispatcher.AddHandler(cookQueudHandler1);
var cookQueudHandler2 = new QueuedHandler<CookFood>(new Cook(d, 5000), "c2");
cookDispatcher.AddHandler(cookQueudHandler2);
var cookQueudHandler3 = new QueuedHandler<CookFood>(new Cook(d, 100), "c3");
cookDispatcher.AddHandler(cookQueudHandler3);
var queueMonitor = new QueueMonitor(new IAmMonitored[] {cookQueudHandler1, cookQueudHandler2, cookQueudHandler3, cookQueudHandler,d.QueudHandler});
//Cook cook = new Cook(ass);
var waiter = new Waiter(d);
cookQueudHandler1.Start();
cookQueudHandler2.Start();
cookQueudHandler3.Start();
cookQueudHandler.Start();
d.Start();
alarmClock.Start();
queueMonitor.Start();
new Thread(TryPay).Start(cashier);
Random r = new Random();
for (int i = 0; i < 500; i++)
{
Guid orderNumber;
if (r.Next()%2 == 0)
{
orderNumber = waiter.PlaceDodgyOrder(new[] {Tuple.Create("Burger", 1)}, 15);
}
else
{
orderNumber = waiter.PlaceOrder(new[] { Tuple.Create("Burger", 1) }, 15);
}
if(i > 2)Thread.Sleep(2000);
orders.TryAdd(orderNumber, null);
}
//var orderNumber = waiter.PlaceOrder(new[] {Tuple.Create("Burger", 1)}, 15);
//cashier.PayForOrder(orderNumber);
Console.ReadLine();
}
public NodeEntryPoint(QueuedHandler handler, ManualResetEventSlim exitWait)
{
_handler = handler;
_exitWait = exitWait;
}
