private static async Task <bool> IsInsideGitWorkTreeAsync(DirectoryInfo outputDirectory)
        {
            var gitDiff = new ProcessStartInfo("git")
            {
                Arguments        = ArgumentEscaper.EscapeAndConcatenate(new[] { "rev-parse", "--is-inside-work-tree" }),
                WorkingDirectory = outputDirectory.FullName
            };

            using var stdout = new StringWriter();
            int exitCode = await gitDiff.GetExitCodeAsync(stdout, stdErr : TextWriter.Null);

            return(exitCode == 0);
        }
Example #2
0
        private void StartProcess(string directory)
        {
            const string exeName = "ワガママハイスペック.exe";

            this._process = Process.Start(
                "wine",
                ArgumentEscaper.EscapeAndConcatenate(new[] { JoinPathInWindows(directory, exeName), "-forcelog=clear" }));

            var logFilePath = Path.Combine(ToUnixPath(directory), "savedata", "krkr.console.log");

            // プロセス開始から 5 秒間はログファイルにアクセスさせない
            var allowedToAccessAt = DateTime.UtcNow.AddTicks(5 * TimeSpan.TicksPerSecond);

            var logObservable =
                Observable.Create <string>(async(observer, cancellationToken) =>
            {
                var now = DateTime.UtcNow;
                if (now < allowedToAccessAt)
                {
                    await Task.Delay(allowedToAccessAt - now, cancellationToken).ConfigureAwait(false);
                }

                using (var reader = new LogFileReader(logFilePath))
                {
                    reader.SeekToLastLine();

                    while (true)
                    {
                        while (reader.Read() is string log)
                        {
                            observer.OnNext(log);
                        }

                        await Task.Delay(500, cancellationToken).ConfigureAwait(false);
                    }
                }
            })
                .Merge(
                    Observable.FromEventPattern(
                        x => this._process.Exited += x,
                        x => { if (this._process != null)
                               {
                                   this._process.Exited -= x;
                               }
                        }
                        )
                    .SelectMany(_ => s_processExitedObservable)
                    );

            this._logStream = Observable.Create <string>(observer => (this._process.HasExited ? s_processExitedObservable : logObservable).Subscribe(observer));
        }
Example #3
0
        public Task <CommandResult> ExecuteAsync(bool throwOnFailure = false)
        {
            var tcs           = new TaskCompletionSource <CommandResult>();
            var exeName       = Path.GetFileNameWithoutExtension(ExecutablePath);
            var formattedArgs = ArgumentEscaper.EscapeAndConcatenate(Arguments);
            var process       = new Process()
            {
                StartInfo = new ProcessStartInfo()
                {
                    FileName               = ExecutablePath,
                    Arguments              = formattedArgs,
                    WorkingDirectory       = WorkingDirectory,
                    RedirectStandardError  = true,
                    RedirectStandardOutput = true,
                }
            };

            process.EnableRaisingEvents = true;

            var stdout = new StringBuilder();
            var stderr = new StringBuilder();

            process.ErrorDataReceived  += (sender, a) => ProcessDataReceived(a, stderr, _standardErrorHandler);
            process.OutputDataReceived += (sender, a) => ProcessDataReceived(a, stdout, _standardOutputHandler);

            process.Exited += (sender, a) =>
            {
                _logger.LogDebug("'{Command} {Arguments}' exited with code {ExitCode}", exeName, formattedArgs, process.ExitCode);
                if (process.ExitCode != 0 && throwOnFailure)
                {
                    tcs.TrySetException(new CommandLineException($"Command '{exeName} {formattedArgs}' failed with exit code {process.ExitCode}!"));
                }
                else
                {
                    tcs.TrySetResult(new CommandResult(process.ExitCode, stdout.ToString(), stderr.ToString()));
                }
            };

            _logger.LogInformation("Running '{Command} {Arguments}'", exeName, formattedArgs);
            process.Start();
            process.BeginErrorReadLine();
            process.BeginOutputReadLine();
            return(tcs.Task);

            void ProcessDataReceived(DataReceivedEventArgs args, StringBuilder buffer, Action <string> handler)
            {
                buffer.AppendLine(args.Data);
                handler?.Invoke(args.Data);
                _logger.LogDebug(args.Data);
            }
        }
