示例#1
0
        public IActionResult ExecuteJS([FromBody] RunRequest request)
        {
            try
            {
                if (request.ResultType == ResultTypeEnum.FileStream)
                {
                    _engine.Execute($"var result = {request.Method.ToLower()}({request.Params})");
                    object result = _engine.GetValue("result").ToObject();
                    if (result == null)
                    {
                        return(StatusCode(500));
                    }

                    return(new FileStreamResult((FileStream)result, "audio/mpeg"));
                }

                _engine.Execute($"var result = {request.Method.ToLower()}({request.Params})");
                //_engine.Execute($"var result = {request.TableName.ToLower()}.{request.Method.ToLower()}({request.Params});");
                return(Ok(_engine.GetValue("result").ToObject()));
            }
            catch (Exception ex)
            {
                return(StatusCode(500, ex.Message));
            }
        }
示例#2
0
        public SbError Run(SbPlatformShellCommand command)
        {
            var grpcSbPlatformShellCommand = new GrpcSbPlatformShellCommand
            {
                Command = command.GetCommand()
            };
            var request = new RunRequest {
                ShellCommand = grpcSbPlatformShellCommand
            };
            RunResponse response = null;

            if (connection.InvokeRpc(() =>
            {
                response = client.Run(request);
            }))
            {
                command.SetOutput(response.Output);
                command.SetSignal(response.Signal);
                command.SetStatus(response.Status);
                return(sbErrorFactory.Create(response.Error));
            }
            var grpcSbError = new GrpcSbError
            {
                Success = false,
                Error   = "Rpc error while calling Run.  Inspect the logs for more information."
            };

            return(sbErrorFactory.Create(grpcSbError));
        }
        private void RunInVm()
        {
            // (1) Serialize sandboxed prosess info.
            SerializeSandboxedProcessInfoToFile();

            // (2) Create and serialize run request.
            var runRequest = new RunRequest
            {
                AbsolutePath     = m_tool.ExecutablePath,
                Arguments        = m_tool.CreateArguments(GetSandboxedProcessInfoFile(), GetSandboxedProcessResultsFile()),
                WorkingDirectory = GetOutputDirectory()
            };

            VmSerializer.SerializeToFile(RunRequestPath, runRequest);

            // (2) Create a process to execute VmCommandProxy.
            string arguments = $"{VmCommands.Run} /{VmCommands.Params.InputJsonFile}:\"{RunRequestPath}\" /{VmCommands.Params.OutputJsonFile}:\"{RunOutputPath}\"";
            var    process   = CreateVmCommandProxyProcess(arguments);

            LogExternalExecution($"call (wd: {process.StartInfo.WorkingDirectory}) {m_vmInitializer.VmCommandProxy} {arguments}");

            m_processExecutor = new AsyncProcessExecutor(
                process,
                TimeSpan.FromMilliseconds(-1), // Timeout should only be applied to the process that the external tool executes.
                line => AppendLineIfNotNull(m_output, line),
                line => AppendLineIfNotNull(m_error, line),
                SandboxedProcessInfo.Provenance,
                message => LogExternalExecution(message));

            m_processExecutor.Start();
        }
示例#4
0
        protected override void ProcessRecord()
        {
            base.ProcessRecord();
            RunRequest request;

            try
            {
                request = new RunRequest
                {
                    NamespaceName   = NamespaceName,
                    ScheduledTaskId = ScheduledTaskId,
                    TimeStart       = TimeStart,
                    TimeEnd         = TimeEnd,
                    OpcRequestId    = OpcRequestId,
                    OpcRetryToken   = OpcRetryToken
                };

                response = client.Run(request).GetAwaiter().GetResult();
                WriteOutput(response);
                FinishProcessing(response);
            }
            catch (Exception ex)
            {
                TerminatingErrorDuringExecution(ex);
            }
        }
