protected ProcessExecOutput StartProcess(IActionContext context, ProcessExecInput execInputInfo)
        {
            var execOutputInfo = ProcessExecuter.Exec(execInputInfo);

            this.OnTraceLogger(context, execInputInfo, execOutputInfo);
            this.OnCheckProcessExecOutput(context, execInputInfo, execOutputInfo);
            return(execOutputInfo);
        }
        protected virtual void OnCheckProcessExecOutput(IActionContext context, ProcessExecInput input, ProcessExecOutput output)
        {
            _ = context ?? throw new ArgumentNullException(nameof(context));
            _ = input ?? throw new ArgumentNullException(nameof(input));
            _ = output ?? throw new ArgumentNullException(nameof(output));

            if (output.TimeOut)
            {
                throw ErrorFactory.FromCode(nameof(Errors.E80001), input.MaximumTimeSeconds);
            }
            if (output.ExitCode != 0)
            {
                throw ErrorFactory.FromCode(nameof(Errors.E80000), output.ExitCode);
            }
        }
示例#3
0
 protected virtual object OnParseResult(IActionContext context, ProcessExecInput input, ProcessExecOutput output)
 {
     _ = output ?? throw new ArgumentNullException(nameof(output));
     return(output.ExitCode);
 }
 protected virtual void OnTraceLogger(IActionContext context, ProcessExecInput input, ProcessExecOutput output)
 {
     _ = context ?? throw new ArgumentNullException(nameof(context));
     _ = output ?? throw new ArgumentNullException(nameof(output));
     context.Logger?.WriteLine(output.StandardOutput);
 }
示例#5
0
        public static ProcessExecOutput Exec(ProcessExecInput input)
        {
            _ = input ?? throw new ArgumentNullException(nameof(input));
            var args = string.Join(" ", input.Arguments ?? Array.Empty <string>());

            SetCurrentProcessAppPath(input.AppPaths);
            ProcessStartInfo startInfo = new ProcessStartInfo(input.FileName, args)
            {
                WorkingDirectory       = input.WorkingDir,
                CreateNoWindow         = true,
                UseShellExecute        = false,
                RedirectStandardOutput = true,
                RedirectStandardInput  = !string.IsNullOrEmpty(input.StandardInput),
                RedirectStandardError  = true,
            };

            if (input.Envs != null)
            {
                foreach (var env in input.Envs)
                {
                    startInfo.Environment.Add(env);
                }
            }

            StringBuilder outTextBuilder = new StringBuilder();

            using (var process = System.Diagnostics.Process.Start(startInfo))
            {
                WriteStdInput(process, input.StandardInput);

                using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false))
                    using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false))
                    {
                        process.OutputDataReceived += (s, e) =>
                        {
                            if (e.Data == null)
                            {
                                outputWaitHandle.Set();
                            }
                            else
                            {
                                outTextBuilder.AppendLine(e.Data);
                            }
                        };
                        process.ErrorDataReceived += (s, e) =>
                        {
                            if (e.Data == null)
                            {
                                errorWaitHandle.Set();
                            }
                            else
                            {
                                outTextBuilder.AppendLine(e.Data);
                            }
                        };
                        process.BeginOutputReadLine();
                        process.BeginErrorReadLine();
                        var timeout = input.MaximumTimeSeconds * 1000;
                        if (process.WaitForExit(timeout) && outputWaitHandle.WaitOne(timeout) && errorWaitHandle.WaitOne(timeout))
                        {
                            return(new ProcessExecOutput
                            {
                                TimeOut = false,
                                StandardOutput = outTextBuilder.ToString(),
                                ExitCode = process.ExitCode,
                            });
                        }
                        else
                        {
                            return(new ProcessExecOutput
                            {
                                TimeOut = true,
                                StandardOutput = outTextBuilder.ToString(),
                            });
                        }
                    }
            }
        }