Example #4
0
        public override bool Execute()
        {
            if (string.IsNullOrEmpty(RuleFile) || !File.Exists(RuleFile))
            {
                Log.LogError($"RuleFile '{RuleFile}' does not exist");
                return(false);
            }

            if (ArtifactDirectory == null || ArtifactDirectory.Length == 0)
            {
                Log.LogError($"At least one ArtifactDirectory must exist.");
                return(false);
            }

            var taskAssemblyFolder = Path.GetDirectoryName(GetType().GetTypeInfo().Assembly.Location);
            var toolPath           = Path.Combine(taskAssemblyFolder, "..", "..", ConsoleAppExe);

            if (!File.Exists(toolPath))
            {
                toolPath = Path.Combine(taskAssemblyFolder, ConsoleAppExe);
            }

            var dotnetMuxer = DotNetMuxer.MuxerPathOrDefault();
            var arguments   = new List <string>
            {
                toolPath,
                "--rule-file",
                RuleFile,
            };

            foreach (var rule in ExcludedRules ?? Enumerable.Empty <string>())
            {
                arguments.Add("--excluded-rule");
                arguments.Add(rule);
            }

            arguments.AddRange(ArtifactDirectory);

            var psi = new ProcessStartInfo
            {
                FileName  = dotnetMuxer,
                Arguments = ArgumentEscaper.EscapeAndConcatenate(arguments),
            };

            Log.LogCommandLine($"Executing '{psi.FileName} {psi.Arguments}'");

            var process = Process.Start(psi);

            process.WaitForExit();
            return(process.ExitCode == 0);
        }
Example #5
0
        public static int Run(
            string executable,
            IReadOnlyList <string> args,
            IReporter reporter,
            string workingDirectory = null,
            bool interceptOutput    = false)
        {
            var arguments = ArgumentEscaper.EscapeAndConcatenate(args);

            reporter.WriteVerbose(executable + " " + arguments);

            var startInfo = new ProcessStartInfo
            {
                FileName               = executable,
                Arguments              = arguments,
                UseShellExecute        = false,
                RedirectStandardOutput = interceptOutput
            };

            if (workingDirectory != null)
            {
                startInfo.WorkingDirectory = workingDirectory;
            }

            using var process = Process.Start(startInfo);
            if (interceptOutput)
            {
                string line;
                while ((line = process.StandardOutput.ReadLine()) != null)
                {
                    reporter.WriteVerbose(line);
                }
            }

            // Follow precedent set in Razor integration tests and ensure process events and output are complete.
            // https://github.com/aspnet/Razor/blob/d719920fdcc7d1db3a6f74cd5404d66fa098f057/test/Microsoft.NET.Sdk.Razor.Test/IntegrationTests/MSBuildProcessManager.cs#L91-L102
            // Timeout is double how long the inside man waits for the IDocumentProcessor to wrap up.
            if (!process.WaitForExit((int)(TimeSpan.FromMinutes(2).TotalMilliseconds)))
            {
                process.Kill();

                // Should be unreachable in almost every case.
                throw new TimeoutException($"Process {executable} timed out after 2 minutes.");
            }

            process.WaitForExit();

            return(process.ExitCode);
        }
