public virtual void Compile() { var slnFile = CompileConfiguration.SlnPath; slnFile = ProcessCommand.ToArgumentPath(slnFile); DotNetBuild($" {slnFile} -c release"); }
private void DataReceivedEvent(object sender, SerialDataReceivedEventArgs e) { SerialPort tty = (SerialPort)sender; while (tty.IsOpen && tty.BytesToRead > 0) { char c = (char)tty.ReadByte(); //Console.WriteLine($"[RAW] {c}"); switch (c) { case '\r': // ignore windows line ending case '\n': break; case ':': // cmd start Buffer_RX.Reset(); break; case '#': // cmd end ProcessCommand?.Invoke(this, EventArgs.Empty); break; default: try { Buffer_RX.Enqueue(c); } catch {; } break; } } }
public void TestProcessCommand_OnProcessError() { // Preconditions Debug.Assert(managerMock != null); Debug.Assert(outputMock != null); /* GIVEN */ managerMock. Setup(manager => manager.Process(It.IsAny <IEnumerable <DirectoryPath> >()))? .Throws(new InvalidOperationException()); var command = new ProcessCommand(managerMock.Object, outputMock.Object); var options = new ProcessOptions { IsVerbose = false, ConfigPath = Assembly.GetExecutingAssembly().Location, InputFile = "C:/" }; /* WHEN */ var returnCode = command.Execute(options); /* THEN */ // We test if the command failed and returned code -1. Assert.AreEqual(failCode, returnCode); managerMock.Verify(manager => manager.Process(It.IsAny <IEnumerable <DirectoryPath> >()), Times.Once); outputMock.Verify(output => output.PrintError(It.IsAny <InvalidOperationException>()), Times.Once); }
public CommandPipeline(IEventstore es, LoadContextModel load, ProcessCommand process, UpdateContextModel update) { _es = es; _load = load; _process = process; _update = update; }
public async Task <APIResult> ProcessOrder([FromBody] ProcessCommand command) { return(new APIResult() { Result = await mediator.Send(command) }); }
public IEnumerator SendProcessCommandRoutine(ProcessCommand command) { MemoryStream stream = new MemoryStream(); Serializer.Serialize(stream, command); string data = System.Convert.ToBase64String(stream.ToArray()); string uri = NetworkSettings.instance.BaseUri() + "/api/process_manager"; var form = new WWWForm(); form.AddField("process_command", data); WWW www = new WWW(uri, form.data, form.headers); yield return(www); if (www.error != null) { Debug.Log(www.error); onProcessCommand(false); } else { onProcessCommand(true); Debug.Log(www.text); } }
static void Main(string[] args) { var appConfigurator = AppConfigurator.GetAppConfigurator(); var appConfiguratorDefault = appConfigurator.Default; var(ownerCommand, runningCommand) = SubCommandParser.ParseCommandlineValue(args); if (runningCommand.Count == 0) { return; } // 其中的 OwnerCommand 先忽略 // 判断 runningCommand 是否存在需要转换的参数 var actualCommandline = CommandlineEngine.FillCommandline(runningCommand.ToArray(), appConfiguratorDefault); var commandlineArgString = new StringBuilder(); for (var i = 1; i < actualCommandline.Length; i++) { var arg = actualCommandline[i]; Console.WriteLine($"[{i}] = {arg}"); commandlineArgString.Append(ProcessCommand.ToArgumentPath(arg)); commandlineArgString.Append(' '); } var arguments = commandlineArgString.ToString(); Console.WriteLine($"Command = {actualCommandline[0]} {arguments}"); var(success, output) = ProcessCommand.ExecuteCommand(actualCommandline[0], arguments); Console.WriteLine(output); }
private static void ExecuteProcess(ProcessCommand command) { string error; using (Process process = Process.Start(StorageEmulatorProcessFactory.Create(command))) { Stopwatch sw = new Stopwatch(); sw.Start(); if (process == null) { throw new InvalidOperationException("Unable to start process."); } error = GetError(process); while (!GetStatus(process) || sw.ElapsedMilliseconds > 30000) { ".".Write(); Thread.Sleep(500); } } if (!String.IsNullOrEmpty(error)) { throw new InvalidOperationException(error); } }
private void ToggleCopyButton() { if (copyManager != null) { btnCopy.Text = btnCopy.Text.ToLowerInvariant().Contains("copy") ? "Cancel" : "Copy"; CopyState = ProcessCommand.Analyzing; } }
public MainViewModel(Windows windows) { processCommand = new ProcessCommand(windows); logCommand = new LogCommand(windows); configurationCommand = new ConfigurationCommand(windows); Process process = new Process(windows); windows.Grid.Children.Add(process); }
public void SumSidesAndCompare() { Dugovna = Entries.Sum(x => x.Dugovna); Potrazna = Entries.Sum(x => x.Potrazna); SidesEqual = Dugovna == Potrazna; ProcessCommand.RaiseCanExecuteChanged(); }
private static void FormatCode() { var(_, output) = ProcessCommand.ExecuteCommand("dotnet", "tool update -g dotnet-format"); Console.WriteLine(output); // dotnet format Console.WriteLine($"Start dotnet format"); ProcessCommand.ExecuteCommand("dotnet", "format"); Console.WriteLine($"Finish dotnet format"); }
public void RunProcessCommandReturnsFailure() { var command = new ProcessCommand(null) { Process = "CMD.EXE", Arguments = "/c BADCOMMAND" }; object actual = command.Execute(); Assert.AreEqual(1, actual); }
protected (bool success, string output) DotNetBuild(string command = "") { if (string.IsNullOrEmpty(command)) { command = $" {ProcessCommand.ToArgumentPath(CompileConfiguration.SlnPath)}"; } (bool success, string output) = ExecuteProcessCommand("dotnet", $"build {command}"); return(success, output); }
public void RunProcessCommandNoArgsTest() { var command = new ProcessCommand(null) { Process = "NOTEPAD.EXE" }; object actual = command.Execute(); Assert.AreEqual(0, actual); }
//======================================================================= Event entry points for unmanaged wrapper // ReSharper disable UnusedMember.Local private bool OnProcessCommand(UInt64 serverConnectionHandlerID, string command) { if (ProcessCommand != null) { var args = new ProcessCommandEventArgs(new ServerConnectionHandler(serverConnectionHandlerID), command); ProcessCommand.Invoke(args); return(args.Handled); } return(false); }
public void RunProcessCommandEmptyArgsTest() { var command = new ProcessCommand(null) { Process = "NOTEPAD.EXE", Arguments = string.Empty }; object actual = command.Execute(); Assert.AreEqual(0, actual); }
private async void OnStartDownloadAsync() { var dialog = new VistaFolderBrowserDialog { RootFolder = System.Environment.SpecialFolder.MyDocuments }; if ((bool)!dialog.ShowDialog()) { return; } string directory = dialog.SelectedPath; tokenSource = new CancellationTokenSource(); var token = tokenSource.Token; IsWorking = true; try { foreach (Link link in Links) { if (link.LinkStatus == Status.Finished) { continue; } currentLink = link; link.LinkStatus = Status.Downloading; string cmd = link.ExtractAudio ? $"-x --audio-format m4a {link.Url}" : link.Url; var process = new ProcessCommand(cmd, directory, token); await Task.Run(() => DownloadClient.downloadAsync(process, token), token); if (link.LinkStatus == Status.Failed) { link.Eta = "Failed"; continue; } link.LinkStatus = Status.Finished; link.Progress = 100.0; link.Eta = "Finished"; try { NormalizeName(directory); } catch (Exception) { } } } catch (OperationCanceledException) { currentLink.LinkStatus = Status.Failed; currentLink.Eta = "Canceled"; } IsWorking = false; tokenSource.Dispose(); }
public static ProcessStartInfo Create(ProcessCommand command) { return(new ProcessStartInfo { FileName = @"C:\Program Files (x86)\Microsoft SDKs\Azure\Storage Emulator\AzureStorageEmulator.exe", Arguments = command.ToString().ToLower(), RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false, CreateNoWindow = true }); }
public static bool TryGetProcessInfo(string command, out ProcessCommand process) { Guard.AgainstEmpty(command, nameof(command)); if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { command = TrimCommand(command); } process = commands.FirstOrDefault(x => x.Command == command); return(!process.Equals(default(ProcessCommand))); }
public static void Handle(byte[] packet, Socket clientSocket) { ushort packetLength = BitConverter.ToUInt16(packet, 0); byte[] data = new byte[packetLength]; Array.Copy(packet, 2, data, 0, packetLength); string commandName = Encoding.Default.GetString(data); byte[] res = ProcessCommand.Execute(commandName); // a reason why ProcessCommand is an inner class clientSocket.Send(res); }
private void RaiseButtonNotifications() { AddTgFileCommand.RaiseCanExecuteChangedNotification(); AddTgFolderCommand.RaiseCanExecuteChangedNotification(); RemoveTgFileCommand.RaiseCanExecuteChangedNotification(); ClearTgFilesCommand.RaiseCanExecuteChangedNotification(); ProcessCommand.RaiseCanExecuteChangedNotification(); SetOutputFolderCommand.RaiseCanExecuteChangedNotification(); LoadOutputFolderCommand.RaiseCanExecuteChangedNotification(); ExportAllCommand.RaiseCanExecuteChangedNotification(); BatchSettingsCommand.RaiseCanExecuteChangedNotification(); }
public static ProcessStartInfo Create(ProcessCommand command) { return(new ProcessStartInfo { FileName = _windowsAzureStorageEmulatorPath, Arguments = command.ToString().ToLower(), RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false, CreateNoWindow = true }); }
public static bool TryTerminateProcess(ProcessCommand processCommand) { var processId = processCommand.Process; using var processHandle = OpenProcess(4097, false, processId); if (processHandle.IsInvalid) { return(false); } TerminateProcess(processHandle, -1); return(true); }
public void RunProcessCommandTest() { string path = GetTempPath("FileCopy", true); string sourceFile = CreateTempFile(path, "SourceFile.tst"); string targetFile = CreateTempFile(path, "TargetFile.tst"); var command = new ProcessCommand(null) { Process = "CMD.EXE", Arguments = string.Format(@"/c COPY {0} {1}", sourceFile, targetFile) }; object actual = command.Execute(); Assert.AreEqual(0, actual); }
private static void ExecuteProcess(ProcessCommand command) { string error; using (Process process = Process.Start(StorageEmulatorProcessFactory.Create(command))) { if (process == null) { return; } error = GetError(process); process.WaitForExit(); } }
public void OnDialogOpened(IDialogParameters parameters) { var list = parameters.GetValue <List <AccountingJournalModel> >("entries"); _automatic = parameters.GetValue <bool>("automatic"); if (list.Count > 0) { BookName = list[0].VrstaTemeljnice; } Entries = new ObservableCollection <AccountingJournalModel>(list); SumSidesAndCompare(); ProcessCommand.RaiseCanExecuteChanged(); if (_automatic && CanProcess()) { ProcessRows(); } }
private static void ExecuteProcess(ProcessCommand command) { string error; using (Process process = Process.Start(StorageEmulatorProcessFactory.Create(command))) { if (process == null) { throw new InvalidOperationException("Unable to start process."); } error = GetError(process); process.WaitForExit(); } if (!String.IsNullOrEmpty(error)) { throw new InvalidOperationException(error); } }
public void HandleCommand(String commandText) { String cmd, paramStr = null; String[] param; ProcessCommand processCmd = null; Regex rgx_cmd = new Regex("^\\/\\w+"); cmd = rgx_cmd.Match(commandText, 0).ToString(); if (cmd == null) { return; } //// delete unnecessary "/" and enforce command format //cmd = cmd.Substring(1); cmd = cmd.ToUpper(); if ((cmd.Length + 1) < commandText.Length) { paramStr = commandText.Substring(cmd.Length + 1); } else { paramStr = ""; } if (!CmdToProcessFunc.TryGetValue(cmd, out processCmd)) { return; } param = paramStr.Split(' '); if (param == null) { param = new String[0]; } Dictionary <string, object> returnVal; processCmd(this, cmd, param, out returnVal); }
public static ProcessStartInfo Create(ProcessCommand command) { string filePath = Path.Combine(EmulatorDirectoryPath, NewEmulatorName); if (!File.Exists(filePath)) { filePath = Path.Combine(EmulatorDirectoryPath, OldEmulatorName); } return(new ProcessStartInfo { FileName = filePath, Arguments = GetCommandArgument(command), RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false, CreateNoWindow = true }); }
public IEnumerator SendProcessCommandRoutine(ProcessCommand command) { MemoryStream stream = new MemoryStream(); Serializer.Serialize(stream, command); string data = System.Convert.ToBase64String(stream.ToArray()); string uri = NetworkSettings.instance.BaseUri() + "/api/process_manager"; var form = new WWWForm(); form.AddField("process_command", data); WWW www = new WWW(uri, form.data, form.headers); yield return www; if (www.error != null) { Debug.Log(www.error); onProcessCommand(false); } else { onProcessCommand(true); Debug.Log(www.text); } }
public GenericCommand(String commandName, String description, ProcessCommand processCommand) { _commandName = commandName; _description = description; _processCommandDelegate = processCommand; }
public ITypableMapCommand AddCommand(String command, String description, ProcessCommand processCommand) { GenericCommand commandC = new GenericCommand(command, description, processCommand); return AddCommand(commandC); }
public void SendProcessCommand(ProcessCommand command) { StartCoroutine(SendProcessCommandRoutine(command)); }
/// <summary> /// Executes the specified command. /// </summary> /// <param name="command"> /// The command. /// </param> private static void ExecuteProcess(ProcessCommand command) { string error; using (var process = Process.Start(StorageEmulatorProcessFactory.Create(command))) { if (process == null) { throw new InvalidOperationException("Unable to start process."); } error = GetError(process); process.WaitForExit(); } if (!string.IsNullOrEmpty(error)) { throw new InvalidOperationException(error); } }
/// <summary> /// The create. /// </summary> /// <param name="command"> /// The command. /// </param> /// <returns> /// The <see cref="ProcessStartInfo"/>. /// </returns> public static ProcessStartInfo Create(ProcessCommand command) { return new ProcessStartInfo { FileName = @"C:\Program Files (x86)\Microsoft SDKs\Azure\Storage Emulator\WAStorageEmulator.exe", Arguments = command.ToString().ToLower(), RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false, CreateNoWindow = true }; }