Example #1
0
 public SymbolHandlerDefault(SymbolInfo symbol, Agent agent)
 {
     this.symbol        = symbol;
     this.agent         = agent;
     this.quotesLatency = new LatencyMetric("SymbolHandler-Quotes-" + symbol.Symbol.StripInvalidPathChars());
     this.salesLatency  = new LatencyMetric("SymbolHandler-Trade-" + symbol.Symbol.StripInvalidPathChars());
     tickPool           = Factory.Parallel.TickPool(symbol);
     tickPoolCallerId   = tickPool.GetCallerId("SymbolHandler-" + symbol + "-" + agent);
 }
 public void Initialize(Task task)
 {
     queueTask           = task;
     queueTask.Name      = "SimulateSymbolPlayback-" + symbolString;
     tickTimer           = Factory.Parallel.CreateTimer("Tick", queueTask, PlayBackTick);
     queueTask.Scheduler = Scheduler.EarliestTime;
     quoteSimulatorSupport.QuotePacketQueue.ConnectOutbound(queueTask);
     queueTask.Start();
     latency        = new LatencyMetric("SimulateSymbolPlayback-" + symbolString.StripInvalidPathChars());
     diagnoseMetric = Diagnose.RegisterMetric("Simulator");
 }
Example #3
0
 public SimulateSymbolSyncTicks(FIXSimulatorSupport fixSimulatorSupport,
                                QuoteSimulatorSupport quoteSimulatorSupport,
                                string symbolString,
                                PartialFillSimulation partialFillSimulation,
                                TimeStamp endTime,
                                long id)
 {
     log.Register(this);
     this.id = id;
     this.fixSimulatorSupport   = fixSimulatorSupport;
     this.quoteSimulatorSupport = quoteSimulatorSupport;
     this.onTick                         = quoteSimulatorSupport.OnTick;
     this.onEndTick                      = quoteSimulatorSupport.OnEndTick;
     this.PartialFillSimulation          = partialFillSimulation;
     this.symbolString                   = symbolString;
     this.symbol                         = Factory.Symbol.LookupSymbol(symbolString);
     fillSimulator                       = Factory.Utility.FillSimulator("FIX", Symbol, false, true, null);
     fillSimulator.EnableSyncTicks       = SyncTicks.Enabled;
     FillSimulator.OnPhysicalFill        = fixSimulatorSupport.OnPhysicalFill;
     FillSimulator.OnRejectOrder         = fixSimulatorSupport.OnRejectOrder;
     fillSimulator.PartialFillSimulation = partialFillSimulation;
     tickSync       = SyncTicks.GetTickSync(Symbol.BinaryIdentifier);
     latency        = new LatencyMetric("SimulateSymbolSyncTicks-" + symbolString.StripInvalidPathChars());
     diagnoseMetric = Diagnose.RegisterMetric("Simulator");
     if (debug)
     {
         log.Debug("Opening tick file for reading.");
     }
     reader = Factory.TickUtil.TickFile();
     try
     {
         reader.Initialize("Test\\MockProviderData", symbolString, TickFileMode.Read);
         reader.EndTime = endTime;
     }
     catch (FileNotFoundException ex)
     {
         log.Info("File for symbol " + symbolString + " not found: " + ex.Message);
     }
 }
Example #4
0
        static void Main()
        {
            List <KustoDataObj> MockedData = new List <KustoDataObj>();

            MockedData.Add(new KustoDataObj(112, "Pull Request 112", 1, 1, "Test run 1", 0.5));
            MockedData.Add(new KustoDataObj(112, "Pull Request 112", 1, 1, "Test run 2", 0.2));
            MockedData.Add(new KustoDataObj(112, "Pull Request 112", 2, 2, "Test run 1", 0.6));
            MockedData.Add(new KustoDataObj(112, "Pull Request 112", 2, 2, "Test run 2", 0.3));
            MockedData.Add(new KustoDataObj(113, "Pull Request 113", 3, 3, "Test run 3", 0.1));
            MockedData.Add(new KustoDataObj(114, "Pull Request 114", 4, 4, "Test run 4", 0.7));
            MockedData.Add(new KustoDataObj(114, "Pull Request 114", 5, 5, "Test run 5", 0.3));

            using (var db = new BloggingContext())
            {
                foreach (var row in MockedData)
                {
                    long        id = row.PrId;
                    PullRequest pr = db.PullRequests.Find(id);
                    if (pr == null)
                    {
                        pr = new PullRequest()
                        {
                            Id    = id,
                            Title = row.PrTitle
                        };

                        db.PullRequests.Add(pr);
                    }

                    long buildId = row.BuildId;
                    PullRequestBuildInfo prBuild = db.Builds.Find(buildId);
                    if (prBuild == null)
                    {
                        prBuild = new PullRequestBuildInfo()
                        {
                            Id          = buildId,
                            TestRuns    = new List <TestRun>(),
                            PullRequest = pr
                        };

                        db.Builds.Add(prBuild);
                    }

                    long    testRunId = row.TrId;
                    TestRun testRun   = db.TestRuns.Find(testRunId);
                    if (testRun == null)
                    {
                        testRun = new TestRun()
                        {
                            Id          = testRunId,
                            BuildId     = testRunId,
                            Content     = row.TrContent,
                            PullRequest = pr
                        };

                        db.TestRuns.Add(testRun);
                    }

                    var metric = new LatencyMetric()
                    {
                        Percentile = row.Percentile
                    };
                    testRun.LatencyMetrics.Add(metric);
                    prBuild.TestRuns.Add(testRun);

                    db.SaveChanges();
                }
            }
        }