Example #6
0
        private ICommand GetRunCommand()
        {
            var globalProperties = new Dictionary <string, string>
            {
                { Constants.MSBuildExtensionsPath, AppContext.BaseDirectory }
            };

            if (!string.IsNullOrWhiteSpace(Configuration))
            {
                globalProperties.Add("Configuration", Configuration);
            }

            if (!string.IsNullOrWhiteSpace(Framework))
            {
                globalProperties.Add("TargetFramework", Framework);
            }

            ProjectInstance projectInstance = new ProjectInstance(Project, globalProperties, null);

            string runProgram = projectInstance.GetPropertyValue("RunCommand");

            if (string.IsNullOrEmpty(runProgram))
            {
                string outputType = projectInstance.GetPropertyValue("OutputType");

                throw new GracefulException(
                          string.Format(
                              LocalizableStrings.RunCommandExceptionUnableToRun,
                              "dotnet run",
                              "OutputType",
                              outputType));
            }

            string runArguments        = projectInstance.GetPropertyValue("RunArguments");
            string runWorkingDirectory = projectInstance.GetPropertyValue("RunWorkingDirectory");

            string fullArguments = runArguments;

            if (_args.Any())
            {
                fullArguments += " " + ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(_args);
            }

            CommandSpec commandSpec = new CommandSpec(runProgram, fullArguments, CommandResolutionStrategy.None);

            return(Command.Create(commandSpec)
                   .WorkingDirectory(runWorkingDirectory));
        }
Example #7
0
        private CommandResult RunProcess(string executable, string[] args, StreamForwarder stdOut, StreamForwarder stdErr)
        {
            var psi = new ProcessStartInfo
            {
                FileName               = executable,
                Arguments              = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(args),
                RedirectStandardError  = true,
                RedirectStandardOutput = true
            };

            Log("Executing: ".Bold().Blue() + $"{psi.FileName} {psi.Arguments}");

            foreach (var item in Environment)
            {
                psi.Environment[item.Key] = item.Value;
            }

            if (!string.IsNullOrWhiteSpace(WorkingDirectory))
            {
                psi.WorkingDirectory = WorkingDirectory;
                Log($"Working directory: {WorkingDirectory}");
            }

            var process = new Process
            {
                StartInfo           = psi,
                EnableRaisingEvents = true
            };

            using (process)
            {
                process.Start();

                var threadOut = stdOut.BeginRead(process.StandardOutput);
                var threadErr = stdErr.BeginRead(process.StandardError);

                process.WaitForExit();
                Task.WaitAll(threadOut, threadErr);

                var result = new CommandResult(
                    process.StartInfo,
                    process.ExitCode,
                    stdOut.CapturedOutput,
                    stdErr.CapturedOutput);

                return(result);
            }
        }
        private static async Task <string?> GetLatestMsBuildExePathAsync()
        {
            var vsWhereExe = Environment.ExpandEnvironmentVariables(@"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe");
            var args       = new[] { "-latest", "-prerelease", "-products", "*", "-requires", "Microsoft.Component.MSBuild", "-version", "[16.0,]", "-find", @"MSBuild\**\Bin\MSBuild.exe" };

            var(exitCode, stdOut, _) = await new ProcessStartInfo(vsWhereExe)
            {
                Arguments = ArgumentEscaper.EscapeAndConcatenate(args)
            }.GetOutputAsync();

            if (exitCode == 0 && !string.IsNullOrWhiteSpace(stdOut))
            {
                return(stdOut);
            }
            return(null);
        }
Example #9
0
        private Process StartLauncher(params string[] args)
        {
            var startInfo = new ProcessStartInfo
            {
                Arguments              = ArgumentEscaper.Escape(args),
                FileName               = "Launcher.exe",
                RedirectStandardError  = true,
                RedirectStandardOutput = true,
                UseShellExecute        = false
            };
            var proc = Process.Start(startInfo);

            proc.should_not_be_null();
            proc.WaitForExit();
            return(proc);
        }
        public CommandSpec Resolve(CommandResolverArguments commandResolverArguments)
        {
            if (commandResolverArguments.CommandName == null)
            {
                return(null);
            }

            if (Path.IsPathRooted(commandResolverArguments.CommandName))
            {
                var escapedArgs = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(
                    commandResolverArguments.CommandArguments.OrEmptyIfNull());

                return(new CommandSpec(commandResolverArguments.CommandName, escapedArgs));
            }

            return(null);
        }
        private static Command CreateCommand(string path, IEnumerable <string> args)
        {
            var psi = new ProcessStartInfo
            {
                FileName        = path,
                Arguments       = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(args),
                UseShellExecute = false
            };


            var _process = new Process
            {
                StartInfo = psi
            };

            return(new Command(_process));
        }
