示例#1
0
        /// <summary>
        /// Send Order requests to OEE as Byte Streams
        /// </summary>
        /// <param name="rabbitMqMessage">Contains Order Byte Stream</param>
        public void SendOrderRequests(RabbitMqRequestMessage rabbitMqMessage)
        {
            try
            {
                // Convert AppID into Bytes
                byte[] appIdBytes = Encoding.UTF8.GetBytes(_appId + ",");
                // Create a new byte array to hold complete info
                byte[] completeByteMessage = new byte[rabbitMqMessage.Message.Length + appIdBytes.Length];

                // Add AppID Bytes to new byte array
                appIdBytes.CopyTo(completeByteMessage, 0);
                // Add order request bytes to new byte array
                rabbitMqMessage.Message.CopyTo(completeByteMessage, appIdBytes.Length);

                // Swap values
                rabbitMqMessage.Message = completeByteMessage;

                // Forward requests to Client MQ Server
                _mqServer.SendOrderRequests(rabbitMqMessage);
            }
            catch (Exception exception)
            {
                _asyncClassLogger.Error(exception, _type.FullName, "SendOrderRequests");
            }
        }
示例#2
0
        /// <summary>
        /// Forwards Execution message to Communicator to be sent to Server
        /// </summary>
        /// <param name="requestMessage">Contains Execution information to be sent</param>
        public void SendExecution(MessageQueueObject requestMessage)
        {
            try
            {
                // Create New Object
                var tempRequestMessage = new RabbitMqRequestMessage();

                // Copy value
                tempRequestMessage.Message = requestMessage.Message;

                // Forward information to Communicator
                _communicator.SendExecution(tempRequestMessage);
            }
            catch (Exception exception)
            {
                Logger.Error(exception, _type.FullName, "SendExecution");
            }
        }
示例#3
0
        public void MarketOrderTestCase()
        {
            MarketOrder marketOrder = new MarketOrder(TradeHubConstants.OrderExecutionProvider.Simulated)
            {
                OrderID  = "A00",
                Security = new Security {
                    Symbol = "AAPL"
                },
                OrderSide = TradeHubConstants.OrderSide.SELL,
                OrderSize = 100
            };
            Execution execution = null;

            bool logonArrived     = false;
            bool logoutArrived    = false;
            bool connected        = false;
            bool newArrived       = false;
            bool executionArrived = false;

            ManualResetEvent manualLogonEvent     = new ManualResetEvent(false);
            ManualResetEvent manualLogoutEvent    = new ManualResetEvent(false);
            ManualResetEvent manualConnectedEvent = new ManualResetEvent(false);
            ManualResetEvent manualNewEvent       = new ManualResetEvent(false);
            ManualResetEvent manualExecutionEvent = new ManualResetEvent(false);

            _executionEngineClient.ServerConnected += delegate()
            {
                connected = true;
                _executionEngineClient.SendLoginRequest(new Login()
                {
                    OrderExecutionProvider = TradeHubConstants.OrderExecutionProvider.Simulated
                });
                manualConnectedEvent.Set();
            };

            _executionEngineClient.LogonArrived +=
                delegate(string obj)
            {
                logonArrived = true;

                //_executionEngineClient.SendMarketOrderRequest(marketOrder);
                RabbitMqRequestMessage entryMessage = new RabbitMqRequestMessage();
                var messageBytes = Encoding.UTF8.GetBytes(marketOrder.DataToPublish());

                // Initialize property
                entryMessage.Message = new byte[messageBytes.Length];
                // Update object values
                messageBytes.CopyTo(entryMessage.Message, 0);

                _executionEngineClient.SendOrderRequests(entryMessage);

                manualLogonEvent.Set();
            };

            _executionEngineClient.NewArrived +=
                delegate(Order obj)
            {
                newArrived = true;
                manualNewEvent.Set();
            };

            _executionEngineClient.ExecutionArrived +=
                delegate(Execution obj)
            {
                if (obj.Fill.LeavesQuantity.Equals(0))
                {
                    executionArrived = true;
                    execution        = obj;
                    _executionEngineClient.SendLogoutRequest(new Logout {
                        OrderExecutionProvider = TradeHubConstants.OrderExecutionProvider.Simulated
                    });
                    manualExecutionEvent.Set();
                }
            };

            _executionEngineClient.LogoutArrived +=
                delegate(string obj)
            {
                logoutArrived = true;
                manualLogoutEvent.Set();
            };

            _executionEngineClient.Start();

            manualConnectedEvent.WaitOne(30000, false);
            manualLogonEvent.WaitOne(30000, false);
            manualNewEvent.WaitOne(30000, false);
            manualExecutionEvent.WaitOne(30000, false);
            manualLogoutEvent.WaitOne(30000, false);

            Thread.Sleep(1000);

            Assert.AreEqual(true, logonArrived, "Logon Arrived");
            Assert.AreEqual(true, newArrived, "New Arrived");
            Assert.AreEqual(true, executionArrived, "Execution Arrived");
            Assert.AreEqual(true, execution.Fill.ExecutionSide.Equals(TradeHubConstants.OrderSide.SELL), "Execution Side");
            Assert.AreEqual(true, logoutArrived, "Logout Arrived");
        }