Ejemplo n.º 1
0
    public void Append(ICountableLookup lookup, IProcess caller, IReadOnlySlimRow[] filterRows)
    {
        var process = ProcessCreator.Invoke(filterRows);

        var rows     = process.TakeRowsAndReleaseOwnership(caller);
        var rowCount = 0;

        foreach (var row in rows)
        {
            rowCount++;

            string key = null;
            try
            {
                key = KeyGenerator(row);
            }
            catch (Exception ex)
            {
                throw KeyGeneratorException.Wrap(caller, row, ex);
            }

            if (string.IsNullOrEmpty(key))
            {
                continue;
            }

            lookup.AddRow(key, row);
        }

        caller?.Context.Log(LogSeverity.Debug, caller, "fetched {RowCount} rows, lookup size is {LookupSize}",
                            rowCount, lookup.Count);
    }
Ejemplo n.º 2
0
        private void CalculateProcess()
        {
            var initialProcess = ApplicationContainer.Resolve <IInitialProcessCreator>().CreateInitialProcess();
            var processCreator = new ProcessCreator(initialProcess);

            process = processCreator.CreateProcess();
        }
Ejemplo n.º 3
0
        protected Process LaunchTestsApp(FileInfo appFile, Actions action, Guid telemetryKey, ProgramInfo pi = null, bool waitForExit = true, string viewName = null)
        {
            Arguments args = new Arguments {
                ApiUrl = this.BaseUrl, Action = action
            };

            args.DebugMode    = true;
            args.ProgramInfo  = pi;
            args.ViewName     = viewName;
            args.TelemetryKey = telemetryKey;


            Process process = ProcessCreator.Create(appFile, args, this.outputs, this.errors);

            this.Log($"Started process: {appFile.FullName}");
            process.Start();
            process.BeginOutputReadLine();
            process.BeginErrorReadLine();
            if (waitForExit)
            {
                process.WaitForExit();
                this.Log($"Finished process: {appFile.FullName}");
            }

            return(process);
        }
Ejemplo n.º 4
0
        Process LaunchTestRunner(PNUnitTestInfo testInfo, string testInfoPath)
        {
            string testingArgs = string.Format(
                "\"{0}\" \"{1}\"", testInfoPath, mPathToAssemblies);

            // You should customize this section depending on the applications
            // you've got and the platform they run on.
            Process result = null;

            if (testInfo.TestName.StartsWith("windows:"))
            {
                result = ProcessCreator.CreateGuiApplicationRunnerProcess(
                    testInfo, "windows.exe", testingArgs, mPathToAssemblies);
            }

            if (testInfo.TestName.StartsWith("linux:"))
            {
                result = ProcessCreator.CreateGuiApplicationRunnerProcess(
                    testInfo, "linux", testingArgs, mPathToAssemblies);
            }

            if (testInfo.TestName.StartsWith("mac:"))
            {
                result = ProcessCreator.CreateGuiApplicationRunnerProcess(
                    testInfo, "macos.app/Contents/MacOS/macos", testingArgs, mPathToAssemblies);
            }

            if (result == null)
            {
                result = ProcessCreator.CreateTestRunnerProc(testingArgs, mPathToAssemblies);
            }

            result.Start();
            return(result);
        }
Ejemplo n.º 5
0
        public void SendStatus(object sender, System.Timers.ElapsedEventArgs args)
        {
            eventLog.WriteEntry("Tick started", EventLogEntryType.Information);
            try {
                dynamic result = SendStatus();
                if (result == null)
                {
                    return;
                }
                if (result.command == null)
                {
                    return;
                }

                string message = result.message != null ? $"-m {result.message}" : "";

                eventLog.WriteEntry($"Starting process for {result.command}\n-c {result.command} {message}");

                ProcessCreator processCreator = new ProcessCreator();
                processCreator.createProcess(WORKING_DIR + WORKER_EXECUTABLE_NAME, $"-c {result.command} {message}");
            } catch (Exception ex) {
                eventLog.WriteEntry($"Tick failed: {ex.Message} {ex.StackTrace}", EventLogEntryType.Error);
            }
            eventLog.WriteEntry("Tick finished", EventLogEntryType.Information);
        }
Ejemplo n.º 6
0
        public void TraceNewProcess(IEnumerable <string> procargs, bool spawnNewConsoleWindow, TraceOptions traceOptions)
        {
            using (var process = new ProcessCreator(procargs)
            {
                SpawnNewConsoleWindow = spawnNewConsoleWindow
            }) {
                process.StartSuspended();

                using (var kernelTraceCollector = new TraceCollector(KernelTraceEventParser.KernelSessionName))
                    using (var customTraceCollector = new TraceCollector(WinTraceUserTraceSessionName)) {
                        InitializeProcessHandlers(kernelTraceCollector, customTraceCollector,
                                                  process.ProcessId, traceOptions);

                        ThreadPool.QueueUserWorkItem((o) => {
                            process.Join();
                            StopCollectors(kernelTraceCollector, customTraceCollector);
                            stopEvent.Set();
                        });

                        stopTraceCollectors = () => { StopCollectors(kernelTraceCollector, customTraceCollector); };

                        ThreadPool.QueueUserWorkItem((o) => { kernelTraceCollector.Start(); });
                        ThreadPool.QueueUserWorkItem((o) => { customTraceCollector.Start(); });

                        Thread.Sleep(1000);

                        // resume thread
                        process.Resume();

                        stopEvent.WaitOne();
                    }
            }
        }