Example #12
0
        private ICommand GetRunCommand()
        {
            Dictionary <string, string> globalProperties = new Dictionary <string, string>()
            {
                { "MSBuildExtensionsPath", AppContext.BaseDirectory }
            };

            if (!string.IsNullOrWhiteSpace(Configuration))
            {
                globalProperties.Add("Configuration", Configuration);
            }

            if (!string.IsNullOrWhiteSpace(Framework))
            {
                globalProperties.Add("TargetFramework", Framework);
            }

            ProjectInstance projectInstance = new ProjectInstance(Project, globalProperties, null);

            string runProgram = projectInstance.GetPropertyValue("RunCommand");

            if (string.IsNullOrEmpty(runProgram))
            {
                string outputType = projectInstance.GetPropertyValue("OutputType");

                throw new GracefulException(string.Join(Environment.NewLine,
                                                        "Unable to run your project.",
                                                        "Please ensure you have a runnable project type and ensure 'dotnet run' supports this project.",
                                                        $"The current OutputType is '{outputType}'."));
            }

            string runArguments        = projectInstance.GetPropertyValue("RunArguments");
            string runWorkingDirectory = projectInstance.GetPropertyValue("RunWorkingDirectory");

            string fullArguments = runArguments;

            if (_args.Any())
            {
                fullArguments += " " + ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(_args);
            }

            CommandSpec commandSpec = new CommandSpec(runProgram, fullArguments, CommandResolutionStrategy.None);

            return(Command.Create(commandSpec)
                   .WorkingDirectory(runWorkingDirectory));
        }
        private static async Task <bool> IsGitDiffEmptyAsync(DirectoryInfo outputDirectory)
        {
            var gitDiff = new ProcessStartInfo("git")
            {
                Arguments        = ArgumentEscaper.EscapeAndConcatenate(new[] { "diff", "--exit-code", "--relative", "--summary", "--diff-filter=ACMRTUXB*" }),
                WorkingDirectory = outputDirectory.FullName
            };

            using var stdout = new StringWriter();
            int exitCode = await gitDiff.GetExitCodeAsync(stdout);

            if (exitCode == 1)
            {
                Console.WriteLine(stdout.ToString());
            }
            return(exitCode == 0);
        }
Example #14
0
        private ICommand GetRunCommand()
        {
            Dictionary <string, string> globalProperties = new Dictionary <string, string>()
            {
                { LocalizableStrings.RunCommandMSBuildExtensionsPath, AppContext.BaseDirectory }
            };

            if (!string.IsNullOrWhiteSpace(Configuration))
            {
                globalProperties.Add(LocalizableStrings.RunCommandConfiguration, Configuration);
            }

            if (!string.IsNullOrWhiteSpace(Framework))
            {
                globalProperties.Add(LocalizableStrings.RunCommandTargetFramework, Framework);
            }

            ProjectInstance projectInstance = new ProjectInstance(Project, globalProperties, null);

            string runProgram = projectInstance.GetPropertyValue(LocalizableStrings.RunCommandProjectInstance);

            if (string.IsNullOrEmpty(runProgram))
            {
                string outputType = projectInstance.GetPropertyValue(LocalizableStrings.RunCommandOutputType);

                throw new GracefulException(string.Join(Environment.NewLine,
                                                        LocalizableStrings.RunCommandExceptionUnableToRun1,
                                                        LocalizableStrings.RunCommandExceptionUnableToRun2,
                                                        $"{LocalizableStrings.RunCommandExceptionUnableToRun3} '{outputType}'."));
            }

            string runArguments        = projectInstance.GetPropertyValue(LocalizableStrings.RunCommandRunArguments);
            string runWorkingDirectory = projectInstance.GetPropertyValue(LocalizableStrings.RunCommandRunWorkingDirectory);

            string fullArguments = runArguments;

            if (_args.Any())
            {
                fullArguments += " " + ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(_args);
            }

            CommandSpec commandSpec = new CommandSpec(runProgram, fullArguments, CommandResolutionStrategy.None);

            return(Command.Create(commandSpec)
                   .WorkingDirectory(runWorkingDirectory));
        }
