public void PostBuildEvents(bool pDebug, Dictionary <string, string> pArguments, out string pOutput, out ICollection <Error> pErrors) { if (!pArguments.ContainsKey(@"FlexSdkPath")) { pOutput = string.Empty; pErrors = new Error[0]; return; } ProcessArguments process = new ProcessArguments(); As3ProjectBuilder builder = new As3ProjectBuilder(pArguments[@"FlexSdkPath"]); pArguments.Remove(@"FlexSdkPath"); process.AddArgument(Path.Combine(_outputFolder, MainClassName.Replace(".", "\\") + ".as")); process.AddArgument("source-path", _outputFolder); if (pDebug) { process.AddArgument(@"debug", "true"); process.AddArgument(@"omit-trace-statements", "false"); process.AddArgument(@"verbose-stacktraces", "true"); } foreach (var argument in pArguments) { process.AddArgument(argument.Key, argument.Value); } process.AddArgument("o", Path.Combine(_outputFolder, @"..\swf\file.swf")); pErrors = builder.Compile(_outputFolder, process.ToString(), false, out pOutput); }
public void InsertRange() => Assert.Equal( new [] { "zero", "one", "two", "three", "four" }, ProcessArguments .Create("four") .InsertRange(0, "zero", "one") .InsertRange(2, new [] { "two", "three" }));
public void Insert() => Assert.Equal( new [] { "zero", "one", "two", "three", "four" }, ProcessArguments .Create("one", "three") .Insert(1, "two") .Insert(3, "four") .Insert(0, "zero"));
private static void MainInternal(ProcessArguments args) { LoadStyles(); var app = new Application(); app.Initialized += (sender, e) => AppInitialized(app, args); app.Run(); }
public void ImplicitlyExecAssemblyWithMonoOnUnix() { var exec = new Exec(ProcessArguments.Create("test.exe", "a", "b")); Assert.False(exec.Elevated); Assert.Equal( exec.Arguments, ProcessArguments.Create("mono", "test.exe", "a", "b")); }
public void CreateFromArgsFailTest() { var processArgumentsArgs = ProcessArguments.Create(new [] { "blabla" }); Assert.IsNull(processArgumentsArgs); var processArgumentsArgs2 = ProcessArguments.Create(new[] { "blabla=" }); Assert.IsNull(processArgumentsArgs2); }
public void ElevateOnMac() { var exec = new Exec( ProcessArguments.Create("installer"), ExecFlags.Elevate); Assert.True(exec.Elevated); Assert.Equal( exec.Arguments, ProcessArguments.Create("/usr/bin/sudo", "installer")); }
public void ElevateOnMacAndImplicitlyExecAssemblyWithMonoOnUnix() { var exec = new Exec( ProcessArguments.Create("test.exe", "a", "b"), ExecFlags.Elevate); Assert.True(exec.Elevated); Assert.Equal( exec.Arguments, ProcessArguments.Create("/usr/bin/sudo", "mono", "test.exe", "a", "b")); }
public void PublishesExitedEventOnError() { var arguments = new ProcessArguments("dotnet", "run --project Nopes"); var completionSource = new TaskCompletionSource <IProcessResult>(); arguments.Exited += (_, args) => completionSource.TrySetResult(args); arguments.Start(); var result = completionSource.Task.GetAwaiter().GetResult(); Assert.NotZero(result.ExitCode); }
private static void AppInitialized(Application app, ProcessArguments args) { var splash = ShowSplash(args.SplashPath); var duplex = PlatformCommon.CreateClientDuplex(args.ParentProcessId, () => new BrowserHost()); var form = new MainForm(duplex, splash); form.Show(); SettingsApplier.CenterForm(form); form.Visible = false; BrowserHost.Form = form; form.Closed += (sender, eventArgs) => app.Quit(); }
public void CreateFromNameTest() { const string ipcName = "TestMe"; var processArguments = ProcessArguments.Create(ipcName, typeof(ProcessArgumentsTest)); Assert.IsTrue(processArguments.IsValid); Assert.AreEqual(processArguments.IpcClientName, ProcessArguments.CreateIpcClientName(ipcName)); Assert.AreEqual(processArguments.IpcProcessName, ProcessArguments.CreateIpcProcessName(ipcName)); Assert.AreEqual(processArguments.IpcServerName, ProcessArguments.CreateIpcServerName(ipcName)); Assert.AreEqual(processArguments.IpcParentProgramPid, Process.GetCurrentProcess().Id); Assert.AreEqual(typeof(ProcessArgumentsTest).Assembly, processArguments.IpcAssembly); Assert.AreEqual(typeof(ProcessArgumentsTest), processArguments.IpcRemoteType); }
/// <summary> /// Constructor /// </summary> /// <param name="processArguments"></param> internal MultiProcessWorkerRunner(ProcessArguments processArguments) { m_ProcessArguments = processArguments; m_HostedType = processArguments.IpcRemoteType; AppDomain.CurrentDomain.UnhandledException += OnCurrentDomainUnhandledException; m_ParentProcess = Process.GetProcessById(processArguments.IpcParentProgramPid); m_ParentProcess.EnableRaisingEvents = true; m_ParentProcess.Exited += OnParentProcessExited; m_WorkCommands = new Queue <WorkCommand>(); }
private static void MainInternal(ProcessArguments args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.ApplicationExit += Application_ApplicationExit; var duplex = PlatformCommon.CreateClientDuplex(args.ParentProcessId, () => new BrowserHost()); var splash = ShowSplash(args.SplashPath); InitializeCef(); var form = new MainForm(duplex, splash); BrowserHost.Form = form; Application.Run(form); }
public void IgnoreElevateOnUnix() { // On VSTS the hosted Linux pool runs as root (sigh, but we can take // advantage of that fact to test that we are _not_ wrapping with // sudo if we already are root). if (Environment.GetEnvironmentVariable("TF_BUILD") == "True") { var exec = new Exec( ProcessArguments.Create("installer"), ExecFlags.Elevate); Assert.False(exec.Elevated); Assert.Equal( exec.Arguments, ProcessArguments.Create("installer")); } }
public void CreateFromArgsTest() { const string ipcName = "TestMe"; var processArguments = ProcessArguments.Create(ipcName, typeof(ProcessArgumentsTest)); var args = processArguments.ToStringArray(); var processArgumentsArgs = ProcessArguments.Create(args); Assert.IsTrue(processArgumentsArgs.IsValid); Assert.AreEqual(processArguments.IpcClientName, processArgumentsArgs.IpcClientName); Assert.AreEqual(processArgumentsArgs.IpcProcessName, processArgumentsArgs.IpcProcessName); Assert.AreEqual(processArguments.IpcServerName, processArgumentsArgs.IpcServerName); Assert.AreEqual(processArguments.IpcParentProgramPid, processArgumentsArgs.IpcParentProgramPid); Assert.AreEqual(processArguments.IpcAssembly, processArgumentsArgs.IpcAssembly); Assert.AreEqual(processArguments.IpcRemoteType, processArgumentsArgs.IpcRemoteType); }
/// <summary> /// Create a remote worker /// </summary> /// <param name="processArguments"></param> private MultiProcessWorkerClientBase(ProcessArguments processArguments) { HostedObjecType = processArguments.IpcRemoteType; m_WorkCommandResults = new ConcurrentDictionary <Guid, WorkResult>(); m_IpcCommunication = IpcCommunication <WorkCommand, WorkResult> .CreateServer(processArguments.IpcServerName, processArguments.IpcClientName); m_IpcCommunication.MessageRecived += OnIpcCommunicationMessageRecived; m_ProcessEventWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset, processArguments.IpcProcessName); m_WorkerProcess = CreateProcess(processArguments.ToString()); m_WorkerProcess.Exited += OnWorkerProcessExited; m_WorkerProcess.Disposed += OnWorkerProcessDisposed; m_WorkerProcess.Start(); }
public void ToStringTest() { const string ipcName = "TestMe"; var processArguments = ProcessArguments.Create(ipcName, typeof(ProcessArgumentsTest)); var argsString = processArguments.ToString(); var args = argsString.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); var processArgumentsArgs = ProcessArguments.Create(args); Assert.IsTrue(processArgumentsArgs.IsValid); Assert.AreEqual(processArguments.IpcClientName, processArgumentsArgs.IpcClientName); Assert.AreEqual(processArgumentsArgs.IpcProcessName, processArgumentsArgs.IpcProcessName); Assert.AreEqual(processArguments.IpcServerName, processArgumentsArgs.IpcServerName); Assert.AreEqual(processArguments.IpcParentProgramPid, processArgumentsArgs.IpcParentProgramPid); Assert.AreEqual(processArguments.IpcAssembly, processArgumentsArgs.IpcAssembly); Assert.AreEqual(processArguments.IpcRemoteType, processArgumentsArgs.IpcRemoteType); }
public ProcessOutput Execute(ProcessArguments processArguments) { using (var process = new Process()) { process.StartInfo = new ProcessStartInfo { FileName = processArguments.File, Arguments = processArguments.Arguments, CreateNoWindow = true, UseShellExecute = false, RedirectStandardOutput = true, ErrorDialog = false, }; var outputBuilder = new StringBuilder(1024); var errorOutputBuilder = new StringBuilder(1024); process.OutputDataReceived += (server, e) => { outputBuilder.Append(e.Data); }; process.ErrorDataReceived += (sender, e) => { errorOutputBuilder.Append(e.Data); }; process.Start(); process.BeginOutputReadLine(); process.BeginErrorReadLine(); process.WaitForExit(); return(new ProcessOutput { Arguments = processArguments.Arguments, File = processArguments.File, ExitCode = process.ExitCode, Output = outputBuilder.ToString(), ErrorOutput = errorOutputBuilder.ToString() }); } }
static WorkbookPackageTests() { void Git(string dir, params string [] args) => new Exec( ProcessArguments.FromCommandAndArguments("git", args), outputRedirection: null, workingDirectory: dir).RunAsync().GetAwaiter().GetResult(); if (PathToExternalWorkbooks.DirectoryExists) { Git(PathToExternalWorkbooks, "pull", "--rebase"); Git(PathToExternalWorkbooks, "submodule", "sync"); Git(PathToExternalWorkbooks, "submodule", "update", "--recursive", "--init"); } else { Git( PathToExternalWorkbooks.ParentDirectory, "clone", "--recursive", "https://github.com/xamarin/workbooks", PathToExternalWorkbooks.Name); } }
public static async Task <int> RunAsync( CancellationToken cancellationToken, Action <TimeSpan>?progressHandler, params string[] arguments) { var commandLine = ProcessArguments.FromCommandAndArguments(Path, arguments); Log.Debug("Exec {Path} {Arguments}", Path, arguments); TimeSpan progress = default; progressHandler?.Invoke(progress); return((await Exec.RunAsync(output => { switch (output.FileDescriptor) { case ConsoleRedirection.FileDescriptor.Output: Log.Debug("ffmpeg: {stdout}", output.Data.TrimEnd('\r', '\n')); break; case ConsoleRedirection.FileDescriptor.Error: Log.Debug("ffmpeg: {stderr}", output.Data.TrimEnd('\r', '\n')); var match = timespanRegex.Match(output.Data); if (match.Success && match.Groups.TryGetValue("timespan", out var timespanGroup) && TimeSpan.TryParse(timespanGroup.Value, out var timespan) && timespan != progress) { progress = timespan; progressHandler?.Invoke(progress); } break; } }, Path, arguments).ConfigureAwait(false)).ExitCode ?? -1); }
public void PostBuildEvents(bool pDebug, Dictionary<string, string> pArguments, out string pOutput, out ICollection<Error> pErrors) { if (!pArguments.ContainsKey(@"FlexSdkPath")) { pOutput = string.Empty; pErrors = new List<Error>(); return; } ProcessArguments process = new ProcessArguments(); JsProjectBuilder builder = new JsProjectBuilder(pArguments[@"FlexSdkPath"]); pArguments.Remove(@"FlexSdkPath"); process.AddArgument(Path.Combine(_outputFolder, MainClassName.Replace(".", "\\")+".as")); process.AddArgument("source-path", _outputFolder); if (pDebug) { process.AddArgument(@"debug", "true"); process.AddArgument(@"omit-trace-statements", "false"); process.AddArgument(@"verbose-stacktraces", "true"); } foreach (var argument in pArguments) { process.AddArgument(argument.Key, argument.Value); } process.AddArgument("o", Path.Combine(_outputFolder, @"..\swf\file.swf")); pErrors = builder.Compile(_outputFolder, process.ToString(), false, out pOutput); }
protected override string GenerateCommandLineCommands() { ProcessArguments arguments = null; if (!InvokeLinkerUsingMono) { arguments = ProcessArguments.Create("--verbose"); } else { var toolsPath = GetPathToMonoLinker(); Log.LogMessage(MessageImportance.High, $"Running monolinker from {toolsPath}."); arguments = ProcessArguments.Create(toolsPath); arguments = arguments.Add("--verbose"); } arguments = arguments.AddRange("--deterministic"); // add exclude features arguments = arguments.AddRange("--exclude-feature", "remoting", "--exclude-feature", "com", "--exclude-feature", "etw"); string coremode, usermode; switch ((WasmLinkMode)Enum.Parse(typeof(WasmLinkMode), LinkMode)) { case WasmLinkMode.SdkOnly: coremode = "link"; usermode = "copy"; break; case WasmLinkMode.Full: coremode = "link"; usermode = "link"; break; default: coremode = "copyused"; usermode = "copy"; break; } arguments = arguments.AddRange("-c", coremode, "-u", usermode); //the linker doesn't consider these core by default foreach (var bn in bindingNames) { arguments = arguments.AddRange("-p", coremode, bn); } if (!string.IsNullOrEmpty(LinkSkip)) { var skips = LinkSkip.Split(new[] { ';', ',', ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); foreach (var s in skips) { arguments = arguments.AddRange("-p", "copy", s); } } arguments = arguments.AddRange("-out", OutputDir); arguments = arguments.AddRange("-d", FrameworkDir); arguments = arguments.AddRange("-d", Path.Combine(FrameworkDir, "Facades")); arguments = arguments.AddRange("-b", Debug.ToString()); arguments = arguments.AddRange("-v", Debug.ToString()); // add custom link descriptions // to ensure the type, methods and/or fields are not eliminated from your application. if (LinkDescriptions != null) { foreach (var desc in LinkDescriptions) { var l = desc.GetMetadata("FullPath"); arguments = arguments.AddRange("-x", l); } } arguments = arguments.AddRange("-a", RootAssembly[0].GetMetadata("FullPath")); //we'll normally have to check most of the files because the SDK references most framework asm by default //so let's enumerate upfront var frameworkAssemblies = new HashSet <string> (StringComparer.OrdinalIgnoreCase); foreach (var f in Directory.EnumerateFiles(FrameworkDir)) { frameworkAssemblies.Add(Path.GetFileNameWithoutExtension(f)); } foreach (var f in Directory.EnumerateFiles(Path.Combine(FrameworkDir, "Facades"))) { frameworkAssemblies.Add(Path.GetFileNameWithoutExtension(f)); } // Load the runtime assemblies to be replaced in the references below var runtimeCopyLocal = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase); if (RuntimeCopyLocalAssemblies != null) { foreach (var copyAsm in RuntimeCopyLocalAssemblies) { var p = copyAsm.GetMetadata("FullPath"); if (frameworkAssemblies.Contains(Path.GetFileNameWithoutExtension(p))) { continue; } runtimeCopyLocal.Add(Path.GetFileNameWithoutExtension(p), p); } } //add references for non-framework assemblies if (Assemblies != null) { foreach (var asm in Assemblies) { var p = asm.GetMetadata("FullPath"); if (frameworkAssemblies.Contains(Path.GetFileNameWithoutExtension(p))) { continue; } if (runtimeCopyLocal.TryGetValue(Path.GetFileNameWithoutExtension(p), out var runtimePath)) { if (!string.IsNullOrEmpty(BindingsDir) && bindingNames.Contains(Path.GetFileNameWithoutExtension(p))) { runtimePath = Path.Combine(BindingsDir, Path.GetFileName(p)); } // Just in case if (File.Exists(runtimePath)) { p = runtimePath; } } arguments = arguments.AddRange("-r", p); } } if (string.IsNullOrEmpty(I18n)) { arguments = arguments.AddRange("-l", "none"); } else { var vals = I18n.Split(new[] { ',', ';', ' ', '\r', '\n', '\t' }); arguments = arguments.AddRange("-l", string.Join(",", vals)); } return(arguments.ToString()); }
public void ParseWithoutGlobs(string commandLine, params string [] expectedArguments) => Assert.Equal( expectedArguments, ProcessArguments.Parse(commandLine));
private void OnExit(object state) { if (restart) { Reset(); ProcessCallback(this); return; } bool isError; try { // An error occurred! if (gitCommand != null && gitCommand.ExitCode != 0) { isError = true; // TODO: This Plink stuff here seems misplaced. Is there a better // home for all of this stuff? For example, if I had a label called pull, // we could end up in this code incorrectly. if (Plink) { if (ProcessArguments.ToLower().Contains("pull") || ProcessArguments.ToLower().Contains("push") || ProcessArguments.ToLower().Contains("plink") || ProcessArguments.ToLower().Contains("tortoiseplink") || ProcessArguments.ToLower().Contains("remote") || ProcessString.ToLower().Contains("clone") || ProcessArguments.ToLower().Contains("clone")) { if (OutputString.ToString().Contains("successfully authenticated")) { isError = false; } if (OutputString.ToString().Contains("FATAL ERROR") && OutputString.ToString().Contains("authentication")) { var puttyError = new FormPuttyError(); puttyError.ShowDialog(); if (puttyError.RetryProcess) { Reset(); ProcessCallback(this); return; } } if (OutputString.ToString().ToLower().Contains("the server's host key is not cached in the registry") && !string.IsNullOrEmpty(UrlTryingToConnect)) { if (MessageBox.Show("The server's host key is not cached in the registry.\n\nDo you want to trust this host key and then try again?", "SSH", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.Yes) { GitCommandHelpers.RunRealCmdDetached( "cmd.exe", string.Format("/k \"\"{0}\" -T \"{1}\"\"", Settings.Plink, UrlTryingToConnect)); Reset(); ProcessCallback(this); return; } } } } } else { isError = false; } } catch { isError = true; } Done(!isError); }
public void Create(params string [] args) => Assert.Equal(args, ProcessArguments.Create(args));
public void ParseAndToStringRoundTrip(string commandLine, string expectedToString) => Assert.Equal( expectedToString, ProcessArguments.Parse(commandLine).ToString());
public override TaskStatus Run() { Info("Launching process..."); if (GeneratesFiles && !(ProcessArguments.Contains(VarFileName) && (ProcessArguments.Contains(VarOutput) && (ProcessArguments.Contains(VarFileName) || ProcessArguments.Contains(VarFileNameWithoutExtension))))) { Error("Error in process command. Please read the documentation."); return(TaskStatus.Failed); } if (!GeneratesFiles) { var startSuccessful = StartProcess(ProcessPath, ProcessArguments, HideGui); return(startSuccessful ? TaskStatus.Completed : TaskStatus.Failed); } foreach (FileInf file in SelectFiles()) { string cmd; string outputFilePath; try { cmd = ProcessArguments.Replace(string.Format("{{{0}}}", VarFilePath), string.Format("\"{0}\"", file.Path)); const string outputRegexPattern = @"{\$output:(?:\$fileNameWithoutExtension|\$fileName)(?:[a-zA-Z0-9._-]*})"; var outputRegex = new Regex(outputRegexPattern); var m = outputRegex.Match(cmd); if (m.Success) { string val = m.Value; outputFilePath = val; if (outputFilePath.Contains(VarFileNameWithoutExtension)) { outputFilePath = outputFilePath.Replace(VarFileNameWithoutExtension, Path.GetFileNameWithoutExtension(file.FileName)); } else if (outputFilePath.Contains(VarFileName)) { outputFilePath = outputFilePath.Replace(VarFileName, file.FileName); } outputFilePath = outputFilePath.Replace("{" + VarOutput + ":", Workflow.WorkflowTempFolder.Trim('\\') + "\\"); outputFilePath = outputFilePath.Trim('}'); cmd = cmd.Replace(val, "\"" + outputFilePath + "\""); } else { Error("Error in process command. Please read the documentation."); return(TaskStatus.Failed); } } catch (ThreadAbortException) { throw; } catch (Exception e) { ErrorFormat("Error in process command. Please read the documentation. Error: {0}", e.Message); return(TaskStatus.Failed); } if (StartProcess(ProcessPath, cmd, HideGui)) { Files.Add(new FileInf(outputFilePath, Id)); if (LoadAllFiles) { var files = Directory.GetFiles(Workflow.WorkflowTempFolder, "*.*", SearchOption.AllDirectories); foreach (var f in files) { if (f != outputFilePath) { Files.Add(new FileInf(f, Id)); } } } } } Info("Task finished."); return(TaskStatus.Completed); }
static void Main(string[] args) { var parameters = ProcessArguments.Parse(args); MainInternal(parameters); }
public void Empty() { Assert.Same(ProcessArguments.Empty, ProcessArguments.Create()); Assert.Same(ProcessArguments.Empty, ProcessArguments.Parse(string.Empty)); }
protected override string GenerateCommandLineCommands() { ProcessArguments arguments = null; if (!InvokeLinkerUsingMono) { arguments = ProcessArguments.Create("--verbose"); } else { var toolsPath = GetPathToMonoLinker(); Log.LogMessage(MessageImportance.High, $"Running monolinker from {toolsPath}."); arguments = ProcessArguments.Create(toolsPath); arguments = arguments.Add("--verbose"); } // add exclude features arguments = arguments.AddRange("--exclude-feature", "remoting", "--exclude-feature", "com", "--exclude-feature", "etw"); string coremode, usermode; switch ((WasmLinkMode)Enum.Parse(typeof(WasmLinkMode), LinkMode)) { case WasmLinkMode.SdkOnly: coremode = "link"; usermode = "copy"; break; case WasmLinkMode.Full: coremode = "link"; usermode = "link"; break; default: coremode = "copyused"; usermode = "copy"; break; } arguments = arguments.AddRange("-c", coremode, "-u", usermode); //the linker doesn't consider these core by default arguments = arguments.AddRange("-p", coremode, "WebAssembly.Bindings"); arguments = arguments.AddRange("-p", coremode, "WebAssembly.Net.Http"); arguments = arguments.AddRange("-p", coremode, "WebAssembly.Net.WebSockets"); if (!string.IsNullOrEmpty(LinkSkip)) { var skips = LinkSkip.Split(new[] { ';', ',', ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); foreach (var s in skips) { arguments = arguments.AddRange("-p", "copy", s); } } arguments = arguments.AddRange("-out", OutputDir); arguments = arguments.AddRange("-d", FrameworkDir); arguments = arguments.AddRange("-d", Path.Combine(FrameworkDir, "Facades")); arguments = arguments.AddRange("-b", Debug.ToString()); arguments = arguments.AddRange("-v", Debug.ToString()); arguments = arguments.AddRange("-a", RootAssembly[0].GetMetadata("FullPath")); //we'll normally have to check most of the because the SDK references most framework asm by default //so let's enumerate upfront var frameworkAssemblies = new HashSet <string> (StringComparer.OrdinalIgnoreCase); foreach (var f in Directory.EnumerateFiles(FrameworkDir)) { frameworkAssemblies.Add(Path.GetFileNameWithoutExtension(f)); } foreach (var f in Directory.EnumerateFiles(Path.Combine(FrameworkDir, "Facades"))) { frameworkAssemblies.Add(Path.GetFileNameWithoutExtension(f)); } //add references for non-framework assemblies if (Assemblies != null) { foreach (var asm in Assemblies) { var p = asm.GetMetadata("FullPath"); if (frameworkAssemblies.Contains(Path.GetFileNameWithoutExtension(p))) { continue; } arguments = arguments.AddRange("-r", p); } } if (string.IsNullOrEmpty(I18n)) { arguments = arguments.AddRange("-l", "none"); } else { var vals = I18n.Split(new[] { ',', ';', ' ', '\r', '\n', '\t' }); arguments = arguments.AddRange("-l", string.Join(",", vals)); } return(arguments.ToString()); }
public void Quote(string unquoted, string quoted) => Assert.Equal(quoted, ProcessArguments.Quote(unquoted));