Ejemplo n.º 7
0
        public void Append(ICountableLookup lookup, IProcess caller, IReadOnlySlimRow[] filterRows)
        {
            var process = ProcessCreator.Invoke(filterRows);

            var rows     = process.Evaluate(caller).TakeRowsAndReleaseOwnership();
            var rowCount = 0;

            foreach (var row in rows)
            {
                rowCount++;

                string key = null;
                try
                {
                    key = KeyGenerator(row);
                }
                catch (EtlException) { throw; }
                catch (Exception)
                {
                    var exception = new ProcessExecutionException(caller, row, nameof(RowLookupBuilder) + " failed");
                    throw exception;
                }

                if (string.IsNullOrEmpty(key))
                {
                    continue;
                }

                lookup.AddRow(key, row);
            }

            caller?.Context.Log(LogSeverity.Debug, caller, "fetched {RowCount} rows, lookup size is {LookupSize}",
                                rowCount, lookup.Count);
        }
        internal override ProcessResult Prepare(ProcessResult processResult)
        {
            processResult = base.Prepare(processResult);

            if (processResult.State == ProcessState.Error)
            {
                return(processResult);
            }

            var udidName = Guid.NewGuid().ToString();

            logger.MoveSrcToTempDir();
            FilesHelper.MoveToTemp(WorkingDir, SRC_FILE_NAME, udidName + SRC_EXT);

            logger.CreateProcess(CREATE_ARGS);
            Process proc = ProcessCreator.Create(WorkingDir, CREATE_ARGS);

            logger.CreateConsoleProject();
            processResult = ExecuteProcess <CreateDotNetConsoleProjectFailed>(proc, processResult);

            if (processResult.State == ProcessState.Error)
            {
                logger.CreateConsoleProject(false);
                logger.EndWriting();

                return(processResult);
            }

            logger.CreateConsoleProject(true);
            logger.MoveSrcToWorkingDir();
            FilesHelper.MoveFromTemp(WorkingDir, udidName + SRC_EXT, SRC_FILE_NAME);

            return(processResult);
        }
Ejemplo n.º 9
0
        Process PreloadTestRunner()
        {
            Process preload = ProcessCreator.CreateTestRunnerProc(
                string.Format("preload \"{0}\"", mPathToAssemblies),
                mPathToAssemblies);

            preload.Start();

            return(preload);
        }
        // In windows fpc -version returned ExitCode = 1, while version is successfully printed, and compilation works
        internal override ProcessResult TestBuildSystem(ProcessResult processResult)
        {
            logger.TestBuildSystem();
            processResult.Status = BuildStatus.BuildSystemTest;

            logger.CreateProcess(VersionCheckParams);
            Process proc = ProcessCreator.Create(WorkingDir, VersionCheckParams);

            processResult = ExecuteTestBuildProcess <BuildSystemNotFound>(proc, processResult);

            if (processResult.State == ProcessState.Error)
            {
                logger.TestBuildSystem(false);
                logger.EndWriting();
            }
            else
            {
                logger.TestBuildSystem(true);
            }
            return(processResult);
        }
Ejemplo n.º 11
0
        private static void RunServerProcess(string[] args)
        {
            var filename          = args[0];
            var port              = GetTcpPort(args);
            var profileServerFlag = GetProfileServerFlag(args);

            Logger.LogInfo("Server image file name is: {0}", filename);
            Logger.LogInfo("TCP port is: {0}", port);
            Logger.LogInfo("Profile server flag is: {0}", profileServerFlag);

            if (profileServerFlag)
            {
                Debug.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
                Debug.WriteLine(string.Format("Run server executable with argument (i.e. tcp port number) {0}", port));
                Debug.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
            }
            else
            {
                using (var job = new JobObject()) {
                    // Create a new Job for this process and its children.
                    Logger.LogInfo("Creating job.");
                    job.AddCurrentProcess();
                    Logger.LogInfo("Job created successfully.");

                    // Create the child process and redirect stdin, stdout, stderr.
                    var argumentLine = (port.HasValue ? port.Value.ToString() : "");
                    Logger.LogInfo("Creating server process.");
                    using (var createProcessResult = new ProcessCreator().CreateProcess(filename, argumentLine, CreateProcessOptions.Default)) {
                        Logger.LogInfo("Server process created successfully (pid={0}).", createProcessResult.Process.Id);
                        Logger.LogInfo("Waiting for server process to exit.");
                        createProcessResult.Process.WaitForExit();
                        Logger.LogInfo("Server process exit code: 0x{0:x8}.", createProcessResult.Process.ExitCode);
                    }
                }

                Logger.LogInfo("Exiting normally.");
            }
        }
Ejemplo n.º 12
0
        protected Process LaunchPackageUpdaterTestsAppWithArgs(out FileInfo appFile, string appName, string testSubfolderName, bool waitForExit)
        {
            appFile = TestAppProvider.ExtractApp(appName, testSubfolderName, this.Log);
            Arguments args = new Arguments {
                ApiUrl = this.BaseUrl
            };

            args.TelemetryKey = Apps.Keys.PackageUpdaterClient;

            Process process = ProcessCreator.Create(appFile, args, this.outputs, this.errors);

            this.Log($"Started process: {appFile.FullName}");
            process.Start();
            process.BeginOutputReadLine();
            process.BeginErrorReadLine();
            if (waitForExit)
            {
                process.WaitForExit();
                this.Log($"Finished process: {appFile.FullName}");
            }

            return(process);
        }