Example #15
0
        public int Execute(bool redirectOutput)
        {
            var arguments = ArgumentEscaper.EscapeAndConcatenate(_arguments);

            var processStartInfo = new ProcessStartInfo
            {
                UseShellExecute        = false,
                FileName               = _processPath,
                Arguments              = arguments,
                RedirectStandardOutput = redirectOutput,
                RedirectStandardError  = redirectOutput,
            };

            Log.Debug($"Executing {_processPath}");
            Log.Debug($"Arguments: {arguments}");

            var process = new Process
            {
                StartInfo = processStartInfo
            };

            try
            {
                process.Start();
                process.WaitForExit();
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                Log.Error(e.Message);

                Log.Fatal($"Error executing process {_processPath}");
            }

            if (process.ExitCode == 0)
            {
                RedirectOutput(redirectOutput, process, false, _isGenerator, _receiveOutput);
            }
            else
            {
                RedirectOutput(redirectOutput, process, true, _isGenerator, _receiveOutput);
            }

            return(process.ExitCode);
        }
Example #16
0
        private int ExecuteScript(ITestOutputHelper output, string script, string[] koreBuildArgs, params string[] commandArgs)
        {
            output.WriteLine("Starting in " + WorkingDirectory);

            var    arguments = new List <string>();
            string cmd;

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                cmd = "cmd.exe";
                arguments.Add("/C");
                arguments.Add($@".\{script}.cmd");
            }
            else
            {
                cmd = "bash";
                arguments.Add($"./{script}.sh");
            }

            arguments.AddRange(koreBuildArgs);

            arguments.AddRange(new[]
            {
                "-ToolsSource", _toolsSource,
                "-Reinstall",
            });

            arguments.AddRange(commandArgs);

            arguments.Add("/bl:" + _logFile);

            var psi = new ProcessStartInfo
            {
                FileName               = cmd,
                Arguments              = ArgumentEscaper.EscapeAndConcatenate(arguments),
                RedirectStandardError  = true,
                RedirectStandardOutput = true,
                UseShellExecute        = false,

                WorkingDirectory = WorkingDirectory,
            };

            return(Run(output, psi));
        }
Example #17
0
        public ProcessStartInfo GetProcessStartInfo()
        {
            var processInfo = new ProcessStartInfo
            {
                FileName        = GetHostExeName(),
                Arguments       = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(_allArgs),
                UseShellExecute = false
            };

            if (_environmentVariables != null)
            {
                foreach (var entry in _environmentVariables)
                {
                    processInfo.Environment[entry.Key] = entry.Value;
                }
            }

            return(processInfo);
        }
        private async Task Nuget(params string[] args)
        {
            var pInfo = new ProcessStartInfo
            {
                Arguments = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(args),
                FileName  = await GetNugetExePath()
            };

            Console.WriteLine("command:   ".Bold().Blue() + pInfo.FileName);
            Console.WriteLine("arguments: ".Bold().Blue() + pInfo.Arguments);

            var p = Process.Start(pInfo);

            p.WaitForExit();
            if (p.ExitCode != 0)
            {
                throw new InvalidOperationException("nuget.exe command returned non-zero exit code: " + p.ExitCode);
            }
        }