示例#5
0
        private async Task <Dictionary <string, PoolResult> > GetPoolMapAsync(RunRequest request)
        {
            using var channel = GrpcChannel.ForAddress(QueryUrl);
            var client  = new QueryServiceClient(channel);
            var poolMap = new Dictionary <string, PoolResult>();

            foreach (var pool in request.Profile.Pools)
            {
                var queryTicketRequest = new QueryTicketsRequest()
                {
                    Pool = pool
                };
                using var stream = client.QueryTickets(queryTicketRequest);
                var cts         = new CancellationTokenSource(TimeSpan.FromSeconds(ApiTimeout));
                var poolTickets = new List <Ticket>();

                while (await stream.ResponseStream.MoveNext(cts.Token))
                {
                    poolTickets.AddRange(stream.ResponseStream.Current.Tickets);
                }

                if (0 == poolTickets.Count)
                {
                    continue;
                }

                var result = new PoolResult();
                result.Name    = pool.Name;
                result.Tickets = poolTickets.ToList();

                poolMap.Add(pool.Name, result);
            }

            return(poolMap);
        }
示例#6
0
        public override async Task <RunResponse> Run(RunRequest request, ServerCallContext context)
        {
            if (this._callerContext.CancellationToken.IsCancellationRequested || // if caller of UpAsync has cancelled
                context.CancellationToken.IsCancellationRequested)    // if CLI has cancelled
            {
                return(new RunResponse());
            }

            var args       = request.Args;
            var engineAddr = args != null && args.Any() ? args[0] : "";

            var settings = new InlineDeploymentSettings(
                engineAddr,
                request.MonitorAddress,
                request.Config,
                request.Project,
                request.Stack,
                request.Parallel,
                request.DryRun,
                request.ConfigSecretKeys);

            using var cts = CancellationTokenSource.CreateLinkedTokenSource(
                      this._callerContext.CancellationToken,
                      context.CancellationToken);

            this._callerContext.ExceptionDispatchInfo = await Deployment.RunInlineAsync(
                settings,
                runner => this._callerContext.Program.InvokeAsync(runner, cts.Token))
                                                        .ConfigureAwait(false);

            return(new RunResponse());
        }
示例#7
0
        public async Task <ResponseContext <string> > RunAction(JobContext context)
        {
            IRestClient _client = Create(context.ClientHostUrl);

            var request = new RestRequest($"{_options.ApiUriSegments}/run", Method.POST);

            if (_options.Token.NotNullOrEmpty())
            {
                request.AddHeader(JobConstant.Token, _options.Token);
            }

            var runRequest = new RunRequest()
            {
                JobId           = context.Id,
                ExecutorHandler = context.Detail.ExecutorHandler,
                ExecutorParams  = context.Detail.ExecutorParam,
                LogId           = context.LogId,
                LogDateTime     = context.LogDateTime
            };

            request.AddRequestBody(_options.InputMessageType, runRequest);
            var response = await _client.ExecuteAsync(request);

            _logger.LogInformation($"core job run 请求完成,{response.IsSuccessful}, {response.StatusCode}");
            return(response.GetResponseData <string>());
        }
 public void Run(RunRequest runRequest)
 {
     foreach (var nodeId in runRequest.NodeIds)
     {
         //TODO run list id begire
         dataFlowFacade.Run(nodeId);
     }
 }
示例#9
0
        /// <summary>
        /// Start a test run request.
        /// </summary>
        public async Task StartTestRunAsync(IEnumerable <TestCase> aTestCases, string aRevitVersion, Action <ProcessResult> aCallback, CancellationToken aCancellationToken)
        {
            RunRequest request = new RunRequest {
                Cases = aTestCases.ToArray()
            };

            await StartTestRunAsync(request, aRevitVersion, aCallback, aCancellationToken);
        }
