//protected override System.Web.Http.Dependencies.IDependencyResolver BuildWebApiDependencyResolver()
//{
// //get the 'default' resolver, populated from the 'main' config metadata
// var resolver = base.BuildWebApiDependencyResolver();
// //check if its castable to a SpringWebApiDependencyResolver
// var springResolver = resolver as SpringWebApiDependencyResolver;
// //return the fully-configured resolver
// return springResolver;
//}
/// <summary>
/// Method for initializaing the single threaded application parts
/// </summary>
private void InitiliazeApplication()
{
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
IEventStore inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
IEventStore outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
Journaler inputJournaler = new Journaler(inputEventStore);
Journaler outputJournaler = new Journaler(outputEventStore);
ExchangeEssentialsList exchangeEssentialsList=outputEventStore.LoadLastSnapshot();
ICurrencyPairRepository currencyPairRepository = (ICurrencyPairRepository) ContextRegistry.GetContext()["CurrencyPairRepository"];
IList<CurrencyPair> tradeableCurrencyPairs = currencyPairRepository.GetTradeableCurrencyPairs();
Exchange exchange;
if (exchangeEssentialsList != null)
{
//means snapshot found so initialize the exchange
exchange = new Exchange(tradeableCurrencyPairs, exchangeEssentialsList);
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler<InputPayload>[] {exchange, inputJournaler});
OutputDisruptor.InitializeDisruptor(new IEventHandler<byte[]>[] {outputJournaler});
exchange.InitializeExchangeAfterSnaphot();
LimitOrderBookReplayService service = new LimitOrderBookReplayService();
service.ReplayOrderBooks(exchange, outputJournaler);
exchange.EnableSnaphots(Constants.SnaphsortInterval);
}
else
{
//no snapshot found
exchange = new Exchange(tradeableCurrencyPairs);
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler<InputPayload>[] { exchange, inputJournaler });
OutputDisruptor.InitializeDisruptor(new IEventHandler<byte[]>[] { outputJournaler });
// check if there are events to replay
LimitOrderBookReplayService service = new LimitOrderBookReplayService();
service.ReplayOrderBooks(exchange, outputJournaler);
exchange.EnableSnaphots(Constants.SnaphsortInterval);
}
}
private void PublishOrdersAfterReplay()
{
string currencyPair = "XBTUSD";
Order order1 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1));
Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2));
Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 405, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3));
Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 100, 407, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4));
Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 409, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5));
Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 413, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6));
ManualResetEvent resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne(10000);
}
private void CrashAndInitializeAgainWithSnapshot()
{
//crash
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
_exchange.StopTimer();
inputEventStore.ShutDown();
outputEventStore.ShutDown();
inputJournaler.ShutDown();
outputJournaler.ShutDown();
ContextRegistry.Clear();
//initialize
inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
inputJournaler = new Journaler(inputEventStore);
outputJournaler = new Journaler(outputEventStore);
_applicationContext = ContextRegistry.GetContext();
IList <CurrencyPair> currencyPairs = new List <CurrencyPair>();
currencyPairs.Add(new CurrencyPair("BTCUSD", "USD", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCLTC", "LTC", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCDOGE", "DOGE", "BTC"));
_exchange = new Exchange(currencyPairs, outputEventStore.LoadLastSnapshot());
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler <InputPayload>[] { _exchange, inputJournaler });
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { outputJournaler });
_exchange.InitializeExchangeAfterSnaphot();
LimitOrderBookReplayService service = new LimitOrderBookReplayService();
service.ReplayOrderBooks(_exchange, outputJournaler);
_exchange.EnableSnaphots(5000);
ManualResetEvent resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne(20000);
}
public new void TearDown()
{
_databaseUtility.Create();
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
inputEventStore.RemoveAllEvents();
outputEventStore.RemoveAllEvents();
}
public void TearDown()
{
_exchange.StopTimer();
_databaseUtility.Create();
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
inputEventStore.RemoveAllEvents();
outputEventStore.RemoveAllEvents();
}
public void TearDown()
{
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
ContextRegistry.Clear();
_databaseUtility.Create();
inputEventStore.RemoveAllEvents();
outputEventStore.RemoveAllEvents();
}
public void SetUp()
{
//initialize journaler
_eventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
Journaler journaler = new Journaler(_eventStore);
//assign journaler to disruptor as its consumer
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler <InputPayload>[] { journaler });
_manualResetEvent = new ManualResetEvent(false);
}
public void PublishCancelOrder_IfCancelOrderIsAddedInPayload_ReceiveCancelOrderInPayloadInConsumer()
{
_counter = 1;//as sending only one message
OrderCancellation cancelOrder = new OrderCancellation(new OrderId("123"), new TraderId("123"), "XBTUSD");
InputPayload payload = InputPayload.CreatePayload(cancelOrder);
InputDisruptorPublisher.Publish(payload);
_manualResetEvent.WaitOne(2000);
Assert.AreEqual(payload.OrderCancellation, cancelOrder);
}
public void PublishOrder_IfOrderIsAddedInPayload_ReceiveOrderInPayloadInConsumer()
{
_counter = 1;//as sending only one message
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
InputPayload payload = InputPayload.CreatePayload(order);
InputDisruptorPublisher.Publish(payload);
_manualResetEvent.WaitOne(2000);
Assert.AreEqual(payload.Order, order);
}
private void Scenario1()
{
string currencyPair = "XBTUSD";
Order order1 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 400, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1));
Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 401, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2));
Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 402, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3));
Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 103, 403, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4));
Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 104, 404, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5));
Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 105, 405, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6));
Order order7 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 106, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order7));
Order order8 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 100, 410, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order8));
Order order9 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 101, 409, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order9));
Order order10 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 102, 407, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order10));
Order order11 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 103, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order11));
Order order12 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 104, 405, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order12));
Order order13 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 105, 411, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order13));
Order order14 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 106, 412, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order14));
Order order15 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 107, 400, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order15));
ManualResetEvent resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne(20000);
}
public void CreateAndLogOrder_GetAllTheOrdersBackFromTheEventStore_CheckIfOrderIsRetreivedProperly()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
InputPayload payload = InputPayload.CreatePayload(order);
InputDisruptorPublisher.Publish(payload);
_manualResetEvent.WaitOne(5000);
//retrieve order
Order savedOrder = _eventStore.GetEvent(order.OrderId.Id.ToString()) as Order;
Assert.NotNull(savedOrder);
Assert.AreEqual(savedOrder, order);
}
public void CreateOrder_PublishToInputDisruptor_JournalerShouldSaveTheEvent()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
InputPayload payload = InputPayload.CreatePayload(order);
InputDisruptorPublisher.Publish(payload);
_manualResetEvent.WaitOne(5000);
//retrieve order
Order savedOrder = _eventStore.GetEvent(order.OrderId.Id.ToString()) as Order;
Assert.NotNull(savedOrder);
Assert.AreEqual(savedOrder, order);
}
public void PublishOrders_ToCheckPayloadRefrenceDoesnotGetMixed_AllOrdersReceived()
{
_counter = 14;//as sending 15 messages
List <string> list = new List <string>();
for (int i = 1; i < 15; i++)
{
Order order = OrderFactory.CreateOrder(i.ToString(), "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
InputPayload payload = InputPayload.CreatePayload(order);
InputDisruptorPublisher.Publish(payload);
list.Add(i.ToString(CultureInfo.InvariantCulture));
}
_manualResetEvent.WaitOne(10000);
Assert.AreEqual(CompareList(list), true);
}
public NewOrderRepresentation CreateOrder(CreateOrderCommand orderCommand)
{
IOrderIdGenerator orderIdGenerator = ContextRegistry.GetContext()["OrderIdGenerator"] as IOrderIdGenerator;
Tuple <string, string> splittedCurrencyPairs = CurrencySplitterService.SplitCurrencyPair(orderCommand.Pair);
Order order = OrderFactory.CreateOrder(orderCommand.TraderId, orderCommand.Pair,
orderCommand.Type, orderCommand.Side, orderCommand.Volume, orderCommand.Price, orderIdGenerator);
if (_balanceValidationService.FundsConfirmation(order.TraderId.Id, splittedCurrencyPairs.Item1,
splittedCurrencyPairs.Item2, order.Volume.Value, order.Price.Value, order.OrderSide.ToString(),
order.OrderId.Id))
{
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order));
return(new NewOrderRepresentation(order));
}
throw new InvalidOperationException("Not Enough Balance for Trader with ID: " + orderCommand.TraderId);
}
public CancelOrderResponse CancelOrder(CancelOrderCommand cancelOrderCommand)
{
try
{
// Verify cancel order command
if (_commandValidationService.ValidateCancelOrderCommand(cancelOrderCommand))
{
string currencyPair = _commandValidationService.GetCurrencyPair(cancelOrderCommand.OrderId);
OrderCancellation cancellation = new OrderCancellation(cancelOrderCommand.OrderId,
cancelOrderCommand.TraderId, currencyPair);
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(cancellation));
return(new CancelOrderResponse(true, "Cancel Request Accepted"));
}
return(new CancelOrderResponse(false, new InvalidDataException("Invalid orderid").ToString()));
}
catch (Exception exception)
{
return(new CancelOrderResponse(false, exception.Message));
}
}
public void SetUp()
{
var connection = ConfigurationManager.ConnectionStrings["MySql"].ToString();
_databaseUtility = new DatabaseUtility(connection);
_databaseUtility.Create();
_databaseUtility.Populate();
inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
inputJournaler = new Journaler(inputEventStore);
outputJournaler = new Journaler(outputEventStore);
IList <CurrencyPair> currencyPairs = new List <CurrencyPair>();
currencyPairs.Add(new CurrencyPair("BTCUSD", "USD", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCLTC", "LTC", "BTC"));
currencyPairs.Add(new CurrencyPair("BTCDOGE", "DOGE", "BTC"));
_exchange = new Exchange(currencyPairs);
_exchange.EnableSnaphots(5000);
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler <InputPayload>[] { _exchange, inputJournaler });
OutputDisruptor.InitializeDisruptor(new IEventHandler <byte[]>[] { outputJournaler });
}
public void TearDown()
{
InputDisruptorPublisher.Shutdown();
_eventStore.RemoveAllEvents();
}
public void Setup()
{
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler <InputPayload>[] { this });
_manualResetEvent = new ManualResetEvent(false);
_receivedTraderId = new List <string>();
}
public void GetTradeDetails_SendMatchingOrdersWithDifferentTraders_TradeDetailsShouldGetReceived()
{
// Get the context
IApplicationContext applicationContext = ContextRegistry.GetContext();
// Get the instance through Spring configuration
TradeController tradeController = (TradeController)applicationContext["TradeController"];
tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController.Request.Headers.Add("Auth", "123456789");
// Get the instance through Spring configuration
OrderController orderController = (OrderController)applicationContext["OrderController"];
orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController.Request.Headers.Add("Auth", "123456789");
ITradeRepository tradeRepository = (ITradeRepository)applicationContext["TradeRepository"];
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 491,
Volume = 100,
Side = "buy",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
OrderController orderController1 = (OrderController)applicationContext["OrderController"];
orderController1.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController1.Request.Headers.Add("Auth", "55555");
orderController1.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 490,
Volume = 300,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(4000);
IHttpActionResult httpActionResult = tradeController.GetTradeHistory(new TradeHistoryParams("", ""));
OkNegotiatedContentResult <object> okResponseObject = (OkNegotiatedContentResult <object>)httpActionResult;
IList <object> objectList = (IList <object>)okResponseObject.Content;
object[] details = objectList[0] as object[];
string tradeId = details[0] as string;
//verify trader("123456789") details
httpActionResult = tradeController.TradeDetails(tradeId);
OkNegotiatedContentResult <TradeDetailsRepresentation> tradeDetails =
(OkNegotiatedContentResult <TradeDetailsRepresentation>)httpActionResult;
Assert.AreEqual(tradeDetails.Content.TradeId, tradeId);
Assert.AreEqual(tradeDetails.Content.ExecutionPrice, (decimal)details[2]);
Assert.AreEqual(tradeDetails.Content.Volume, (decimal)details[3]);
Assert.AreEqual(tradeDetails.Content.Order.Price, 491);
Assert.AreEqual(tradeDetails.Content.Order.Side, OrderSide.Buy.ToString());
Assert.AreEqual(tradeDetails.Content.Order.Type, OrderType.Limit.ToString());
Assert.AreEqual(tradeDetails.Content.Order.Volume, 100);
Assert.AreEqual(tradeDetails.Content.Order.Status, OrderState.Complete.ToString());
//verify trader("55555") details
TradeController tradeController1 = (TradeController)applicationContext["TradeController"];
tradeController1.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController1.Request.Headers.Add("Auth", "55555");
httpActionResult = tradeController1.TradeDetails(tradeId);
OkNegotiatedContentResult <TradeDetailsRepresentation> tradeDetails1 =
(OkNegotiatedContentResult <TradeDetailsRepresentation>)httpActionResult;
Assert.AreEqual(tradeDetails1.Content.TradeId, tradeId);
Assert.AreEqual(tradeDetails1.Content.ExecutionPrice, (decimal)details[2]);
Assert.AreEqual(tradeDetails1.Content.Volume, (decimal)details[3]);
Assert.AreEqual(tradeDetails1.Content.Order.Price, 490);
Assert.AreEqual(tradeDetails1.Content.Order.Side, OrderSide.Sell.ToString());
Assert.AreEqual(tradeDetails1.Content.Order.Type, OrderType.Limit.ToString());
Assert.AreEqual(tradeDetails1.Content.Order.Volume, 300);
Assert.AreEqual(tradeDetails1.Content.Order.Status, OrderState.PartiallyFilled.ToString());
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
tradeRepository.RollBack();
}
public void GetTradesForTraderBetweenTimeRangeTest_TestsTheMethodThatWillGetAllTradesForACurrencypair_AssertsTheValuesOfTheFetchedTrades()
{
// Get the context
IApplicationContext applicationContext = ContextRegistry.GetContext();
//Exchange exchange = new Exchange();
//IEventStore inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
//IEventStore outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
//Journaler inputJournaler = new Journaler(inputEventStore);
//Journaler outputJournaler = new Journaler(outputEventStore);
//InputDisruptorPublisher.InitializeDisruptor(new IEventHandler<InputPayload>[] { exchange, inputJournaler });
//OutputDisruptor.InitializeDisruptor(new IEventHandler<byte[]>[] { outputJournaler });
// Get the instance through Spring configuration
TradeController tradeController = (TradeController)applicationContext["TradeController"];
tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController.Request.Headers.Add("Auth", "123456789");
// Get the instance through Spring configuration
OrderController orderController = (OrderController)applicationContext["OrderController"];
orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController.Request.Headers.Add("Auth", "123456789");
ITradeRepository tradeRepository = (ITradeRepository)applicationContext["TradeRepository"];
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 491,
Volume = 100,
Side = "buy",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 492,
Volume = 300,
Side = "buy",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 493,
Volume = 1000,
Side = "buy",
Type = "limit"
});
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 493,
Volume = 1000,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 492,
Volume = 300,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 491,
Volume = 100,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(4000);
IHttpActionResult httpActionResult = tradeController.GetTradeHistory(new TradeHistoryParams("2014/05/09", "2014/05/09"));
OkNegotiatedContentResult <object> okResponseObject = (OkNegotiatedContentResult <object>)httpActionResult;
IList <object> objectList = (IList <object>)okResponseObject.Content;
List <object[]> newObjectsList = new List <object[]>();
for (int i = 0; i < objectList.Count; i++)
{
object[] objects = objectList[i] as object[];
newObjectsList.Add(objects);
}
Assert.AreEqual(493, newObjectsList[0][2]);
Assert.AreEqual(1000, newObjectsList[0][3]);
Assert.AreEqual(492, newObjectsList[1][2]);
Assert.AreEqual(300, newObjectsList[1][3]);
Assert.AreEqual(491, newObjectsList[2][2]);
Assert.AreEqual(100, newObjectsList[2][3]);
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
tradeRepository.RollBack();
}
public void SetUp()
{
_orderseService = ContextRegistry.GetContext()["OrderApplicationService"] as IOrderApplicationService;
InputDisruptorPublisher.InitializeDisruptor(new IEventHandler <InputPayload>[] { this });
_manualResetEvent = new ManualResetEvent(false);
}
public void TearDown()
{
InputDisruptorPublisher.Shutdown();
}
