public virtual void Compile()
        {
            var slnFile = CompileConfiguration.SlnPath;

            slnFile = ProcessCommand.ToArgumentPath(slnFile);
            DotNetBuild($" {slnFile} -c release");
        }
Example #2
0
        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;
                }
            }
        }
Example #3
0
        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;
 }
Example #5
0
 public async Task <APIResult> ProcessOrder([FromBody] ProcessCommand command)
 {
     return(new APIResult()
     {
         Result = await mediator.Send(command)
     });
 }
Example #6
0
            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);
                }
            }
Example #7
0
        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);
        }
Example #8
0
        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);
            }
        }
Example #9
0
 private void ToggleCopyButton()
 {
     if (copyManager != null)
     {
         btnCopy.Text = btnCopy.Text.ToLowerInvariant().Contains("copy") ? "Cancel" : "Copy";
         CopyState    = ProcessCommand.Analyzing;
     }
 }
Example #10
0
        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);
        }
Example #11
0
        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);
        }
Example #16
0
 //======================================================================= 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);
        }
Example #18
0
        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
     });
 }
Example #20
0
    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)));
    }
Example #21
0
            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);
            }
Example #22
0
 private void RaiseButtonNotifications()
 {
     AddTgFileCommand.RaiseCanExecuteChangedNotification();
     AddTgFolderCommand.RaiseCanExecuteChangedNotification();
     RemoveTgFileCommand.RaiseCanExecuteChangedNotification();
     ClearTgFilesCommand.RaiseCanExecuteChangedNotification();
     ProcessCommand.RaiseCanExecuteChangedNotification();
     SetOutputFolderCommand.RaiseCanExecuteChangedNotification();
     LoadOutputFolderCommand.RaiseCanExecuteChangedNotification();
     ExportAllCommand.RaiseCanExecuteChangedNotification();
     BatchSettingsCommand.RaiseCanExecuteChangedNotification();
 }
Example #23
0
 public static ProcessStartInfo Create(ProcessCommand command)
 {
     return(new ProcessStartInfo
     {
         FileName = _windowsAzureStorageEmulatorPath,
         Arguments = command.ToString().ToLower(),
         RedirectStandardOutput = true,
         RedirectStandardError = true,
         UseShellExecute = false,
         CreateNoWindow = true
     });
 }
Example #24
0
    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();
            }
        }
Example #27
0
        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();
            }
        }
Example #28
0
    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);
        }
    }
Example #29
0
        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);
        }
Example #30
0
        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
            });
        }
Example #31
0
            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);
 }
Example #34
0
 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
     };
 }