/// <summary> /// Sets the simulation parameters. /// </summary> /// <param name="simulationParameters">The simulator parameters.</param> void SetSimulatorParameter(Object state) { // Extract the simulator parameters from the generic argument. SimulatorParameters simulatorParameters = state as SimulatorParameters; // This pushes the simulation parameters to the simulator. using (MarketServiceClient marketServiceClient = new MarketServiceClient()) marketServiceClient.SetSimulatorParameters(simulatorParameters); }
/// <summary> /// Extracts orders from the queue and passes them on to the market service to be executed. /// </summary> static void MarketThread() { // This provides a connection to a destination that will simulate the execution of orders. MarketServiceClient marketServiceClient = new MarketServiceClient(); while (true) { // The thread will wait here until there is an order to process. MarketEngine.orderEvent.WaitOne(); // The general idea is to pull messages out of the queue until either the queue is empty or we've got a chunk big enough to send to the // destination. When the queue has been emptied, we're going to put the thread in a wait until more orders arrive. List <Message> messages = new List <Message>(); lock (MarketEngine.syncRoot) { while (MarketEngine.messageQueue.Count != 0 && messages.Count < MarketEngine.chunkSize) { messages.Add(MarketEngine.messageQueue.Dequeue()); } if (MarketEngine.messageQueue.Count == 0) { MarketEngine.orderEvent.Reset(); } } // This will guarantee the delivery of the block of messages. This loop will continue to try to send execute the web method until until the market // service either accepts it or the thread is killed externally. If the client finds itself in the faulted state after any exception, we'll try // to create it again. Note that we give the thread a little time to sleep when we do run into a fault so as to keep this loop from eating up the // CPU when the market service isn't around to process the web service request. while (true) { try { marketServiceClient.ExecuteOrder(messages.ToArray()); break; } catch { if (marketServiceClient.State != CommunicationState.Opened) { marketServiceClient = new MarketServiceClient(); Thread.Sleep(MarketEngine.retryTime); } } } } }
/// <summary> /// Clears the orders and executions from the server. /// </summary> void ClearOrders(Object state) { // The simulator needs to be cleaned of orders so it doesn't generate an execution on an order that's been deleted by the server. using (MarketServiceClient marketServiceClient = new MarketServiceClient()) marketServiceClient.ClearOrders(); // This will clear any of the orders on the server. The main idea is to allow a replay of a demo scenario. This is never intended to be part of an // actual production environment. foreach (TenantInfo tenantInfo in MainWindow.Tenants) { if (tenantInfo.Status == Status.Running) { WebServiceClient webServiceClient = new WebServiceClient(tenantInfo.EndpointConfigurationName); webServiceClient.ClientCredentials.UserName.UserName = tenantInfo.UserName; webServiceClient.ClientCredentials.UserName.Password = tenantInfo.Password; webServiceClient.ClearOrders(); } } }
/// <summary> /// Initializes the simulation parameters. /// </summary> /// <param name="state">The generic thread start parameter.</param> void InitializeData(Object state) { SimulatorParameters simulatorParameters = null; // This will ask the simulator for the current set of operating parameters using (MarketServiceClient marketServiceClient = new MarketServiceClient()) { try { simulatorParameters = marketServiceClient.GetSimulatorParameters(); } catch (Exception exception) { MessageBox.Show(exception.Message, "Market Console Error"); Application.Current.Shutdown(); } } // Pass the simulator parameters to the foreground to be used as the initialization settings for the management dialog. this.Dispatcher.BeginInvoke( DispatcherPriority.SystemIdle, new SetSimulatorParametersHandler(this.OnSetSimulatorParameters), simulatorParameters); }