示例#10
0
        public RunResponse Run(RunRequest r)
        {
            var res = Run(r.NameFilter, r.Path, r.SuiteName, r.SupportAssemblies, r.TestRunnerType, r.TestRunnerAssembly, r.CrashLogFile);

            return(new RunResponse()
            {
                Result = res
            });
        }
示例#11
0
        private async Task RunTests(RunRequest request, string aRevitVersion)
        {
            request.ClientName    = Assembly.GetExecutingAssembly().GetCustomAttribute <AssemblyProductAttribute>().Product;
            request.ClientVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();

            TimeSpan duration = TimeSpan.Zero;

            System.Console.WriteLine($"App dir {FileNames.WatchDirectory}");
            System.Console.WriteLine($"Start test run {DateTime.Now}; preferred on Revit {aRevitVersion}");
            System.Console.WriteLine();

            var    complete = new List <TestCase>();
            Client client   = new Client(ProgramName, ProgramVersion);

            await client.StartTestRunAsync(request, aRevitVersion, result => {
                try {
                    if (result.Result != null)
                    {
                        foreach (var test in result.Result.Cases.Where(c => c.State == TestState.Passed || c.State == TestState.Failed))
                        {
                            if (complete.All(t => t.Id != test.Id))
                            {
                                complete.Add(test);

                                string testString = $"{test.Id,-8} Test {test.State,-7} - {test.TestClass}.{test.MethodName}";

                                System.Console.WriteLine(testString);
                                if (!string.IsNullOrEmpty(test.Message))
                                {
                                    System.Console.WriteLine($"\t{test.Message}");
                                }
                                if (!string.IsNullOrEmpty(test.StackTrace))
                                {
                                    System.Console.WriteLine($"\t{test.StackTrace}");
                                }

                                duration = result.Duration;
                            }
                        }
                    }
                }
                catch (Exception e) {
                    System.Console.WriteLine($"Callback Exception: {e}");
                }

                if (!string.IsNullOrEmpty(result.Message))
                {
                    System.Console.WriteLine(result.Message);
                }
            }, CancellationToken.None);

            int passedCount = complete.Count(t => t.State == TestState.Passed);

            System.Console.WriteLine();
            System.Console.WriteLine($"Run finished - duration {duration:g} - {passedCount} of {complete.Count} Tests passed ({Math.Round( 100 * (double)passedCount / complete.Count )}%)");
        }
示例#12
0
 public void RejectEmptyTempPath()
 {
     using (var temp = new TempRoot())
     {
         var host     = new TestableCompilerServerHost();
         var request  = new RunRequest(LanguageNames.CSharp, currentDirectory: temp.CreateDirectory().Path, tempDirectory: null, libDirectory: null, arguments: Array.Empty <string>());
         var response = host.RunCompilation(request, CancellationToken.None);
         Assert.Equal(ResponseType.Rejected, response.Type);
     }
 }
 public void RejectEmptyTempPath()
 {
     using (var temp = new TempRoot())
     {
         var host = new TestableCompilerServerHost();
         var request = new RunRequest(LanguageNames.CSharp, currentDirectory: temp.CreateDirectory().Path, tempDirectory: null, libDirectory: null, arguments: Array.Empty<string>());
         var response = host.RunCompilation(request, CancellationToken.None);
         Assert.Equal(ResponseType.Rejected, response.Type);
     }
 }
示例#14
0
        public int Run(RunRequest request)
        {
            if (PTMKernelService.IsTestSuiteRunning())
            {
                throw new NotSupportedException("PTMService does not support parallel run right now, please wait for the current running job to be completed and then try again.");
            }

            var result = PTMKernelService.CreateTestRun(request.ConfigurationId, request.SelectedTestCases);

            return(result);
        }
示例#15
0
        private async Task MainAsync(string[] args)
        {
            RunRequest request      = null;
            string     requestFile  = GetFile(args);
            string     revitVersion = GetVersion(args);

            if (!string.IsNullOrEmpty(requestFile))
            {
                request = GetRequestFromFile(requestFile);
            }

            await RunTests(request, revitVersion);
        }