Example #19
0
        private static VsInstallation[] GetInstallations(List <string> args, TaskLoggingHelper log)
        {
            args.Add("-format");
            args.Add("json");

            var vswhere = GetVsWherePath();
            var process = new Process
            {
                StartInfo =
                {
                    FileName  = vswhere,
                    Arguments = ArgumentEscaper.EscapeAndConcatenate(args),
                    RedirectStandardOutput = true,
                    UseShellExecute        = false,
                    CreateNoWindow         = true,
                }
            };

            log.LogCommandLine(process.StartInfo.FileName + " " + process.StartInfo.Arguments);

            try
            {
                process.Start();
                process.WaitForExit();
            }
            catch (Exception ex)
            {
                log.LogError("vswhere failed." + ex.Message);
                return(Array.Empty <VsInstallation>());
            }

            var output = process.StandardOutput.ReadToEnd();

            if (process.ExitCode != 0)
            {
                log.LogMessage(MessageImportance.Low, "vswhere output = " + output);
                log.LogError("vswhere failed.");
                return(Array.Empty <VsInstallation>());
            }

            return(JsonConvert.DeserializeObject <VsInstallation[]>(output));
        }
Example #20
0
        void ExecuteDeploymentProvider(IConsole console)
        {
            var providerToExecute = Path.Combine(
                ToolsDirectory,
                string.Concat("dotnet-deploy-", Provider)
                );

            var psi = new ProcessStartInfo
            {
                FileName  = providerToExecute,
                Arguments = ArgumentEscaper.EscapeAndConcatenate(RemainingArgs),
                RedirectStandardOutput = true,
                RedirectStandardError  = true,
            };

            var process = Process.Start(psi);

            process.WaitForExit();
            console.Out.WriteLine(process.StandardOutput.ReadToEnd());
        }
Example #21
0
        private ICommand GetRunCommand()
        {
            var globalProperties = new Dictionary <string, string>
            {
                { Constants.MSBuildExtensionsPath, AppContext.BaseDirectory }
            };

            if (!string.IsNullOrWhiteSpace(Configuration))
            {
                globalProperties.Add("Configuration", Configuration);
            }

            if (!string.IsNullOrWhiteSpace(Framework))
            {
                globalProperties.Add("TargetFramework", Framework);
            }

            Project project = new Project(Project, globalProperties, null);

            string runProgram = project.GetPropertyValue("RunCommand");

            if (string.IsNullOrEmpty(runProgram))
            {
                ThrowUnableToRunError(project);
            }

            string runArguments        = project.GetPropertyValue("RunArguments");
            string runWorkingDirectory = project.GetPropertyValue("RunWorkingDirectory");

            string fullArguments = runArguments;

            if (_args.Any())
            {
                fullArguments += " " + ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(_args);
            }

            CommandSpec commandSpec = new CommandSpec(runProgram, fullArguments, CommandResolutionStrategy.None);

            return(Command.Create(commandSpec)
                   .WorkingDirectory(runWorkingDirectory));
        }
Example #22
0
        public void Start()
        {
            if (_process != null)
            {
                throw new InvalidOperationException("Already started");
            }

            _process = new Process
            {
                EnableRaisingEvents = true,
                StartInfo           = new ProcessStartInfo
                {
                    UseShellExecute        = false,
                    FileName               = _spec.Executable,
                    WorkingDirectory       = _spec.WorkingDirectory,
                    Arguments              = ArgumentEscaper.EscapeAndConcatenate(_spec.Arguments),
                    RedirectStandardOutput = true,
                    RedirectStandardError  = true,
                    Environment            =
                    {
                        ["DOTNET_SKIP_FIRST_TIME_EXPERIENCE"] = "true"
                    }
                }
            };

            foreach (var env in _spec.EnvironmentVariables)
            {
                _process.StartInfo.EnvironmentVariables[env.Key] = env.Value;
            }

            _process.OutputDataReceived += OnData;
            _process.ErrorDataReceived  += OnData;
            _process.Exited             += OnExit;

            WriteTestOutput($"{DateTime.Now}: starting process: '{_process.StartInfo.FileName} {_process.StartInfo.Arguments}'");
            _process.Start();
            _started = true;
            _process.BeginErrorReadLine();
            _process.BeginOutputReadLine();
            WriteTestOutput($"{DateTime.Now}: process started: '{_process.StartInfo.FileName} {_process.StartInfo.Arguments}'");
        }
