public CommandString(ShellCommand Cmd, IEnumerable<string> Prms) { command = Cmd; parameters = new Queue<string>(); foreach (string s in Prms) parameters.Enqueue(s); }
public CommandBarControl NewButtonObsolete(IContext context, string caption, int index, string binding, object newItemValue) { var validValueTypes = new[] { typeof(ScriptBlock), typeof(string) }; if (null == newItemValue || !validValueTypes.Contains(newItemValue.GetType())) { var validNames = String.Join(", ", validValueTypes.ToList().ConvertAll(t => t.FullName).ToArray()); throw new ArgumentException( "new item values for command bar buttons must be one of the following types: " + validNames); } index = Math.Max(index, 1); ShellCommand shellCommand = CommandUtilities.GetOrCreateCommand( context, _commandBar.Application as DTE2, caption, newItemValue ); if (!String.IsNullOrEmpty(binding)) { shellCommand.Bindings = new[] { (object)binding }; } Command command = shellCommand.AsCommand(); var ctl = command.AddControl(_commandBar, index) as CommandBarControl; return(ctl); }
static void Main(string[] args) { Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) { e.Cancel = true; }; LineEditor lineEditor = new LineEditor(); lineEditor.LineReceived += delegate(object _, string e) { if (string.IsNullOrEmpty(e)) { Console.WriteLine(); return; } ShellCommand shellCommand = ParseCommand(e); CommandProcessor commandProcessor = new CommandProcessor(shellCommand); commandProcessor.Run(); }; lineEditor.Start(); }
public Task Create(ShellCommand command) { return new Task(() => { CommandOutput commandOutput; CommandResult output = new CommandResult("", "", ""); try { output = this.commandRunner.RunCommand(command); var resultLog = this.logParser.Parse(output.Result); var outputLog = this.logParser.Parse(output.Output); var errorLog = this.logParser.Parse(output.Error); commandOutput = resultLog; commandOutput.Results.AddRange(outputLog.Results); commandOutput.Results.AddRange(errorLog.Results); } catch (Exception ex) { commandOutput = new CommandOutput("goose", "Failed to run command: " + command.Command, ex.ToString(), CommandOutputItemType.Error); output = new CommandResult(commandOutput.ToString(), "", ""); } this.errorReporter.Report(command, output); this.outputService.Handle(commandOutput); }); }
/// <summary> /// Opens a window with the specified help topic. /// </summary> /// <param name="topic"></param> public static void ShowHelp(Topic topic) { if (!sTopicMap.TryGetValue(topic, out string fileName)) { Debug.Assert(false, "Unable to find " + topic + " in map"); return; } string helpFilePath = Path.Combine(RuntimeDataAccess.GetDirectory(), HELP_DIR, fileName); if (!File.Exists(helpFilePath)) { // Alternate path, used during development. If it also doesn't exist, leave // the original path intact so the error message is useful. string altPath = Path.Combine(RuntimeDataAccess.GetDirectory() + "\\..\\..\\docs\\sgmanual", fileName); altPath = Path.GetFullPath(altPath); // normalize if (File.Exists(altPath)) { helpFilePath = altPath; } } string url = "file://" + helpFilePath; //url = url.Replace("#", "%23"); Debug.WriteLine("Requesting help URL: " + url); ShellCommand.OpenUrl(url); }
public CommandResult RunCommand(ShellCommand command) { var host = new GoosePSHost(); var results = new List<string>(); using (var runspace = RunspaceFactory.CreateRunspace(host)) { var setWorkingDirectory = new Command("set-location"); setWorkingDirectory.Parameters.Add("path", command.WorkingDirectory); var redirectOutput = new Command("out-string"); runspace.Open(); var pipeline = runspace.CreatePipeline(); pipeline.Commands.Add(setWorkingDirectory); pipeline.Commands.AddScript(command.Command); pipeline.Commands.Add(redirectOutput); foreach (var psObject in pipeline.Invoke()) { var result = FormatCommandResult(psObject); results.Add(result); } runspace.Close(); } return BuildOutput(results, host); }
// IAssembler public AssemblerResults RunAssembler(BackgroundWorker worker) { Debug.Assert(mPathNames.Count == 2); string pathName = StripWorkDirectory(mPathNames[0]); string cfgName = StripWorkDirectory(mPathNames[1]); AssemblerConfig config = AssemblerConfig.GetConfig(AppSettings.Global, AssemblerInfo.Id.Cc65); if (string.IsNullOrEmpty(config.ExecutablePath)) { Debug.WriteLine("Assembler not configured"); return(null); } string cfgOpt = " -C \"" + cfgName + "\""; worker.ReportProgress(0, Properties.Resources.PROGRESS_ASSEMBLING); // Wrap pathname in quotes in case it has spaces. // (Do we need to shell-escape quotes in the pathName?) ShellCommand cmd = new ShellCommand(config.ExecutablePath, OPTIONS + cfgOpt + " \"" + pathName + "\"", mWorkDirectory, null); cmd.Execute(); // Can't really do anything with a "cancel" request. // Output filename is the input filename without the ".S". Since the filename // was generated by us we can be confident in the format. string outputFile = mPathNames[0].Substring(0, mPathNames[0].Length - 2); return(new AssemblerResults(cmd.FullCommandLine, cmd.ExitCode, cmd.Stdout, cmd.Stderr, outputFile)); }
static void Main(string[] args) { Shell = new Core.ShellShell(); var cmd = new ShellCommand(CommandNames.Command2, Command1); cmd.ConfigureSwitch(SwitchesNames.Switch1); cmd.ConfigureParameter(ParameterNames.Parameter1, false); cmd.ConfigureParameter(ParameterNames.Parameter2, false, "default1"); Shell.ConfigureCommand(cmd); var cmd2 = new ShellCommand(CommandNames.Command1, Command1); cmd2.ConfigureSwitch(SwitchesNames.Switch2); cmd2.ConfigureParameter(ParameterNames.Parameter1, true); Shell.ConfigureCommand(cmd2); Shell.ConfigureGlobalParameter(ParameterNames.Parameter3, true); //shell.UseDefaultCommand = true; try { Shell.SetArguments(args); Shell.Execute(); } catch (Exception e) { Console.WriteLine(e.Message); } Console.ReadLine(); }
public void IShellBuilderTest() { string name = "My Shell Command"; string workDir = "/myworkdir"; string exec1 = "echo hello"; string exec2 = "echo world"; IShellCommandBuilder b = new ShellCommandBuilderImpl(_stepsBuilder, _pipelineBuilder); b.SetName(name) .InDirectory(workDir) .Execute(exec1) .Execute(exec2) .Build(); ShellCommand actual = (ShellCommand)b.Collect(); ShellCommand expected = new ShellCommand(name, exec1, exec2); expected.WorkDirectory = workDir; Assert.AreEqual(expected.WorkDirectory, actual.WorkDirectory); Assert.AreEqual(expected.Name, actual.Name); Assert.AreEqual(expected.getCommandLines(), actual.getCommandLines()); }
public void OpenActionKeyword(String actword) { ProcessStartInfo info; var command = actword.Trim(); command = Environment.ExpandEnvironmentVariables(command); var workingDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); var parts = command.Split(new[] { ' ' }, 2); if (parts.Length == 2) { var filename = parts[0]; if (ExistInPath(filename)) { var arguments = parts[1]; info = ShellCommand.SetProcessStartInfo(filename, workingDirectory, arguments); } else { info = ShellCommand.SetProcessStartInfo(command, workingDirectory); } } else { info = ShellCommand.SetProcessStartInfo(command, workingDirectory); } info.UseShellExecute = true; Process.Start(info); }
protected override string ProcessChange() { var recipient = ChatEngine.Owner as IShellCommandRecipient; // If there's no target or no recipient, don't bother if (!HasAttribute("target") || recipient == null) { return string.Empty; } // Build a command var name = GetAttribute("command"); if (name.IsEmpty()) { name = "nav"; } var target = GetAttribute("target"); var data = GetAttribute("data"); var command = new ShellCommand(name, target, data); // Send the command on to the owner var redirect = recipient.ProcessShellCommand(command); // If no redirect was specified, use empty otherwise execute a redirect to the result of the star operation return !redirect.HasText() ? string.Empty : DoRedirect(redirect); }
//todo rewrite this using COM API public override StatusResult CheckStatus() { var taskName = Params[PARAM_NAME_TASK_NAME]; string args = $"schtasks /query /tn \"{taskName}\" /hresult /fo csv /nh"; var cmd = new ShellCommand(args); if (cmd.TryExecute(out string taskStatusCSV)) { var actualStatus = taskStatusCSV.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)[0].Split(',')[2]; //{Disabled, Ready} var checkStatus = Params[PARAM_NAME_STATUS]; // {DISABLED, ENABLED} if ((actualStatus.Trim().Trim('"') == "Disabled" && checkStatus == "DISABLED") || (actualStatus.Trim().Trim('"') == "Ready" && checkStatus == "ENABLED") ) { return(StatusResult.Match); } else { return(StatusResult.Mismatch); } } else { return(StatusResult.Unavailable); } }
//todo rewrite this using COM API public override bool Execute() { var taskName = Params[PARAM_NAME_TASK_NAME]; var setStatus = Params[PARAM_NAME_STATUS];// {DISABLED, ENABLED} string statusSwitch = null; if (setStatus == "DISABLED") { statusSwitch = "/disable"; } else if (setStatus == "ENABLED") { statusSwitch = "/enable"; } else { return(false); } string args = $"schtasks /change /tn \"{taskName}\" {statusSwitch} /hresult"; var cmd = new ShellCommand(args); return(cmd.TryExecute(out _)); }
/// <summary> /// 执行shell命令 /// </summary> /// <param name="device"></param> /// <param name="sh"></param> /// <returns></returns> public static Tuple <Output, int> Shell(this IDevice device, string sh) { var cmd = new ShellCommand(device, sh); var result = cmd.Execute(); return(new Tuple <Output, int>(result.Output, result.ExitCode)); }
public static ShellCommand PackageShellCmd() { ShellCommand packageStep = new ShellCommand("Package TANKS", "mvn package"); packageStep.WorkDirectory = "./TANKS"; return(packageStep); }
public static ShellCommand CompileShellCmd() { ShellCommand compileStep = new ShellCommand("Compile TANKS", "mvn compile"); compileStep.WorkDirectory = "./TANKS"; return(compileStep); }
public static ShellCommand GlobalCleanStep() { ShellCommand cleanStep = new ShellCommand("Compile TANKS", "mvn clean"); cleanStep.WorkDirectory = "./TANKS"; return(cleanStep); }
public static ShellCommand InstallShellCmd() { ShellCommand installStep = new ShellCommand("Install Tanks", "mvn install"); installStep.WorkDirectory = "./TANKS"; return(installStep); }
/// <summary> /// 获取build.prop中的值 /// </summary> /// <param name="device"></param> /// <param name="key"></param> /// <returns></returns> public static string GetProp(this IDevice device, string key) { var result = new ShellCommand(device, $"getprop {key}") .Execute() .ThrowIfExitCodeNotEqualsZero(); return(result.Output.ToString().Trim()); }
public void ShellRun(string cmd, string filename = "cmd.exe") { var args = filename == "cmd.exe" ? $"/C {cmd}" : $"{cmd}"; var startInfo = ShellCommand.SetProcessStartInfo(filename, arguments: args, createNoWindow: true); ShellCommand.Execute(startInfo); }
public void GetShellCommandNameTest() { string name = ShellCommand.GetShellCommandName(typeof(TestCommand)); Assert.AreEqual("test", name); name = ShellCommand.GetShellCommandName(typeof(AnotherCommand)); Assert.AreEqual("AnotherCommand", name); }
public void IsShellCommandTest() { bool isCommand = ShellCommand.IsShellCommand(typeof(TestCommand)); Assert.IsTrue(isCommand); isCommand = ShellCommand.IsShellCommand(typeof(NotACommand)); Assert.IsFalse(isCommand); }
public void GetShellCommandsTest() { Type[] commands = ShellCommand.GetShellCommands(Assembly.GetExecutingAssembly()); Assert.IsNotNull(commands); Assert.AreEqual(3, commands.Length); CollectionAssert.Contains(commands, typeof(TestCommand)); CollectionAssert.Contains(commands, typeof(AnotherCommand)); CollectionAssert.Contains(commands, typeof(CustomParsingCommand)); }
/// <summary> /// 检测某个命令是否存在 /// </summary> /// <param name="device"></param> /// <param name="cmd"></param> public static void CommandExistsCheck(IDevice device, string cmd) { var result = new ShellCommand(device, cmd) .Execute(); if (result.ExitCode == (int)LinuxReturnCode.KeyHasExpired) { throw new CommandNotFoundException(cmd); } }
public static bool StartProcess(ShellCommand shellCommand) { var process = new Process(); return(StartProcess(new ProcessStartInfo { CreateNoWindow = true, FileName = shellCommand.FileName, Arguments = shellCommand.Args }, ref process)); }
private static void CreateCommand(RegistryKey parentKey, ShellCommand command) { var shellKey = parentKey.CreateSubKey(RegistryKeys.Shell); var actionKey = shellKey.CreateSubKey(command.Action ?? "open"); var cmdKey = actionKey.CreateSubKey(RegistryKeys.Command); var cmdStr = $"\"{command.Path}\" \"{command.Argument}\""; cmdKey.SetValue(RegistryKeys.Default, cmdStr); }
public async Task <int> ExecuteAsync(ShellCommand command) { Command?cmd = Cli.Wrap(_shell) .WithArguments("/c " + command.Command + " " + command.Arguments) .WithWorkingDirectory(command.WorkDirectory ?? _boostApplicationContext.WorkingDirectory.FullName); var exitCode = 0; await foreach (CommandEvent? cmdEvent in cmd.ListenAsync()) { switch (cmdEvent) { case StartedCommandEvent started: _messageHandler?.Invoke(new ShellMessage( _session.Next(), "cmd", $"{_shell}> {command.Command} {command.Arguments}") { Tags = new[] { "command" } }); break; case StandardOutputCommandEvent stdOut: _messageHandler?.Invoke(new ShellMessage(_session.Next(), "info", stdOut.Text) { Tags = ShellMessageTagger.GetTags(stdOut.Text) }); break; case StandardErrorCommandEvent stdErr: _messageHandler?.Invoke(new ShellMessage(_session.Next(), "error", stdErr.Text) { Tags = new[] { "error" } }); break; case ExitedCommandEvent exited: exitCode = exited.ExitCode; _messageHandler?.Invoke(new ShellMessage( _session.Next(), "end", (exitCode == 0) ? "Command completed successfully" : $"Command completed with errors (ExitCode: {exitCode})" ) { Tags = new string[] { (exitCode == 0) ? "success" : "error" } }); break; } } return(exitCode); }
/// <summary> /// Define supported shell functions here for use through the game terminal /// </summary> private void DefineSupportedShellFunctions() { _supportedShellFunctions = new Dictionary <string, ShellCommand>(); var helpCmd = new ShellCommand() { Desc = "List Supported Commands", SupportedInputs = new List <string>() { "v - verbose, lists supported inputs for shell functions" }, ShellFunction = ListShellCommands, }; _supportedShellFunctions.Add("help", helpCmd); _supportedShellFunctions.Add("?", helpCmd); _supportedShellFunctions.Add("q", new ShellCommand() { Desc = "Quit Terminal", ShellFunction = QuitTerminal }); _supportedShellFunctions.Add("e", new ShellCommand() { Desc = "Exit Game", ShellFunction = ExitGame }); _supportedShellFunctions.Add("t", new ShellCommand() { Desc = "Toggle Specified System", SupportedInputs = new List <string>() { "fow - fog of war, ai - ai for all npcs" }, ShellFunction = Toggle }); _supportedShellFunctions.Add("ce", new ShellCommand() { Desc = "Create Entity", SupportedInputs = new List <string>() { "marker, seeker, seekerPistol, seekerKnife, seekeraitest, fadingcolor", "x-coord", "y-coord" }, ShellFunction = CreateEntity }); _supportedShellFunctions.Add("le", new ShellCommand() { Desc = "List Entities", SupportedInputs = new List <string>() { "actor" }, ShellFunction = ListEntities }); }
protected override void Run(ShellCommand command, ShellContext context, JobsOptions options) { foreach (var job in context.Jobs) { if (options.ShowAll || job.Running) { var suffix = job.Running ? "running" : "exited"; Console.WriteLine($"[{job.Id}] - {job.ProcessName} {suffix}"); } } }
/// <summary> /// Processes a shell command by sending it on to the user interface layer. /// </summary> /// <param name="command">The command.</param> public string ProcessShellCommand(ShellCommand command) { _alfred.Console?.Log("ShellCommand", "Received shell command: " + command, LogLevel.Info); switch (command.Name.ToUpperInvariant()) { case "NAV": return HandleNavigationCommand(command) ? "NAVIGATE SUCCESS" : "NAVIGATE FAILED"; } return string.Empty; }
public void StrayexShell_Hello_WriteHello() { var obj = new ShellCommand("hello", new string[50]); if (obj.Interpret()) { return; } else { throw new InvalidOperationException("Command Hello not working!"); } }
public void StrayexShell_Echo_WriteEmptyLine() { var obj = new ShellCommand("echo", new string[50]); if (obj.Interpret()) { return; } else { throw new InvalidOperationException("Command Echo not working or turned off!"); } }
public void StrayexShell_Clear_ClearConsole() { var obj = new ShellCommand("clear", new string[50]); if (obj.Interpret()) { return; } else { throw new InvalidOperationException("Command Clear not working!"); } }
public void Run(ShellCommand command, ShellContext context) { var builtin = FindBuiltinCommand(command); if (builtin is null) { RunExternalCommand(command, context); } else { builtin.Run(command, context); } }
public void ShellCommandOnlyPipesTest() { ShellParser shellParser = MakeParser("git reset --hard | echo"); ShellCommandContext context = shellParser.shellCommand(); ShellVisitor visitor = new ShellVisitor(); ParserResult result = visitor.Visit(context); ShellCommand shellCommand = result.ShellCommandValue; result.IsShellCommand.Should().BeTrue(); shellCommand.IsBackground.Should().BeFalse(); shellCommand.CommandList.Should().HaveCount(2); }
/// <summary> /// Processes a shell <paramref name="command"/> by sending it on to the user interface layer. /// </summary> /// <param name="command">The command.</param> /// <returns>The redirect target or string.empty for no redirect.</returns> public string ProcessShellCommand(ShellCommand command) { if (command.Name.Matches("Nav")) { if (command.Target.Matches("Pages")) { // We'll pretend it worked unless the data contained fail. Why not? if (!command.Data.ToUpperInvariant().Contains("FAIL")) { return "Navigate Success"; } } // If we got here, its a navigate and it didn't succeed return "Navigate Failed"; } // Default to string.empty return string.Empty; }
public void ControlCanHandleNavigationCommands() { Assert.IsNotNull(_app.Alfred.RootPages); var lastPage = _app.Alfred.RootPages.LastOrDefault(); Assert.IsNotNull(lastPage); var command = new ShellCommand("Nav", "Pages", lastPage.Id); var tab = _control.TabPages; Assert.IsNotNull(tab, "TabPages was null"); Assert.IsTrue(tab.HasItems, "TabPages did not have items"); var result = _control.HandlePageNavigationCommand(command); Assert.IsTrue(result, "Navigation Failed"); var selectedItem = tab.SelectedItem; Assert.IsNotNull(selectedItem, "Selected tab was null after navigate"); var selectedDomainItem = selectedItem as IAlfredPage; Assert.IsNotNull(selectedDomainItem); Assert.AreEqual(lastPage.Id, selectedDomainItem.Id, "Selected tab's ID did not match last tab's ID"); }
/// <summary> /// Handles the page navigation command. /// </summary> /// <param name="command">The command.</param> /// <returns>Whether or not the command was handled</returns> public bool HandlePageNavigationCommand(ShellCommand command) { if (!command.Data.HasText() || TabPages == null) { return false; } return SelectionHelper.SelectItemById(TabPages, command.Data); }
/// <summary> /// Handles the page navigation <paramref name="command" /> . /// </summary> /// <param name="command">The command.</param> /// <returns>Whether or not the <paramref name="command"/> was handled</returns> public bool HandlePageNavigationCommand(ShellCommand command) { Debug.Assert(PagesControl != null); return PagesControl.HandlePageNavigationCommand(command); }
protected bool Equals(ShellCommand other) { return string.Equals(WorkingDirectory, other.WorkingDirectory) && string.Equals(Command, other.Command); }
public string GetHelpText(ShellCommand cmd) { string helpText = String.Empty; switch (cmd) { case ShellCommand.None: helpText = @"This system recognizes the following commands: LIST, CLEAR, EDIT, PROMOTE, DEMOTE, DELETE, REGISTERS, LOG Type HELP [COMMAND] for more information on a system command."; break; case ShellCommand.Clear: helpText = @"Clear Command Syntax: CLEAR This command will flush the terminal display buffers."; break; case ShellCommand.Delete: helpText = @"Delete Command Syntax: DELETE [PROGRAM] This command will remove a program from system memory."; break; case ShellCommand.Demote: helpText = @"Demote Command Syntax: DEMOTE [PROGRAM] This command will lower a program's run priority."; break; case ShellCommand.Edit: helpText = @"Edit Command Syntax: EDIT [PROGRAM] This command will edit the program provided as a parameter. If the program does not exist it will be created."; break; case ShellCommand.Help: helpText = @"Help Command Syntax: HELP *[PROGRAM] This command will display general help information on this system. The optional program parameter will provide more specific information."; break; case ShellCommand.List: helpText = @"List Command Syntax: LIST This command lists all programs in resident memory in descending order of run priority."; break; case ShellCommand.Promote: helpText = @"Promote Command Syntax: PROMOTE [PROGRAM] This command will raise the run priority of the program provided as a parameter."; break; case ShellCommand.Registers: helpText = @"Registers Command Syntax: REGISTERS This command will display the current status of all system memory registers. Reserved Registers ------------------ 99: Thermostat reading 98: HVAC On/Off setting 97: Heater/Condenser setting"; break; case ShellCommand.Log: helpText = @"Log Command Syntax: LOG This command will log program execution and resulting errors."; break; case ShellCommand.Notes: /*helpText = @"Registers Command Syntax: REGISTERS This command will display the current status of all system memory registers.";*/ break; } return helpText; }
public string ProcessShellCommand(ShellCommand command) { // Commands are very, very important and need to be logged. Alfred?.Console?.Log(Resources.AlfredCommandRouterProcessShellCommandLogHeader, string.Format(CultureInfo.CurrentCulture, Resources.AlfredCommandRouterProcessShellCommandMessage, command.Name, command.Target, command.Data), LogLevel.Info); var shell = Alfred?.ShellCommandHandler; var result = shell?.ProcessShellCommand(command); return result.NonNull(); }
public void ControlDoesNotHandleBogusCommands() { var command = new ShellCommand("Nav", "Pages", "IamTheBatman"); var result = _control.HandlePageNavigationCommand(command); Assert.IsFalse(result); }
public PowerShellGooseAction(IPowerShellTaskFactory powershellTaskFactory, ShellCommand command) { this.powershellTaskFactory = powershellTaskFactory; this.command = command; }
/// <summary> /// Handles a shell navigation command. /// </summary> /// <param name="command">The command.</param> /// <returns>Whether or not the event was handled</returns> private bool HandleNavigationCommand(ShellCommand command) { switch (command.Target.ToUpperInvariant()) { case "PAGES": return _uiDirector.HandlePageNavigationCommand(command); } return false; }