public static IEnumerable<CycleCompletedArgs> GetCycles(this RemoteViewClient client, Action<RemoteViewClient> attachAction) { using (var resultQueue = new BlockingCollection<object>(new ConcurrentQueue<object>())) using (var otherQueue = new BlockingCollection<object>(new ConcurrentQueue<object>())) { var resultListener = new EventViewResultListener(); resultListener.CycleCompleted += (sender, e) => resultQueue.Add(e); resultListener.CycleExecutionFailed += (s, e) => otherQueue.Add(e); resultListener.ProcessTerminated += (s, e) => otherQueue.Add(e); resultListener.ViewDefinitionCompilationFailed += (s, e) => otherQueue.Add(e); client.SetResultListener(resultListener); attachAction(client); TimeSpan timeout = TimeSpan.FromMinutes(1); try { while (true) { object next; var index = BlockingCollection<object>.TryTakeFromAny(new[] { resultQueue, otherQueue }, out next, timeout); if (index == 0) { yield return (CycleCompletedArgs)next; } else { var detailMessage = string.Format("for {0} after {1}\n state {2} is completed {3}", client.GetViewDefinition().Name, timeout, client.GetState(), client.IsCompleted); switch (index) { case 0: throw new ArgumentException("index"); case 1: throw new Exception(string.Format("Error occured whilst getting results {0}\n{1}", next, detailMessage)); default: throw new TimeoutException("No results received " + detailMessage); } } } } finally { client.RemoveResultListener(); } } }
public static void WithViewCycle(Action<ViewDefinitionCompiledArgs, IViewCycle, RemoteViewClient> action, string viewName = "Demo Equity Option Test View") { using (var executedMre = new ManualResetEventSlim(false)) using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { ViewDefinitionCompiledArgs compiled = null; CycleCompletedArgs cycle = null; JavaException error = null; var listener = new EventViewResultListener(); listener.ProcessCompleted += delegate { executedMre.Set(); }; listener.CycleCompleted += delegate(object sender, CycleCompletedArgs e) { cycle = e; executedMre.Set(); }; listener.ViewDefinitionCompiled += delegate(object sender, ViewDefinitionCompiledArgs e) { compiled = e; }; listener.ViewDefinitionCompilationFailed += delegate(object sender, ViewDefinitionCompilationFailedArgs e) { error = e.Exception; executedMre.Set(); }; remoteViewClient.SetResultListener(listener); remoteViewClient.SetViewCycleAccessSupported(true); remoteViewClient.AttachToViewProcess(viewName, ExecutionOptions.SingleCycle); Assert.Null(remoteViewClient.CreateLatestCycleReference()); executedMre.Wait(TimeSpan.FromMinutes(1)); Assert.Null(error); Assert.NotNull(compiled); Assert.NotNull(cycle); using (var engineResourceReference = remoteViewClient.CreateLatestCycleReference()) { action(compiled, engineResourceReference.Value, remoteViewClient); } } }
public static Tuple<IEnumerable<ViewDefinitionCompiledArgs>, IEnumerable<CycleCompletedArgs>> RunToCompletion(IViewExecutionOptions options) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { var cycles = new ConcurrentQueue<CycleCompletedArgs>(); var compiles = new ConcurrentQueue<ViewDefinitionCompiledArgs>(); using (var manualResetEvent = new ManualResetEvent(false)) { var listener = new EventViewResultListener(); listener.ViewDefinitionCompiled += (sender, e) => compiles.Enqueue(e); listener.CycleCompleted += (sender, e) => cycles.Enqueue(e); listener.ProcessCompleted += (sender, e) => manualResetEvent.Set(); remoteViewClient.SetResultListener(listener); remoteViewClient.AttachToViewProcess(ViewName, options); manualResetEvent.WaitOne(); } Assert.InRange(compiles.Count, cycles.Any() ? 1 : 0, cycles.Count + 1); Assert.True(remoteViewClient.IsCompleted); return new Tuple<IEnumerable<ViewDefinitionCompiledArgs>, IEnumerable<CycleCompletedArgs>>(compiles, cycles); } }
private static WeakReference[] UseClient(string vdName) { var firstClient = Context.ViewProcessor.CreateClient(); //NOTE: no using { var finished = new ManualResetEventSlim(false); var eventViewResultListener = new EventViewResultListener(); eventViewResultListener.ProcessCompleted += delegate { finished.Set(); }; firstClient.SetResultListener(eventViewResultListener); //Make sure the active connection is made firstClient.AttachToViewProcess(vdName, ExecutionOptions.SingleCycle); finished.Wait(TimeSpan.FromMinutes(1)); return new[] { new WeakReference(firstClient) }; } }
public void ViewResultsMatchDefinition(ViewDefinition viewDefinition) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { ICompiledViewDefinition compiledViewDefinition = null; IViewComputationResultModel viewComputationResultModel = null; var resultsReady = new ManualResetEvent(false); var listener = new EventViewResultListener(); listener.ViewDefinitionCompiled += delegate(object sender, ViewDefinitionCompiledArgs e) { compiledViewDefinition = e.CompiledViewDefinition; }; listener.CycleCompleted += delegate(object sender, CycleCompletedArgs e) { viewComputationResultModel = e.FullResult; resultsReady.Set(); }; remoteViewClient.SetResultListener(listener); remoteViewClient.AttachToViewProcess(viewDefinition.UniqueID, ExecutionOptions.RealTime); if (!resultsReady.WaitOne(TimeSpan.FromMinutes(2))) throw new TimeoutException("Failed to get results for " + viewDefinition.Name + " client " + remoteViewClient.GetUniqueId()); Assert.NotNull(compiledViewDefinition); foreach (var viewResultEntry in viewComputationResultModel.AllResults) { Assert.NotNull(viewResultEntry.ComputedValue.Value); AssertDefinitionContains(viewDefinition, viewResultEntry); } var countActualValues = viewComputationResultModel.AllResults.Count(); var countMaxExpectedValues = CountMaxExpectedValues(compiledViewDefinition); Console.Out.WriteLine("{0} {1} {2}", viewDefinition.Name, countActualValues, countMaxExpectedValues); Assert.InRange(countActualValues, 1, countMaxExpectedValues); } }
public void HeartbeatWorks() { const string vdName = "Equity Option Test View 1"; using (var firstClient = Context.ViewProcessor.CreateClient()) { var finished = new ManualResetEventSlim(false); var eventViewResultListener = new EventViewResultListener(); eventViewResultListener.ProcessCompleted += delegate { finished.Set(); }; firstClient.SetResultListener(eventViewResultListener); //Make sure the active connection is made firstClient.AttachToViewProcess(vdName, ExecutionOptions.SingleCycle); finished.Wait(TimeSpan.FromMinutes(1)); Thread.Sleep(TimeSpan.FromMinutes(1)); Assert.NotNull(firstClient.GetUniqueId()); } }
public void CanReAttach() { var timeout = TimeSpan.FromMinutes(0.5); using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { var compilationResult = new BlockingCollection<ICompiledViewDefinition>(); var compilationError = new BlockingCollection<JavaException>(); var eventViewResultListener = new EventViewResultListener(); eventViewResultListener.ViewDefinitionCompiled += (sender, e) => compilationResult.Add(e.CompiledViewDefinition); eventViewResultListener.ViewDefinitionCompilationFailed += (sender, e) => compilationError.Add(e.Exception); remoteViewClient.SetResultListener(eventViewResultListener); remoteViewClient.AttachToViewProcess("Equity Option Test View 1", ExecutionOptions.RealTime); ICompiledViewDefinition result; Assert.True(compilationResult.TryTake(out result, timeout)); Assert.Equal("Equity Option Test View 1", result.ViewDefinition.Name); remoteViewClient.DetachFromViewProcess(); remoteViewClient.AttachToViewProcess("Equity Option Test View 2", ExecutionOptions.RealTime); Assert.True(compilationResult.TryTake(out result, timeout)); Assert.Equal("Equity Option Test View 2", result.ViewDefinition.Name); } }
public void CanGetCompilationResults(ViewDefinition definition) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { var compilationResult = new BlockingCollection<object>(); var eventViewResultListener = new EventViewResultListener(); eventViewResultListener.ViewDefinitionCompiled += (sender, e) => compilationResult.Add(e.CompiledViewDefinition); eventViewResultListener.ViewDefinitionCompilationFailed += (sender, e) => compilationResult.Add(e.Exception); remoteViewClient.SetResultListener(eventViewResultListener); remoteViewClient.AttachToViewProcess(definition.UniqueID, ExecutionOptions.GetCompileOnly()); var result = compilationResult.Take(); Assert.IsNotType(typeof(Exception), result); Debug.WriteLine(definition.UniqueID); Assert.IsAssignableFrom(typeof(ICompiledViewDefinition), result); var viewDefin = (ICompiledViewDefinition)result; ValueAssertions.AssertSensibleValue(viewDefin); } }
public void NumberOfResultsIsConsistent(ViewDefinition defn) { const int cyclesCount = 5; using (var remoteViewClient = Context.ViewProcessor.CreateClient()) using (var mre = new ManualResetEvent(false)) { var cycles = new BlockingCollection<IEngineResourceReference<IViewCycle>>(); var listener = new EventViewResultListener(); listener.ProcessCompleted += delegate { mre.Set(); }; listener.ViewDefinitionCompilationFailed += delegate { mre.Set(); }; listener.CycleExecutionFailed += delegate { mre.Set(); }; listener.CycleCompleted += (sender, e) => { cycles.Add(remoteViewClient.CreateCycleReference(e.FullResult.ViewCycleId)); remoteViewClient.TriggerCycle(); }; remoteViewClient.SetResultListener(listener); remoteViewClient.SetViewCycleAccessSupported(true); var sequence = ArbitraryViewCycleExecutionSequence.Create(Enumerable.Range(0, cyclesCount).Select(i => DateTimeOffset.Now + TimeSpan.FromHours(i))); var options = new ExecutionOptions(sequence, ViewExecutionFlags.TriggersEnabled | ViewExecutionFlags.AwaitMarketData, null, new ViewCycleExecutionOptions(default(DateTimeOffset), ExecutionOptions.GetDefaultMarketDataSpec())); remoteViewClient.AttachToViewProcess(defn.UniqueID, options); TimeSpan timeout = TimeSpan.FromMinutes(5); if (! mre.WaitOne(timeout)) { throw new TimeoutException(string.Format("Failed to get result in {0}", timeout)); } Assert.Equal(cyclesCount, cycles.Count); var specs = cycles.Select(GetAllSpecs).ToList(); var inconsistent = specs.Zip(specs.Skip(1), Tuple.Create).SelectMany( t => { var diff = new HashSet<Tuple<string, ValueSpecification>>(t.Item1); diff.SymmetricExceptWith(t.Item2); return diff; }).Distinct(); if (inconsistent.Any()) { var counts = string.Join(",", specs.Select(c => c.Count.ToString())); var inconsistentStrings = specs.Select(s => string.Join(",", s.Where(x => inconsistent.Contains(x)).Select(x => x.ToString()))); string inconsistentString = string.Join(Environment.NewLine, inconsistentStrings); throw new Exception(string.Format("Inconsistent number of results for {0} {1}: {2}", defn.Name, counts, inconsistentString)); } } }
public void CanHoldLotsOfCycles() { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { const int cyclesCount = 1000; var cycles = new BlockingCollection<IEngineResourceReference<IViewCycle>>(); var listener = new EventViewResultListener(); listener.ProcessCompleted += delegate { cycles.Add(null); }; listener.ViewDefinitionCompilationFailed += delegate { cycles.Add(null); }; listener.CycleExecutionFailed += delegate { cycles.Add(null); }; listener.CycleCompleted += (sender, e) => { remoteViewClient.Pause(); //Use parallel to fill the thread pool Parallel.For(0, cyclesCount, _ => cycles.Add(remoteViewClient.CreateCycleReference(e.FullResult.ViewCycleId))); }; remoteViewClient.SetResultListener(listener); remoteViewClient.SetViewCycleAccessSupported(true); var options = ExecutionOptions.RealTime; remoteViewClient.AttachToViewProcess("Demo Equity Option Test View", options); var cyclesList = new List<IEngineResourceReference<IViewCycle>>(); TimeSpan timeout = TimeSpan.FromMinutes(2); for (int i = 0; i < cyclesCount; i++) { IEngineResourceReference<IViewCycle> cycle; if (!cycles.TryTake(out cycle, timeout)) { throw new TimeoutException(string.Format("Failed to get result {0} in {1}", i, timeout)); } if (cycle == null) { throw new Exception("Some error occured"); } cyclesList.Add(cycle); } remoteViewClient.DetachFromViewProcess(); //Stop gathering more and more referencess Thread.Sleep(TimeSpan.FromSeconds(20)); //Make sure we have to heartbeat a few times foreach (var engineResourceReference in cyclesList) { Assert.NotNull(engineResourceReference.Value.UniqueId); } } }
private void RefreshMyDataImpl(string viewName, string liveDataSource, CancellationToken cancellationToken) { Invoke(delegate { resultsTableView.DataContext = null; }, cancellationToken); var clientLock = new object(); lock (clientLock) { var client = OGContext.ViewProcessor.CreateClient(); RoutedEventHandler pausedHandler = delegate { if (!cancellationToken.IsCancellationRequested) { client.Pause(); } }; RoutedEventHandler unpausedHandler = delegate { if (!cancellationToken.IsCancellationRequested) { client.Resume(); } }; //Must do this before we can throw any exceptions ThreadPool.RegisterWaitForSingleObject(cancellationToken.WaitHandle, delegate { lock (clientLock) { client.Dispose(); pauseToggle.Checked -= pausedHandler; pauseToggle.Unchecked -= unpausedHandler; } }, null, int.MaxValue, true); //Now we can start hooking things together pauseToggle.Checked += pausedHandler; pauseToggle.Unchecked += unpausedHandler; ComputationResultsTables resultsTable = null; int count = 0; var eventViewResultListener = new EventViewResultListener(); eventViewResultListener.ViewDefinitionCompiled += delegate(object sender, ViewDefinitionCompiledArgs args) { resultsTable = new ComputationResultsTables(_remoteSecuritySource, args.CompiledViewDefinition); Invoke(delegate { resultsTableView.DataContext = resultsTable; SetStatus(string.Format("Waiting for first cycle...")); }, cancellationToken); }; eventViewResultListener.CycleCompleted += delegate(object sender, CycleCompletedArgs e) { resultsTable.Update(e); SetStatus(GetMessage(e.FullResult ?? (IViewResultModel)e.DeltaResult, ref count)); }; eventViewResultListener.ViewDefinitionCompilationFailed += delegate(object sender, ViewDefinitionCompilationFailedArgs args) { Invoke(delegate { SetStatus(string.Format("Failed to compile {0} @ {1}", args.Exception, args.ValuationTime), true); resultsTableView.DataContext = null; }, cancellationToken); }; eventViewResultListener.CycleExecutionFailed += delegate(object sender, CycleExecutionFailedArgs args) { Invoke(delegate { SetStatus(string.Format("Failed to execute {0} @ {1}", args.Exception, args.ExecutionOptions.ValuationTime), true); }, cancellationToken); }; eventViewResultListener.ProcessTerminated += delegate { Invoke(() => SetStatus(string.Format("Process terminated @ {0}", DateTimeOffset.Now), true), cancellationToken); }; SetStatus(string.Format("Waiting for compilation...")); client.SetResultMode(ViewResultMode.FullThenDelta); client.SetResultListener(eventViewResultListener); client.AttachToViewProcess(viewName, ExecutionOptions.GetRealTime(liveDataSource)); } }
public void RemoveChangesResults() { var valueRequirement = new ValueRequirement("Market_Value", new ComputationTargetSpecification(ComputationTargetType.Primitive, BloombergUid)); var defn = GetViewDefinition(); using (var remoteClient = Context.ViewProcessor.CreateClient()) { var liveDataOverrideInjector = remoteClient.LiveDataOverrideInjector; const double newValue = 1234.5678; ManualResetEvent mre = new ManualResetEvent(false); IViewComputationResultModel results = null; var listener = new EventViewResultListener(); listener.CycleCompleted += delegate(object sender, CycleCompletedArgs e) { results = e.FullResult; mre.Set(); }; remoteClient.SetResultListener(listener); remoteClient.AttachToViewProcess(defn.UniqueID, ExecutionOptions.RealTime); liveDataOverrideInjector.AddValue(valueRequirement, newValue); liveDataOverrideInjector.RemoveValue(valueRequirement); mre.WaitOne(); mre.Reset(); var result = results.AllResults.Where(r => valueRequirement.IsSatisfiedBy(r.ComputedValue.Specification)).First(); Assert.NotEqual(newValue, (double)result.ComputedValue.Value); } }