Example #23
0
    public static int Main(string[] args)
    {
        var app = new CommandLineApplication
        {
            AllowArgumentSeparator       = true,
            UnrecognizedArgumentHandling = UnrecognizedArgumentHandling.StopParsingAndCollect,
        };

        var showMilliseconds = app.Option <int>("-m", "Show time in milliseconds", CommandOptionType.NoValue);

        app.OnExecute(() =>
        {
            var timer = Stopwatch.StartNew();
            if (app.RemainingArguments != null && app.RemainingArguments.Count > 0)
            {
                var process = new Process
                {
                    StartInfo =
                    {
                        FileName  = app.RemainingArguments[0],
                        Arguments = ArgumentEscaper.EscapeAndConcatenate(app.RemainingArguments.Skip(1)),
                    }
                };
                process.Start();
                process.WaitForExit();
            }

            timer.Stop();

            if (showMilliseconds.HasValue())
            {
                Console.WriteLine($"Time = {timer.Elapsed.TotalMilliseconds} ms");
            }
            else
            {
                Console.WriteLine($"Time = {timer.Elapsed.TotalSeconds}s");
            }
        });

        return(app.Execute(args));
    }
Example #24
0
        public static string StartServerIfNotStarted(IConsole console, string ffmpegPath = null, string ffprobePath = null)
        {
            if (WebServerUtils.IsServerAlive())
            {
                console.WriteLine("Server is alive, getting its port...");
                var port = WebServerUtils.GetServerPort();
                if (port.HasValue)
                {
                    return(WebServerUtils.GetWebServerIpAddress(port.Value));
                }
                console.WriteLine("Couldn't retrieve the server port");
                return(null);
            }

            var dir  = Directory.GetCurrentDirectory();
            var path = Path.Combine(dir, "Server", WebServerUtils.ServerProcessName);

            console.WriteLine($"Trying to start process located in = {path}");
//#if DEBUG
//            path = "E:\\Proyectos\\CastIt\\CastIt.Server\\bin\\Debug\\net5.0\\CastIt.Server.exe";
//#endif

            console.WriteLine("Web server is not running, starting it...");
            var openPort = WebServerUtils.GetOpenPort();
            var args     = new[]
            {
                AppWebServerConstants.PortArgument, $"{openPort}",
                AppWebServerConstants.FFmpegPathArgument, ffmpegPath,
                AppWebServerConstants.FFprobePathArgument, ffprobePath
            };
            var  escapedArgs = ArgumentEscaper.EscapeAndConcatenate(args);
            bool started     = WebServerUtils.StartServer(escapedArgs, path);

            if (started)
            {
                return(WebServerUtils.GetWebServerIpAddress(openPort));
            }

            console.WriteLine("Couldn't start the web server");
            return(null);
        }
Example #25
0
        public static int Main(string[] args)
        {
            var processInfo = new ProcessStartInfo()
            {
                FileName        = Path.Combine(Path.GetDirectoryName(typeof(Program).GetTypeInfo().Assembly.Location), "tool", "package_tool"),
                Arguments       = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(args),
                UseShellExecute = false
            };

            Console.WriteLine($"dotnet-deb-tool: executing - {processInfo.FileName} {processInfo.Arguments}");

            var process = new Process()
            {
                StartInfo = processInfo
            };

            process.Start();
            process.WaitForExit();

            return(process.ExitCode);
        }