示例#16
0
        public ActionResult <AiResult> Post([FromBody] RunRequest request)
        {
            var compilationResult = _compiler.Compile(request.Code);

            if (!compilationResult.IsOk)
            {
                return(BadRequest(compilationResult));
            }

            var ai       = compilationResult.Ai;
            var aiResult = ai.Run(request.TrackState);

            return(Ok(aiResult));
        }
示例#17
0
        public void TestRunExpression()
        {
            var handler = new CSScriptHandler();
            var rr      = new RunRequest
            {
                Kind = ScriptKind.Expression,
                Code = @" 
                        System.Environment.OSVersion.Platform
                        "
            };
            var rsp = handler.Process(rr) as RunResponse;

            Assert.AreEqual("Win32NT", rsp.Result + "");
        }
示例#18
0
        public string Run(Application app, RunRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }
            var stringBuilder = new StringBuilder();

            ReflectionRunner runner = new ReflectionRunner();

            foreach (TestCase test in request.Cases)
            {
                stringBuilder.Append(Run(app, runner, test));
            }

            return(stringBuilder.ToString());
        }
示例#19
0
        public void TestRunMethod()
        {
            var handler = new CSScriptHandler();
            var rr      = new RunRequest
            {
                Kind = ScriptKind.Method,
                Code = @" 
                        public object Run(params object[] args)
                        {
                            return System.Environment.OSVersion.Platform;
                        }                        
                        "
            };
            var rsp = handler.Process(rr) as RunResponse;

            Assert.AreEqual("Win32NT", rsp.Result + "");
        }
示例#20
0
        public async override Task Run(RunRequest request, grpc::IServerStreamWriter <global::OpenMatch.RunResponse> responseStream, grpc::ServerCallContext context)
        {
            AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);

            var poolMap = await GetPoolMapAsync(request);

            if (0 == poolMap.Count)
            {
                return;
            }

            var matches = MakeMatches(request, poolMap);

            foreach (var match in matches)
            {
                await responseStream.WriteAsync(new RunResponse { Proposal = match });
            }
        }
		public RunResponse Run (RunRequest r)
		{
			EventListenerWrapper listenerWrapper = new EventListenerWrapper (server);

			UnhandledExceptionEventHandler exceptionHandler = (object sender, UnhandledExceptionEventArgs e) => {
				var ex = e.ExceptionObject;
				File.WriteAllText (r.CrashLogFile, e.ToString ());
			};

			AppDomain.CurrentDomain.UnhandledException += exceptionHandler;
			try {
				var res = Run (listenerWrapper, r.NameFilter, r.Path, r.SuiteName, r.SupportAssemblies, r.TestRunnerType, r.TestRunnerAssembly);
				res = res.SelectSingleNode ("test-suite");
				return new RunResponse () { Result = listenerWrapper.GetLocalTestResult (res) };
			} finally {
				AppDomain.CurrentDomain.UnhandledException -= exceptionHandler;
			}
		}
示例#22
0
        public override async Task <RunResponse> Run(RunRequest request, ServerCallContext context)
        {
            if (this._callerContext.CancellationToken.IsCancellationRequested || // if caller of UpAsync has cancelled
                context.CancellationToken.IsCancellationRequested)    // if CLI has cancelled
            {
                return(new RunResponse());
            }

            var args       = request.Args;
            var engineAddr = args != null && args.Any() ? args[0] : "";

            var settings = new InlineDeploymentSettings(
                _callerContext.Logger,
                engineAddr,
                request.MonitorAddress,
                request.Config,
                request.ConfigSecretKeys,
                request.Project,
                request.Stack,
                request.Parallel,
                request.DryRun);

            using var cts = CancellationTokenSource.CreateLinkedTokenSource(
                      this._callerContext.CancellationToken,
                      context.CancellationToken);

            var result = await Deployment.RunInlineAsync(
                settings,
                // ReSharper disable once AccessToDisposedClosure
                runner => this._callerContext.Program.InvokeAsync(runner, cts.Token))
                         .ConfigureAwait(false);

            if (result.ExitCode != 0 || result.ExceptionDispatchInfo != null)
            {
                this._callerContext.ExceptionDispatchInfo = result.ExceptionDispatchInfo;
                return(new RunResponse()
                {
                    Bail = true,
                    Error = result.ExceptionDispatchInfo?.SourceException.Message ?? "One or more errors occurred.",
                });
            }

            return(new RunResponse());
        }
