private void GetSetting(IShellState shellState, HttpState programState, DefaultCommandInput <ICoreParseResult> commandInput) { string preferenceName = commandInput.Arguments.Count > 1 ? commandInput.Arguments[1]?.Text : null; _telemetry.TrackEvent(new PreferenceEvent("Get", preferenceName)); //If there's a particular setting to get the value of if (!string.IsNullOrEmpty(preferenceName)) { if (_preferences.TryGetValue(preferenceName, out string value)) { shellState.ConsoleManager.WriteLine(string.Format(Resources.Strings.PrefCommand_Get_ConfiguredValue, value)); } else { shellState.ConsoleManager.Error.WriteLine(string.Format(Resources.Strings.PrefCommand_Error_NoConfiguredValue, commandInput.Arguments[1].Text).SetColor(programState.ErrorColor)); } } else { foreach (KeyValuePair <string, string> entry in _preferences.CurrentPreferences.OrderBy(x => x.Key)) { shellState.ConsoleManager.WriteLine($"{entry.Key}={entry.Value}"); } } }
public Shell(IShellState shellState) { shellState = shellState ?? throw new ArgumentNullException(nameof(shellState)); KeyHandlers.RegisterDefaultKeyHandlers(shellState.InputManager); ShellState = shellState; }
public IEnumerable <string> Suggest(IShellState shellState, object programState, ICoreParseResult parseResult) { parseResult = parseResult ?? throw new ArgumentNullException(nameof(parseResult)); if (parseResult.SelectedSection == 0) { bool nameMatch = string.IsNullOrEmpty(parseResult.Sections[parseResult.SelectedSection]) || Name.StartsWith(parseResult.Sections[0].Substring(0, parseResult.CaretPositionWithinSelectedSection), StringComparison.OrdinalIgnoreCase); bool alternateNameMatch = string.IsNullOrEmpty(parseResult.Sections[parseResult.SelectedSection]) || AlternateName.StartsWith(parseResult.Sections[0].Substring(0, parseResult.CaretPositionWithinSelectedSection), StringComparison.OrdinalIgnoreCase); if (nameMatch && alternateNameMatch) { return(new[] { Name, AlternateName }); } else if (nameMatch) { return(new[] { Name }); } else if (alternateNameMatch) { return(new[] { AlternateName }); } } return(null); }
protected override async Task ExecuteAsync(IShellState shellState, HttpState programState, DefaultCommandInput <ICoreParseResult> commandInput, ICoreParseResult parseResult, CancellationToken cancellationToken) { commandInput = commandInput ?? throw new ArgumentNullException(nameof(commandInput)); shellState = shellState ?? throw new ArgumentNullException(nameof(shellState)); programState = programState ?? throw new ArgumentNullException(nameof(programState)); string rootAddress = commandInput.Arguments.SingleOrDefault()?.Text?.EnsureTrailingSlash(); string baseAddress = GetBaseAddressFromCommand(commandInput)?.EnsureTrailingSlash(); string swaggerAddress = GetSwaggerAddressFromCommand(commandInput); bool isVerbosityEnabled = GetOptionExistsFromCommand(commandInput, VerbosityOption); ApiConnection connectionInfo = GetConnectionInfo(shellState, programState, rootAddress, baseAddress, swaggerAddress, _preferences, isVerbosityEnabled); bool rootSpecified = !string.IsNullOrWhiteSpace(rootAddress); bool baseSpecified = !string.IsNullOrWhiteSpace(baseAddress); bool openApiSpecified = !string.IsNullOrWhiteSpace(swaggerAddress); if (connectionInfo is null) { _telemetry.TrackEvent(new ConnectEvent(baseSpecified, rootSpecified, openApiSpecified, openApiFound: false)); return; } await connectionInfo.SetupHttpState(programState, performAutoDetect : true, cancellationToken); bool openApiFound = connectionInfo?.HasSwaggerDocument == true; _telemetry.TrackEvent(new ConnectEvent(baseSpecified, rootSpecified, openApiSpecified, openApiFound)); WriteStatus(shellState, programState); }
public IEnumerable <string> Suggest(IShellState shellState, HttpState programState, ICoreParseResult parseResult) { if (parseResult.Sections.Count == 0) { return(new[] { Name }); } if (parseResult.Sections.Count > 0 && parseResult.SelectedSection == 0 && Name.StartsWith(parseResult.Sections[0].Substring(0, parseResult.CaretPositionWithinSelectedSection), StringComparison.OrdinalIgnoreCase)) { return(new[] { Name }); } if (string.Equals(Name, parseResult.Sections[0], StringComparison.OrdinalIgnoreCase) && parseResult.SelectedSection == 1 && (parseResult.Sections.Count < 2 || SubCommand.StartsWith(parseResult.Sections[1].Substring(0, parseResult.CaretPositionWithinSelectedSection), StringComparison.OrdinalIgnoreCase))) { return(new[] { SubCommand }); } if (parseResult.Sections.Count > 2 && string.Equals(Name, parseResult.Sections[0], StringComparison.OrdinalIgnoreCase) && string.Equals(SubCommand, parseResult.Sections[1], StringComparison.OrdinalIgnoreCase) && parseResult.SelectedSection == 2) { string prefix = parseResult.Sections[2].Substring(0, parseResult.CaretPositionWithinSelectedSection); return(HeaderCompletion.GetCompletions(null, prefix)); } if (parseResult.Sections.Count > 3 && string.Equals(Name, parseResult.Sections[0], StringComparison.OrdinalIgnoreCase) && string.Equals(SubCommand, parseResult.Sections[1], StringComparison.OrdinalIgnoreCase) && parseResult.SelectedSection == 3) { string prefix = parseResult.Sections[3].Substring(0, parseResult.CaretPositionWithinSelectedSection); return(HeaderCompletion.GetValueCompletions(null, string.Empty, parseResult.Sections[2], prefix, programState)); } return(null); }
public Task ExecuteAsync(IShellState shellState, HttpState programState, ICoreParseResult parseResult, CancellationToken cancellationToken) { if (programState.BaseAddress == null) { shellState.ConsoleManager.Error.WriteLine("Must be connected to a server to launch Swagger UI".SetColor(programState.ErrorColor)); return(Task.CompletedTask); } Uri uri = new Uri(programState.BaseAddress, "swagger"); string agent = "cmd"; string agentParam = $"/c start {uri.AbsoluteUri}"; if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { agent = "open"; agentParam = uri.AbsoluteUri; } else if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { agent = "xdg-open"; agentParam = uri.AbsoluteUri; } Process.Start(new ProcessStartInfo(agent, agentParam) { CreateNoWindow = true }); return(Task.CompletedTask); }
private void SetSetting(IShellState shellState, HttpState programState, DefaultCommandInput <ICoreParseResult> commandInput) { string prefName = commandInput.Arguments[1].Text; string prefValue = commandInput.Arguments.Count > 2 ? commandInput.Arguments[2]?.Text : null; _telemetry.TrackEvent(new PreferenceEvent("Set", prefName)); if (!_preferences.SetValue(prefName, prefValue)) { shellState.ConsoleManager.Error.WriteLine(Resources.Strings.PrefCommand_Error_Saving.SetColor(programState.ErrorColor)); } else { // If we think they're configurating HttpRepl to use Visual Studio Code as their editor, we should // warn them that for best integration, they should also pass the `-w` or `--wait` arguments to // Visual Studio Code. if (string.Equals(prefName, WellKnownPreference.DefaultEditorCommand, StringComparison.Ordinal)) { if (IsVSCode(prefValue)) { shellState.ConsoleManager.WriteLine(string.Format(Resources.Strings.PrefCommand_Set_VSCode, WellKnownPreference.DefaultEditorArguments).SetColor(programState.WarningColor)); } } } }
public async Task RunAsync_WithDeleteKeyPress_DeletesCurrentCharacterInTheInputBuffer() { ConsoleKeyInfo consoleKeyInfo = new ConsoleKeyInfo(keyChar: '\0', key: ConsoleKey.Delete, shift: false, alt: false, control: false); Shell shell = CreateShell(consoleKeyInfo, previousCommand: null, nextCommand: null, out CancellationTokenSource cancellationTokenSource); string inputBufferTextBeforeKeyPress = "get"; string inputBufferTextAfterKeyPress = "ge"; IShellState shellState = shell.ShellState; shellState.InputManager.SetInput(shellState, inputBufferTextBeforeKeyPress); shellState.ConsoleManager.MoveCaret(2); await shell.RunAsync(cancellationTokenSource.Token).ConfigureAwait(false); // Verify the input buffer contents after Delete key press event Assert.Equal(inputBufferTextAfterKeyPress, shell.ShellState.InputManager.GetCurrentBuffer()); }
private void SetInput(IShellState state, IReadOnlyList <char> input, bool moveCaret = true) { bool oldCaretVisibility = state.ConsoleManager.IsCaretVisible; state.ConsoleManager.IsCaretVisible = false; int lastCommonPosition = 0; for (; lastCommonPosition < input.Count && lastCommonPosition < _inputBuffer.Count && _inputBuffer[lastCommonPosition] == input[lastCommonPosition]; ++lastCommonPosition) { } state.ConsoleManager.MoveCaret(-state.ConsoleManager.CaretPosition + lastCommonPosition); string str = new string(input.Skip(lastCommonPosition).ToArray()); int trailing = _inputBuffer.Count - input.Count; if (trailing > 0) { str = str.PadRight(trailing + str.Length); } state.ConsoleManager.Write(str); if (trailing > 0 && moveCaret) { state.ConsoleManager.MoveCaret(-trailing); } _inputBuffer.Clear(); _inputBuffer.AddRange(input); if (oldCaretVisibility) { state.ConsoleManager.IsCaretVisible = true; } }
public static Task Home(ConsoleKeyInfo keyInfo, IShellState state, CancellationToken cancellationToken) { state = state ?? throw new ArgumentNullException(nameof(state)); state.MoveCarets(-state.InputManager.CaretPosition); return(Task.CompletedTask); }
public async Task RunAsync_WithShiftTabKeyPress_UpdatesInputBufferWithLastEntryFromSuggestionList() { ConsoleKeyInfo consoleKeyInfo = new ConsoleKeyInfo(keyChar: '\0', key: ConsoleKey.Tab, shift: true, alt: false, control: false); Shell shell = CreateShell(consoleKeyInfo, previousCommand: null, nextCommand: null, out CancellationTokenSource cancellationTokenSource); string inputBufferTextBeforeKeyPress = "c"; string inputBufferTextAfterKeyPress = "clear"; IShellState shellState = shell.ShellState; shellState.InputManager.SetInput(shellState, inputBufferTextBeforeKeyPress); DefaultCommandDispatcher <object> defaultCommandDispatcher = shellState.CommandDispatcher as DefaultCommandDispatcher <object>; string cdCommandName = "cd"; defaultCommandDispatcher.AddCommand(new MockCommand(cdCommandName)); string clearCommandName = "clear"; defaultCommandDispatcher.AddCommand(new MockCommand(clearCommandName)); await shell.RunAsync(cancellationTokenSource.Token).ConfigureAwait(false); // Verify the input buffer contents after Shift + Tab key press event Assert.Equal(inputBufferTextAfterKeyPress, shell.ShellState.InputManager.GetCurrentBuffer()); }
public static Task Insert(ConsoleKeyInfo keyInfo, IShellState state, CancellationToken cancellationToken) { state = state ?? throw new ArgumentNullException(nameof(state)); state.InputManager.IsOverwriteMode = !state.InputManager.IsOverwriteMode; return(Task.CompletedTask); }
public static Task Delete(ConsoleKeyInfo keyInfo, IShellState state, CancellationToken cancellationToken) { state = state ?? throw new ArgumentNullException(nameof(state)); state.InputManager.RemoveCurrentCharacter(state); return(Task.CompletedTask); }
public static Task Escape(ConsoleKeyInfo keyInfo, IShellState state, CancellationToken cancellationToken) { state = state ?? throw new ArgumentNullException(nameof(state)); state.InputManager.SetInput(state, string.Empty); return(Task.CompletedTask); }
public static void CoreGetHelp(IShellState shellState, ICommandDispatcher <HttpState, ICoreParseResult> dispatcher, HttpState programState) { shellState = shellState ?? throw new ArgumentNullException(nameof(shellState)); dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher)); const int navCommandColumn = -15; StringBuilder output = new StringBuilder(); output.AppendLine(); output.AppendLine(Strings.HelpCommand_Core_SetupCommands.Bold().Cyan()); output.AppendLine(Strings.HelpCommand_Core_SetupCommands_Description); output.AppendLine(); output.AppendLine($"{"connect",navCommandColumn}{GetCommand<ConnectCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"set header",navCommandColumn}{GetCommand<SetHeaderCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine(); output.AppendLine(Strings.HelpCommand_Core_HttpCommands.Bold().Cyan()); output.AppendLine(Strings.HelpCommand_Core_HttpCommands_Description); output.AppendLine(); output.AppendLine($"{"GET",navCommandColumn}{GetCommand<GetCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"POST",navCommandColumn}{GetCommand<PostCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"PUT",navCommandColumn}{GetCommand<PutCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"DELETE",navCommandColumn}{GetCommand<DeleteCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"PATCH",navCommandColumn}{GetCommand<PatchCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"HEAD",navCommandColumn}{GetCommand<HeadCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"OPTIONS",navCommandColumn}{GetCommand<OptionsCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine(); output.AppendLine(Strings.HelpCommand_Core_NavigationCommands.Bold().Cyan()); output.AppendLine(Strings.HelpCommand_Core_NavigationCommands_Description); output.AppendLine(); output.AppendLine($"{"ls",navCommandColumn}{GetCommand<ListCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"cd",navCommandColumn}{GetCommand<ChangeDirectoryCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine(); output.AppendLine(Strings.HelpCommand_Core_ShellCommands.Bold().Cyan()); output.AppendLine(Strings.HelpCommand_Core_ShellCommands_Description); output.AppendLine(); output.AppendLine($"{"clear",navCommandColumn}{GetCommand<ClearCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"echo [on/off]",navCommandColumn}{GetCommand<EchoCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"exit",navCommandColumn}{GetCommand<ExitCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine(); output.AppendLine(Strings.HelpCommand_Core_CustomizationCommands.Bold().Cyan()); output.AppendLine(Strings.HelpCommand_Core_CustomizationCommands_Description); output.AppendLine(); output.AppendLine($"{"pref [get/set]",navCommandColumn}{GetCommand<PrefCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"run",navCommandColumn}{GetCommand<RunCommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine($"{"ui",navCommandColumn}{GetCommand<UICommand>(dispatcher).GetHelpSummary(shellState, programState)}"); output.AppendLine(); output.AppendLine(Strings.HelpCommand_Core_Details_Line1.Bold().Cyan()); output.AppendLine(Strings.HelpCommand_Core_Details_Line2.Bold().Cyan()); output.AppendLine(); shellState.ConsoleManager.Write(output.ToString()); }
public override string GetHelpSummary(IShellState shellState, HttpState programState) { #pragma warning disable CA1308 // Normalize strings to uppercase return($"{Verb.ToLowerInvariant()} - Issues a {Verb.ToUpperInvariant()} request"); #pragma warning restore CA1308 // Normalize strings to uppercase }
private static Task SetSetting(IShellState shellState, HttpState programState, DefaultCommandInput <ICoreParseResult> commandInput) { string prefName = commandInput.Arguments[1].Text; string prefValue = commandInput.Arguments.Count > 2 ? commandInput.Arguments[2]?.Text : null; if (string.IsNullOrEmpty(prefValue)) { if (!programState.DefaultPreferences.TryGetValue(prefName, out string defaultValue)) { programState.Preferences.Remove(prefName); } else { programState.Preferences[prefName] = defaultValue; } } else { programState.Preferences[prefName] = prefValue; } if (!programState.SavePreferences()) { shellState.ConsoleManager.Error.WriteLine("Error saving preferences".SetColor(programState.ErrorColor)); } return(Task.CompletedTask); }
private static Task GetSetting(IShellState shellState, HttpState programState, DefaultCommandInput <ICoreParseResult> commandInput) { string preferenceName = commandInput.Arguments.Count > 1 ? commandInput.Arguments[1]?.Text : null; //If there's a particular setting to get the value of if (!string.IsNullOrEmpty(preferenceName)) { if (programState.Preferences.TryGetValue(preferenceName, out string value)) { shellState.ConsoleManager.WriteLine("Configured value: " + value); } else { shellState.ConsoleManager.Error.WriteLine((commandInput.Arguments[1].Text + " does not have a configured value").SetColor(programState.ErrorColor)); } } else { foreach (KeyValuePair <string, string> entry in programState.Preferences.OrderBy(x => x.Key)) { shellState.ConsoleManager.WriteLine($"{entry.Key}={entry.Value}"); } } return(Task.CompletedTask); }
public async Task ExecuteScriptAsync(IShellState shellState, IEnumerable <string> commandTexts, CancellationToken cancellationToken) { shellState = shellState ?? throw new ArgumentNullException(nameof(shellState)); commandTexts = commandTexts ?? throw new ArgumentNullException(nameof(commandTexts)); if (shellState.CommandDispatcher is ICommandDispatcher <TProgramState, TParseResult> dispatcher) { IDisposable suppressor = _hideScriptLinesFromHistory ? shellState.CommandHistory.SuspendHistory() : null; using (suppressor) { foreach (string commandText in commandTexts) { if (string.IsNullOrWhiteSpace(commandText)) { continue; } if (cancellationToken.IsCancellationRequested) { break; } dispatcher.OnReady(shellState); shellState.ConsoleManager.ResetCommandStart(); shellState.InputManager.SetInput(shellState, commandText); await dispatcher.ExecuteCommandAsync(shellState, cancellationToken).ConfigureAwait(false); } } } }
public static Task DownArrow(ConsoleKeyInfo keyInfo, IShellState state, CancellationToken cancellationToken) { string line = state.CommandHistory.GetNextCommand(); state.InputManager.SetInput(state, line); return(Task.CompletedTask); }
protected override Task ExecuteAsync(IShellState shellState, object programState, DefaultCommandInput <ICoreParseResult> commandInput, ICoreParseResult parseResult, CancellationToken cancellationToken) { shellState = shellState ?? throw new ArgumentNullException(nameof(shellState)); shellState.IsExiting = true; return(Task.CompletedTask); }
public static Task LeftArrow(ConsoleKeyInfo keyInfo, IShellState state, CancellationToken cancellationToken) { if (state.ConsoleManager.CaretPosition > 0) { if (!keyInfo.Modifiers.HasFlag(ConsoleModifiers.Control)) { state.ConsoleManager.MoveCaret(-1); } else { string line = state.InputManager.GetCurrentBuffer(); ICoreParseResult parseResult = state.CommandDispatcher.Parser.Parse(line, state.ConsoleManager.CaretPosition); int targetSection = parseResult.SelectedSection - (parseResult.CaretPositionWithinSelectedSection > 0 ? 0 : 1); if (targetSection < 0) { targetSection = 0; } int desiredPosition = parseResult.SectionStartLookup[targetSection]; state.ConsoleManager.MoveCaret(desiredPosition - state.ConsoleManager.CaretPosition); } } return(Task.CompletedTask); }
public static Task RightArrow(ConsoleKeyInfo keyInfo, IShellState state, CancellationToken cancellationToken) { string line = state.InputManager.GetCurrentBuffer(); if (state.ConsoleManager.CaretPosition < line.Length) { if (!keyInfo.Modifiers.HasFlag(ConsoleModifiers.Control)) { state.ConsoleManager.MoveCaret(1); } else { ICoreParseResult parseResult = state.CommandDispatcher.Parser.Parse(line, state.ConsoleManager.CaretPosition); int targetSection = parseResult.SelectedSection + 1; if (targetSection >= parseResult.Sections.Count) { state.ConsoleManager.MoveCaret(line.Length - state.ConsoleManager.CaretPosition); } else { int desiredPosition = parseResult.SectionStartLookup[targetSection]; state.ConsoleManager.MoveCaret(desiredPosition - state.ConsoleManager.CaretPosition); } } } return(Task.CompletedTask); }
private static bool SetupBaseAddress(IShellState shellState, string baseAddress, ApiConnection connectionInfo) { if (!string.IsNullOrWhiteSpace(baseAddress)) { if (!connectionInfo.HasRootUri && !Uri.IsWellFormedUriString(baseAddress, UriKind.Absolute)) { shellState.ConsoleManager.Error.WriteLine(Resources.Strings.ConnectCommand_Error_NoRootNoAbsoluteBase); return(false); } else if (connectionInfo.HasRootUri && !Uri.IsWellFormedUriString(baseAddress, UriKind.RelativeOrAbsolute)) { shellState.ConsoleManager.Error.WriteLine(Resources.Strings.ConnectCommand_Error_InvalidBase); return(false); } if (Uri.IsWellFormedUriString(baseAddress, UriKind.Absolute)) { connectionInfo.BaseUri = new Uri(baseAddress, UriKind.Absolute); } else if (Uri.IsWellFormedUriString(baseAddress, UriKind.Relative)) { connectionInfo.BaseUri = new Uri(connectionInfo.RootUri, baseAddress); } } return(true); }
public async Task ExecuteAsync_WithoutHistoryOption_AvoidsAddingCommandsExecutedFromScriptToCommandHistory() { string commands = @"set header name value1 value2"; if (!File.Exists(_pathToScript)) { File.WriteAllText(_pathToScript, commands); } string parseResultSections = "run " + _pathToScript; ArrangeInputs(parseResultSections: parseResultSections, out MockedShellState _, out HttpState httpState, out ICoreParseResult parseResult); IShellState shellState = GetShellState(commands, httpState); MockedFileSystem mockedFileSystem = new MockedFileSystem(); mockedFileSystem.AddFile(_pathToScript, commands); RunCommand runCommand = new RunCommand(mockedFileSystem); await runCommand.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None); string previousCommand = shellState.CommandHistory.GetPreviousCommand(); Assert.True(string.IsNullOrEmpty(previousCommand)); }
public bool?CanHandle(IShellState shellState, TProgramState programState, TParseResult parseResult) { shellState = shellState ?? throw new ArgumentNullException(nameof(shellState)); if (!DefaultCommandInput <TParseResult> .TryProcess(InputSpec, parseResult, out DefaultCommandInput <TParseResult> commandInput, out IReadOnlyList <CommandInputProcessingIssue> processingIssues)) { //If this is the right command, just not the right syntax, report the usage errors if (processingIssues.All(x => x.Kind != CommandInputProcessingIssueKind.CommandMismatch)) { foreach (CommandInputProcessingIssue issue in processingIssues) { shellState.ConsoleManager.Error.WriteLine(GetStringForIssue(issue)); } string help = GetHelpDetails(shellState, programState, parseResult); shellState.ConsoleManager.WriteLine(help); return(false); } //If there was a mismatch in the command name, this isn't our input to handle return(null); } return(CanHandle(shellState, programState, commandInput)); }
public async Task ExecuteAsync(IShellState shellState, HttpState programState, ICoreParseResult parseResult, CancellationToken cancellationToken) { shellState = shellState ?? throw new ArgumentNullException(nameof(shellState)); programState = programState ?? throw new ArgumentNullException(nameof(programState)); parseResult = parseResult ?? throw new ArgumentNullException(nameof(parseResult)); if (parseResult.Sections.Count == 2) { programState.BaseAddress = null; } else if (parseResult.Sections.Count != 3 || string.IsNullOrEmpty(parseResult.Sections[2]) || !Uri.TryCreate(parseResult.Sections[2].EnsureTrailingSlash(), UriKind.Absolute, out Uri serverUri)) { shellState.ConsoleManager.Error.WriteLine(Strings.SetBaseCommand_MustSpecifyServerError.SetColor(programState.ErrorColor)); } else { programState.BaseAddress = serverUri; try { using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Head, serverUri)) { await programState.Client.SendAsync(request).ConfigureAwait(false); } } catch (Exception ex) when(ex.InnerException is SocketException se) { shellState.ConsoleManager.Error.WriteLine(String.Format(Strings.SetBaseCommand_HEADRequestUnSuccessful, se.Message).SetColor(programState.WarningColor)); } catch { } } }
public Task ExecuteAsync(IShellState shellState, object programState, ICoreParseResult parseResult, CancellationToken cancellationToken) { shellState = shellState ?? throw new ArgumentNullException(nameof(shellState)); shellState.ConsoleManager.Clear(); shellState.CommandDispatcher.OnReady(shellState); return(Task.CompletedTask); }
public bool?CanHandle(IShellState shellState, HttpState programState, ICoreParseResult parseResult) { parseResult = parseResult ?? throw new ArgumentNullException(nameof(parseResult)); return(parseResult.ContainsAtLeast(minimumLength: 2, Name) && parseResult.Sections.Count < 4 ? (bool?)true : null); }
public void SetInput(IShellState state, string input) { state = state ?? throw new ArgumentNullException(nameof(state)); input = input ?? throw new ArgumentNullException(nameof(input)); SetInput(state, input.ToCharArray()); }