示例#23
0
        /// <summary>
        /// Run report background job by id 83001 and wait until job finished as succeed or failed and get result
        /// </summary>
        public static DetailsResponse RunReportBackgroundJob()
        {
            const int reportId           = 83001;
            var       reportExportFormat = new RunRequest("xlsx");

            var jobId = ApiClient.RunReport(reportId, reportExportFormat).JobId;

            while (true)
            {
                var jobState = ApiClient.GetJobById(jobId).JobState;

                if (jobState == StateType.Succeeded || jobState == StateType.Failed)
                {
                    return(ApiClient.GetJobById(jobId));
                }

                Thread.Sleep(millisecondsTimeout: 1000);
            }
        }
示例#24
0
        private List <Match> MakeMatches(RunRequest request, Dictionary <string, PoolResult> poolMap)
        {
            var matches = new List <Match>();

            while (true)
            {
                var insufficientTickets = false;
                var matchTickets        = new List <Ticket>();

                foreach (var key in poolMap.Keys)
                {
                    var pool    = poolMap[key];
                    var tickets = pool.Tickets.ToList();
                    if (tickets.Count < MatchingCount)
                    {
                        insufficientTickets = true;
                        break;
                    }

                    for (var i = 0; i < MatchingCount; i++)
                    {
                        var ticket = tickets[i];
                        matchTickets.Add(ticket);
                        pool.Tickets.Remove(ticket);
                    }
                }

                if (insufficientTickets)
                {
                    break;
                }

                var match = new Match();
                match.MatchId       = $"profile-{request.Profile.Name}-{Guid.NewGuid().ToString()}";
                match.MatchProfile  = request.Profile.Name;
                match.MatchFunction = MatchFunctionName;
                match.Tickets.AddRange(matchTickets);
                matches.Add(match);
            }

            return(matches);
        }
示例#25
0
        public async Task <UnitTestResult> Run(IRemoteEventListener listener, string[] nameFilter, string path, string suiteName, List <string> supportAssemblies, string testRunnerType, string testRunnerAssembly, string crashLogFile)
        {
            this.listener = listener;

            var msg = new RunRequest {
                NameFilter         = nameFilter,
                Path               = path,
                SuiteName          = suiteName,
                SupportAssemblies  = supportAssemblies.ToArray(),
                TestRunnerType     = testRunnerType,
                TestRunnerAssembly = testRunnerAssembly,
                CrashLogFile       = crashLogFile
            };

            var r = (await connection.SendMessage(msg)).Result;

            await connection.ProcessPendingMessages();

            return(ToUnitTestResult(r));
        }
		public async Task<UnitTestResult> Run (IRemoteEventListener listener, string[] nameFilter, string path, string suiteName, List<string> supportAssemblies, string testRunnerType, string testRunnerAssembly, string crashLogFile)
		{
			this.listener = listener;

			var msg = new RunRequest {
				NameFilter = nameFilter,
				Path = path,
				SuiteName = suiteName,
				SupportAssemblies = supportAssemblies.ToArray (),
				TestRunnerType = testRunnerType,
				TestRunnerAssembly = testRunnerAssembly,
				CrashLogFile = crashLogFile
			};

			var r = (await connection.SendMessage (msg)).Result;

			await connection.ProcessPendingMessages ();

			return ToUnitTestResult (r);
		}
示例#27
0
        // Run the specified command.
        public override Task <RunResponse> Run(RunRequest request, ServerCallContext context)
        {
            PreconditionCheck();
            var shellCommand = sbPlatformShellCommandFactory.Create(request.ShellCommand.Command);
            var error        = sbPlatform.Run(shellCommand);
            var grpcError    = new GrpcSbError
            {
                Success = error.Success(),
                Error   = error.GetCString()
            };
            var response = new RunResponse
            {
                Error  = grpcError,
                Output = shellCommand.GetOutput(),
                Signal = shellCommand.GetSignal(),
                Status = shellCommand.GetStatus()
            };

            return(Task.FromResult(response));
        }
示例#28
0
        public RunResponse Run(RunRequest r)
        {
            EventListenerWrapper listenerWrapper = new EventListenerWrapper(server);

            UnhandledExceptionEventHandler exceptionHandler = (object sender, UnhandledExceptionEventArgs e) => {
                var ex = e.ExceptionObject;
                File.WriteAllText(r.CrashLogFile, e.ToString());
            };

            AppDomain.CurrentDomain.UnhandledException += exceptionHandler;
            try {
                var res = Run(listenerWrapper, r.NameFilter, r.Path, r.SuiteName, r.SupportAssemblies, r.TestRunnerType, r.TestRunnerAssembly);
                res = res.SelectSingleNode("test-suite");
                return(new RunResponse()
                {
                    Result = listenerWrapper.GetLocalTestResult(res)
                });
            } finally {
                AppDomain.CurrentDomain.UnhandledException -= exceptionHandler;
            }
        }
示例#29
0
        public RunRequest GetRequestFromAssembly(string assemblyPath)
        {
            var node = GetXmlNodeFromAssembly(assemblyPath);

            if (node == null)
            {
                return(null);
            }

            Console.WriteLine("****Node: ");
            Console.WriteLine(node.OuterXml);
            Console.WriteLine("**********");

            var nunitTestSuite = new NUnitTestSuite(node);
            var nUnitCases     = nUnitCaseFlattenService.Flatten(nunitTestSuite);

            var testCases = new List <TestCase>();

            foreach (var nUnitCase in nUnitCases)
            {
                var testCase = new TestCase
                {
                    Id           = nUnitCase.Id,
                    AssemblyPath = assemblyPath,
                    TestClass    = nUnitCase.ClassName,
                    MethodName   = nUnitCase.MethodName
                };

                testCases.Add(testCase);
            }

            RunRequest request = new RunRequest
            {
                ClientName = "Revit",
                Timestamp  = DateTime.Now,
                Cases      = testCases.ToArray()
            };

            return(request);
        }
        public async Task <Result> RunSolution(RunRequest request)
        {
            var challenge = await _challengeService.Get(request.ChallengeId);

            var result = new Result
            {
                TestResults = new List <Models.Competition.TestResult>()
            };

            foreach (var test in challenge.Tests)
            {
                var compileRequest = CreateCompileRequest(challenge, request.Language, request.SolutionCode, test.InputParameter);

                var compileResult = await _codeCompiler.RunCode(compileRequest);

                if (!string.IsNullOrEmpty(compileResult.Errors))
                {
                    result.Errors   = compileResult.Errors;
                    result.Warnings = compileResult.Warnings;
                    break;
                }

                if (string.IsNullOrEmpty(result.Runtime))
                {
                    result.Runtime = compileResult.Statistic;
                }

                result.TestResults.Add(new Models.Competition.TestResult
                {
                    Success        = compileResult.Result == test.ExpectedResult,
                    ActualResult   = compileResult.Result,
                    ExpectedResult = test.ExpectedResult,
                    InputParameter = test.InputParameter,
                });
            }

            result.Success = result.TestResults.Count(x => x.Success) == challenge.Tests.Count;
            result.Message = $"Passed {result.TestResults.Count(x => x.Success)} of {challenge.Tests.Count}";
            return(result);
        }
示例#31
0
        private RunRequest GetRequestFromFile(string path)
        {
            RunRequest request = null;

            if (File.Exists(path))
            {
                try {
                    request = JsonHelper.FromFile <RunRequest>(path);

                    System.Console.WriteLine($"Request loaded from '{path}'");
                }
                catch (Exception e) {
                    System.Console.WriteLine($"Can not create Request from '{path}' - {e}");
                }
            }
            else
            {
                System.Console.WriteLine($"File does not exist '{path}'");
            }

            return(request);
        }
示例#32
0
        public void TestRunClass()
        {
            var handler = new CSScriptHandler();
            var rr      = new RunRequest
            {
                Kind = ScriptKind.Class,
                Code = @"
                         using System;
                         using Stinkhorn.Script.API;

                         public class Example : MarshalByRefObject, IRunnable 
                         {
                            public object Run(params object[] args)
                            {
                                return System.Environment.OSVersion.Platform;
                            }
                         }
                        "
            };
            var rsp = handler.Process(rr) as RunResponse;

            Assert.AreEqual("Win32NT", rsp.Result + "");
        }
示例#33
0
        /// <summary>
        /// Start a test run request.
        /// </summary>
        public async Task StartTestRunAsync(RunRequest aRequest, string aRevitVersion, Action <ProcessResult> aCallback, CancellationToken aCancellationToken)
        {
            aRequest.Timestamp     = DateTime.Now;
            aRequest.Id            = GenerateId();
            aRequest.ClientName    = mClientName;
            aRequest.ClientVersion = mClientVersion;

            var  revit             = RevitHelper.StartRevit(aRevitVersion);
            bool isRunnerAvailable = await IsRunnerAvailable(aCancellationToken);

            if (isRunnerAvailable)
            {
                string requestFilePath = FileNames.RunRequestFilePath(aRequest.Id);
                JsonHelper.ToFile(requestFilePath, aRequest);

                var responseDirectoryPath = await GetResponseDirectory(aRequest.Id);

                if (Directory.Exists(responseDirectoryPath))
                {
                    bool run = true;

                    while (run && !aCancellationToken.IsCancellationRequested)
                    {
                        var runResult = JsonHelper.FromFile <RunResult>(Path.Combine(responseDirectoryPath, FileNames.RunResult));

                        if (runResult != null)
                        {
                            bool          isCompleted = runResult.State == TestState.Passed || runResult.State == TestState.Failed;
                            ProcessResult result      = new ProcessResult(runResult, isCompleted);

                            aCallback(result);

                            run = !isCompleted;

                            if (run)
                            {
                                await Task.Delay(500, aCancellationToken);
                            }
                        }
                    }
                }
                else
                {
                    FileHelper.DeleteWithLock(requestFilePath);
                    aCallback(new ProcessResult(null, true)
                    {
                        Message = "Tests not executed! Service may not be running."
                    });
                }

                if (revit.IsNew)
                {
                    RevitHelper.KillRevit(revit.ProcessId);
                }
            }
            else
            {
                aCallback(new ProcessResult(null, true)
                {
                    Message = "Runner not available!"
                });
            }
        }
 BuildResponse ICompilerServerHost.RunCompilation(RunRequest request, CancellationToken cancellationToken)
 {
     return RunCompilation(request, cancellationToken);
 }
		public RunResponse Run (RunRequest r)
		{
			var res = Run (r.NameFilter, r.Path, r.SuiteName, r.SupportAssemblies, r.TestRunnerType, r.TestRunnerAssembly, r.CrashLogFile);
			return new RunResponse () { Result = res };
		}
 public RunRequestHandler(IContainerManager containerManager, Request request)
     : base(containerManager, request)
 {
     this.request = (RunRequest)request;
 }