public static void Error(string message) { lock (_lock) { _reporter.Error(message); } }
private void processBeatmap(int beatmapId, List <Ruleset> rulesets) { try { var localBeatmap = BeatmapLoader.GetBeatmap(beatmapId, Verbose, ForceDownload); if (localBeatmap == null) { reporter.Warn($"Beatmap {beatmapId} skipped (beatmap file not found)."); return; } using (var conn = MasterDatabase.GetConnection()) { if (Converts && localBeatmap.BeatmapInfo.RulesetID == 0) { foreach (var ruleset in rulesets) { computeDifficulty(beatmapId, localBeatmap, ruleset, conn); } } else if (rulesets.Any(r => r.RulesetInfo.ID == localBeatmap.BeatmapInfo.RulesetID)) { computeDifficulty(beatmapId, localBeatmap, localBeatmap.BeatmapInfo.Ruleset.CreateInstance(), conn); } } reporter.Verbose($"Difficulty updated for beatmap {beatmapId}."); } catch (Exception e) { reporter.Error($"{beatmapId} failed with: {e}"); } Interlocked.Increment(ref processedBeatmaps); }
private static int CleanHttpsCertificates(IReporter reporter) { var manager = CertificateManager.Instance; try { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { reporter.Output("Cleaning HTTPS development certificates from the machine. A prompt might get " + "displayed to confirm the removal of some of the certificates."); } if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { reporter.Output("Cleaning HTTPS development certificates from the machine. This operation might " + "require elevated privileges. If that is the case, a prompt for credentials will be displayed."); } manager.CleanupHttpsCertificates(); reporter.Output("HTTPS development certificates successfully removed from the machine."); return(Success); } catch (Exception e) { reporter.Error("There was an error trying to clean HTTPS development certificates on this machine."); reporter.Error(e.Message); return(ErrorCleaningUpCertificates); } }
public async Task <int> RunAsync(string[] args) { CommandLineOptions options; try { options = CommandLineOptions.Parse(args, _console); } catch (CommandParsingException ex) { _reporter.Error(ex.Message); return(1); } if (options == null) { // invalid args syntax return(1); } if (options.IsHelp) { return(2); } // update reporter as configured by options _reporter = CreateReporter(options.IsVerbose, options.IsQuiet, _console); try { _cts.Token.ThrowIfCancellationRequested(); await RunCoreAsync(options); return(await Task.FromResult(0)); } catch (OperationCanceledException) { // swallow when only exception is the CTRL+C forced an exit return(0); } catch (Exception ex) { _reporter.Error(ex.ToString()); if (ex is ReflectionTypeLoadException reflectionTypeLoadException) { foreach (Exception loaderException in reflectionTypeLoadException.LoaderExceptions) { _reporter.Error(loaderException.ToString()); } } _reporter.Error("An unexpected error occurred"); return(1); } }
private async Task <int> OnExecute(CommandLineApplication app, IConsole console) { try { if (string.IsNullOrEmpty(Path)) { Path = _fileSystem.Directory.GetCurrentDirectory(); } if (!(_fileSystem.File.Exists(Path) || _fileSystem.Directory.Exists(Path))) { _reporter.Error("Directory or file does not exist."); return(1); } var projFiles = new List <string>(); if (_fileSystem.File.Exists(Path)) { projFiles.Add(Path); } else { projFiles = _fileSystem.Directory.GetFiles(Path, "*.csproj", SearchOption.AllDirectories) .Concat(_fileSystem.Directory.GetFiles(Path, "*.fsproj", SearchOption.AllDirectories)).ToList(); } if (projFiles.Count == 0) { _reporter.Error(".csproj or .fsproj files not found."); return(1); } var projFilesWithNonSortedReferences = await Inspect(projFiles); if (IsInspect) { Console.WriteLine("Running inspection..."); PrintInspectionResults(projFiles, projFilesWithNonSortedReferences); return(projFilesWithNonSortedReferences.Count > 0 ? 1 : 0); } else { Console.WriteLine("Running sort package references..."); return(await SortReferences(projFilesWithNonSortedReferences)); } } catch (Exception e) { _reporter.Error(e.StackTrace); return(1); } }
public async Task <string> ExecuteAsync(string buildConfiguration, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var projectDir = Path.GetDirectoryName(_projectFile); OutputCapture capture = _outputSink.StartCapture(); IEnumerable <string> args = new[] { "msbuild", _projectFile, } .Concat(BuildFlags); if (buildConfiguration != null) { args = args.Append($"/p:Configuration=\"{buildConfiguration}\""); } var processSpec = new ProcessSpec { Executable = DotNetMuxer.MuxerPathOrDefault(), WorkingDirectory = projectDir, Arguments = args, OutputCapture = capture }; _reporter.Verbose($"Running MSBuild target '{TargetName}' on '{_projectFile}'"); var exitCode = await _processRunner.RunAsync(processSpec, cancellationToken); if (exitCode != 0) { _reporter.Error($"Failed to build the project file '{Path.GetFileName(_projectFile)}'"); DumpMSBuildOutput(capture); return(null); } Match targetPathMatch = capture.Lines .Select(line => Regex.Match(line, @"Bundling\.TargetPath=<(.+)>")) .FirstOrDefault(match => match.Success); if (targetPathMatch == null) { _reporter.Error("Failed to determine the path of the output assembly."); DumpMSBuildOutput(capture); return(null); } return(targetPathMatch.Groups[1].Value); }
private void processBeatmap(int beatmapId, List <Ruleset> rulesets) { try { reporter.Verbose($"Processing difficulty for beatmap {beatmapId}."); var localBeatmap = BeatmapLoader.GetBeatmap(beatmapId, Verbose, ForceDownload, reporter); if (localBeatmap == null) { reporter.Error($"Beatmap {beatmapId} skipped (beatmap file not found)."); return; } if (localBeatmap.Beatmap.HitObjects.Count == 0) { using (var conn = Database.GetSlaveConnection()) { if (conn?.QuerySingleOrDefault <int>("SELECT `approved` FROM `osu_beatmaps` WHERE `beatmap_id` = @BeatmapId", new { BeatmapId = beatmapId }) > 0) { reporter.Error($"Ranked beatmap {beatmapId} has 0 hitobjects!"); } } } using (var conn = Database.GetConnection()) { if (Converts && localBeatmap.BeatmapInfo.RulesetID == 0) { foreach (var ruleset in rulesets) { computeDifficulty(beatmapId, localBeatmap, ruleset, conn); } } else if (rulesets.Any(r => r.RulesetInfo.ID == localBeatmap.BeatmapInfo.RulesetID)) { computeDifficulty(beatmapId, localBeatmap, localBeatmap.BeatmapInfo.Ruleset.CreateInstance(), conn); } } reporter.Verbose($"Difficulty updated for beatmap {beatmapId}."); } catch (Exception e) { reporter.Error($"{beatmapId} failed with: {e.Message}"); } Interlocked.Increment(ref processedBeatmaps); }
public async Task <Auth0ResourceTemplate> Process(Auth0ResourceTemplate t) { var processor = _processorFactory.GetProcessor(t.Type); try { await processor.Validate(t); } catch (Exception e) { _reporter.Error($"Result of processing {t.Type.Name} template {t.Location.FullName} was not valid."); _reporter.Error(e.Message); } return(t); }
private static int Execute(IReporter reporter, string projectPath, string id) { if (!DevJwtCliHelpers.GetProjectAndSecretsId(projectPath, reporter, out var project, out var userSecretsId)) { return(1); } var jwtStore = new JwtStore(userSecretsId); if (!jwtStore.Jwts.ContainsKey(id)) { reporter.Error(Resources.FormatRemoveCommand_NoJwtFound(id)); return(1); } var jwt = jwtStore.Jwts[id]; var appsettingsFilePath = Path.Combine(Path.GetDirectoryName(project), "appsettings.Development.json"); JwtAuthenticationSchemeSettings.RemoveScheme(appsettingsFilePath, jwt.Scheme); jwtStore.Jwts.Remove(id); jwtStore.Save(); reporter.Output(Resources.FormatRemoveCommand_Confirmed(id)); return(0); }
public void Run(string[] args) { ProjectCommandLineApplication userJwts = new(_reporter) { Name = "dotnet user-jwts" }; userJwts.HelpOption("-h|--help"); // dotnet user-jwts list ListCommand.Register(userJwts); // dotnet user-jwts create CreateCommand.Register(userJwts); // dotnet user-jwts print ecd045 PrintCommand.Register(userJwts); // dotnet user-jwts remove ecd045 RemoveCommand.Register(userJwts); // dotnet user-jwts clear ClearCommand.Register(userJwts); // dotnet user-jwts key KeyCommand.Register(userJwts); // Show help information if no subcommand/option was specified. userJwts.OnExecute(() => userJwts.ShowHelp()); try { userJwts.Execute(args); } catch (Exception ex) { _reporter.Error(ex.Message); } } }
public static bool GetProjectAndSecretsId(string projectPath, IReporter reporter, out string project, out string userSecretsId) { project = GetProject(projectPath); userSecretsId = null; if (project == null) { reporter.Error(Resources.ProjectOption_ProjectNotFound); return(false); } userSecretsId = GetOrSetUserSecretsId(project); if (userSecretsId == null) { reporter.Error(Resources.ProjectOption_SercretIdNotFound); return(false); } return(true); }
private void ValidateCommandLineOptions(ApplicationCommandOptions options, IReporter reporter) { if (options.SignalRType == 1 && string.IsNullOrEmpty(options.ConnectionString)) { var err = "Use ASRS but forget to set connection string!"; reporter.Error(err); throw new InvalidOperationException(err); } }
public async Task <Auth0ResourceTemplate> Process(Auth0ResourceTemplate t) { var processor = _processorFactory.GetProcessor(t.Type); try { await processor.Preprocess(t); t.Preprocessed = true; } catch (Exception e) { _reporter.Error($"Result of preprocessing {t.Type.Name} template {t.Location.FullName} failed with an error."); _reporter.Error(e.Message); } return(t); }
public static bool GetProjectAndSecretsId(string projectPath, IReporter reporter, out string project, out string userSecretsId) { project = GetProject(projectPath); userSecretsId = null; if (project == null) { reporter.Error($"No project found at `-p|--project` path or current directory."); return(false); } userSecretsId = GetOrSetUserSecretsId(reporter, project); if (userSecretsId == null) { reporter.Error($"Project does not contain a user secrets ID."); return(false); } return(true); }
public async Task <int> OnExecute(CommandLineApplication app, IConsole console) { try { // If no path is set, use the current directory if (string.IsNullOrEmpty(Path)) { Path = _fileSystem.Directory.GetCurrentDirectory(); } // Get all the projects console.Write("Discovering projects..."); string projectPath = _projectDiscoveryService.DiscoverProject(Path); if (!console.IsOutputRedirected) { ClearCurrentConsoleLine(); } else { console.WriteLine(); } // Analyze the projects console.Write("Analyzing project and restoring packages..."); var projects = _projectAnalysisService.AnalyzeProject(projectPath, Transitive, TransitiveDepth); if (!console.IsOutputRedirected) { ClearCurrentConsoleLine(); } else { console.WriteLine(); } // Analyze the dependencies await AnalyzeDependencies(projects, console); // Report on the outdated dependencies ReportOutdatedDependencies(projects, console); // Upgrade the packages await UpgradePackages(projects, console); return(0); } catch (CommandValidationException e) { _reporter.Error(e.Message); return(1); } }
private int CreateTableAndIndexes(IReporter reporter) { ValidateConnectionString(); using (var connection = new SqlConnection(_connectionString)) { connection.Open(); var sqlQueries = new SqlQueries(_schemaName, _tableName); var command = new SqlCommand(sqlQueries.TableInfo, connection); using (var reader = command.ExecuteReader(CommandBehavior.SingleRow)) { if (reader.Read()) { reporter.Warn( $"Table with schema '{_schemaName}' and name '{_tableName}' already exists. " + "Provide a different table name and try again."); return(1); } } using (var transaction = connection.BeginTransaction()) { try { command = new SqlCommand(sqlQueries.CreateTable, connection, transaction); reporter.Verbose($"Executing {command.CommandText}"); command.ExecuteNonQuery(); command = new SqlCommand( sqlQueries.CreateNonClusteredIndexOnExpirationTime, connection, transaction); reporter.Verbose($"Executing {command.CommandText}"); command.ExecuteNonQuery(); transaction.Commit(); reporter.Output("Table and index were created successfully."); } catch (Exception ex) { reporter.Error( $"An error occurred while trying to create the table and index. {ex.Message}"); transaction.Rollback(); return(1); } } } return(0); }
public static WorkingBeatmap GetBeatmap(int beatmapId, bool verbose, bool forceDownload, IReporter reporter) { string fileLocation = Path.Combine(AppSettings.BeatmapsPath, beatmapId.ToString()) + ".osu"; if ((forceDownload || !File.Exists(fileLocation)) && AppSettings.AllowDownload) { if (verbose) { reporter.Verbose($"Downloading {beatmapId}."); } var req = new WebRequest(string.Format(AppSettings.DownloadPath, beatmapId)) { AllowInsecureRequests = true }; req.Failed += _ => { if (verbose) { reporter.Error($"Failed to download {beatmapId}."); } }; req.Finished += () => { if (verbose) { reporter.Verbose($"{beatmapId} successfully downloaded."); } }; req.Perform(); if (req.ResponseStream == null) { return(null); } if (AppSettings.SaveDownloaded) { using (var fileStream = File.Create(fileLocation)) { req.ResponseStream.CopyTo(fileStream); req.ResponseStream.Seek(0, SeekOrigin.Begin); } } return(req.ResponseStream != null ? new LoaderWorkingBeatmap(req.ResponseStream) : null); } return(!File.Exists(fileLocation) ? null : new LoaderWorkingBeatmap(fileLocation)); }
public static WorkingBeatmap GetBeatmap(int beatmapId, bool verbose = false, bool forceDownload = true, IReporter reporter = null) { string fileLocation = Path.Combine(AppSettings.BEATMAPS_PATH, beatmapId.ToString()) + ".osu"; if ((forceDownload || !File.Exists(fileLocation)) && AppSettings.ALLOW_DOWNLOAD) { Stream stream; if (verbose) { reporter?.Verbose($"Downloading {beatmapId}."); } stream = GetBeatmapByBid(beatmapId); if (stream == null) { var req = new WebRequest(string.Format(AppSettings.DOWNLOAD_PATH, beatmapId)) { AllowInsecureRequests = true, }; req.Failed += _ => { if (verbose) { reporter?.Error($"Failed to download {beatmapId}."); } }; req.Finished += () => { if (verbose) { reporter?.Verbose($"{beatmapId} successfully downloaded."); } }; req.Perform(); RedisHelper.HSet("beatmap", beatmapId.ToString(), req.GetResponseData()); stream = req.ResponseStream; } if (AppSettings.SAVE_DOWNLOADED) { using (var fileStream = File.Create(fileLocation)) { stream.CopyTo(fileStream); stream.Seek(0, SeekOrigin.Begin); } } return(new LoaderWorkingBeatmap(stream)); } return(!File.Exists(fileLocation) ? null : new LoaderWorkingBeatmap(fileLocation)); }
public async Task <Auth0ResourceTemplate> Process(Auth0ResourceTemplate t) { var allStrings = t.Template.SelectTokens("$..*").OfType <JValue>().Where(x => x.Type == JTokenType.String); // var regex = new Regex("(%%[a-zA-Z-_]+%%)+.*(?>(%%[a-zA-Z-_]+%%)+.*)"); var regex = new Regex("%%[a-zA-Z-_]+%%"); foreach (var sToken in allStrings) { var match = regex.Matches(sToken.Value as string ?? "").SelectMany(x => x.Groups.Values).ToList(); if (match.Any()) { _reporter.Error( $"{t.Type.Name} template {t.Filename} contains unresolved tokens, you should ensure " + $"you define every token to be replaced in the overrides file."); _reporter.Error($"[{string.Join(", ", match.Select(x => x.Value))}]"); } } return(t); }
private async Task <int> ListFilesAsync( IReporter reporter, string project, CancellationToken cancellationToken) { // TODO multiple projects should be easy enough to add here string projectFile; try { projectFile = MsBuildProjectFinder.FindMsBuildProject(_workingDirectory, project); } catch (FileNotFoundException ex) { reporter.Error(ex.Message); return(1); } var fileSetFactory = new MsBuildFileSetFactory(reporter, DotNetWatchOptions.Default, projectFile, waitOnError: false, trace: false); var files = await fileSetFactory.CreateAsync(cancellationToken); if (files == null) { return(1); } foreach (var group in files.GroupBy(g => g.FileKind).OrderBy(g => g.Key)) { if (group.Key == FileKind.StaticFile) { _console.Out.WriteLine("::: Watch Action: Refresh browser :::"); } foreach (var file in group) { if (file.FileKind == FileKind.StaticFile) { _console.Out.WriteLine($"{file.FilePath} ~/{file.StaticWebAssetPath}"); } else { _console.Out.WriteLine(file.FilePath); } } } return(0); }
private async Task <int> HandleWatch(CommandLineOptions options) { // update reporter as configured by options _reporter = CreateReporter(options.Verbose, options.Quiet, _console); try { if (_cts.IsCancellationRequested) { return(1); } if (options.List) { return(await ListFilesAsync(_reporter, options.Project, _cts.Token)); } else { return(await MainInternalAsync(_reporter, options.Project, options.RemainingArguments, _cts.Token)); } } catch (Exception ex) { if (ex is TaskCanceledException || ex is OperationCanceledException) { // swallow when only exception is the CTRL+C forced an exit return(0); } _reporter.Error(ex.ToString()); _reporter.Error("An unexpected error occurred"); return(1); } }
public void Control(IReporter reporter) { foreach (var rover in _rovers) { try { rover.LandOn(_plateau); rover.MoveOn(_plateau); reporter.Report(rover, Status.Ok); } catch (FallOffPlateau e) { reporter.Error(e.Message); reporter.Report(rover, Status.FellOff); } catch (CrashedIntoRover e) { reporter.Error(e.Message); reporter.Report(rover, Status.Crashed); } } }
public async Task ExecuteAsync(IEnumerable <Auth0ResourceTemplate> templates) { foreach (var template in templates) { var result = template; foreach (var stage in _pipeline) { _reporter.Verbose($"Processing {template.Type.Name} template {template.Filename} through stage {stage.Name}"); try { result = await stage.Process(result); } catch (Exception e) { _reporter.Error($"An error occurred processing {template.Type.Name} template {template.Filename} in stage \'{stage.Name}\'"); _reporter.Error(e.Message); _reporter.Error("Template cannot be processed further."); throw; } } } }
public async Task <int> OnExecute(CommandLineApplication app, IConsole console) { try { // If no path is set, use the current directory if (string.IsNullOrEmpty(Path)) { Path = _fileSystem.Directory.GetCurrentDirectory(); } // Get all the projects string projectPath = _projectDiscoveryService.DiscoverProject(Path); // Analyze the projects var projects = _projectAnalysisService.AnalyzeProject(projectPath); foreach (var project in projects) { int indentLevel = 1; WriteProjectName(console, project); // Increase indent if we have dependencies at project level if (project.Dependencies.Any()) { indentLevel++; } // Process each target framework with its related dependencies foreach (var targetFramework in project.TargetFrameworks) { WriteTargetFramework(console, targetFramework, indentLevel); foreach (var dependency in targetFramework.Dependencies) { await ReportDependency(console, dependency.Name, dependency.VersionRange, project.Sources, indentLevel, targetFramework); } } console.WriteLine(); } return(0); } catch (CommandValidationException e) { _reporter.Error(e.Message); return(1); } }
public Auth0TokenFactory(HttpClient httpClient, IOptionsMonitor <Auth0AuthenticationConfig> config, IReporter reporter) { _httpClient = httpClient; _config = config; _reporter = reporter; _token = new AsyncLazy <string>(async() => { var disco = await _httpClient.GetDiscoveryDocumentAsync(address: $"https://{_config.CurrentValue.Domain}/"); if (disco.IsError) { _reporter.Error(disco.Error); _reporter.Error(disco.Exception.Message); throw disco.Exception; } var token = await _httpClient.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest() { Address = disco.TokenEndpoint, ClientId = _config.CurrentValue.ClientId, ClientSecret = _config.CurrentValue.ClientSecret, Parameters = new Dictionary <string, string> { { "audience", $"https://{_config.CurrentValue.Domain}/api/v2/" } } }); if (token.IsError) { _reporter.Error(token.ErrorDescription); _reporter.Error(token.Exception.Message); throw token.Exception; } return(token.AccessToken); }); }
public async Task <int> OnExecuteAsync(KafkaService kafkaService, IReporter reporter, ILogger <ProduceCommand> logger) { try { await kafkaService.ProduceContent(Topic, Path); return(0); } catch (Exception ex) { reporter.Error(ex.Message); logger.LogError(ex, nameof(OnExecuteAsync)); return(1); } }
public async Task <int> OnExecute(CommandLineApplication app, IConsole console) { try { // If no path is set, use the current directory if (string.IsNullOrEmpty(Path)) { Path = _fileSystem.Directory.GetCurrentDirectory(); } // Get all the projects string projectPath = _projectDiscoveryService.DiscoverProject(Path); // Analyze the projects var projects = _projectAnalysisService.AnalyzeProject(projectPath); foreach (var project in projects) { WriteProjectName(console, project); foreach (var dependency in project.Dependencies) { await ReportDependency(console, dependency, 1); } foreach (var targetFramework in project.TargetFrameworks) { WriteTargetFramework(console, targetFramework); foreach (var dependency in targetFramework.Dependencies) { await ReportDependency(console, dependency, 2); } } console.WriteLine(); } return(0); } catch (CommandValidationException e) { _reporter.Error(e.Message); return(1); } }
private async Task <int> MainInternalAsync( IReporter reporter, string project, ICollection <string> args, CancellationToken cancellationToken) { // TODO multiple projects should be easy enough to add here string projectFile; try { projectFile = MsBuildProjectFinder.FindMsBuildProject(_workingDirectory, project); } catch (FileNotFoundException ex) { reporter.Error(ex.Message); return(1); } var watchOptions = DotNetWatchOptions.Default; var fileSetFactory = new MsBuildFileSetFactory(reporter, watchOptions, projectFile, waitOnError: true, trace: false); var processInfo = new ProcessSpec { Executable = DotNetMuxer.MuxerPathOrDefault(), WorkingDirectory = Path.GetDirectoryName(projectFile), Arguments = args, EnvironmentVariables = { ["DOTNET_WATCH"] = "1" }, }; if (CommandLineOptions.IsPollingEnabled) { _reporter.Output("Polling file watcher is enabled"); } await using var watcher = new DotNetWatcher(reporter, fileSetFactory, watchOptions); await watcher.WatchAsync(processInfo, cancellationToken); return(0); }
private int ScriptTableAndIndexes(IReporter reporter) { Action <string> writer = reporter.Output; StreamWriter streamWriter = default; try { if (_outputPath is not null) { streamWriter = new StreamWriter(_outputPath); writer = streamWriter.WriteLine; } var sqlQueries = CreateSqlQueries(); if (_idempotent) { writer("IF NOT EXISTS ("); writer("\t" + sqlQueries.TableInfo); writer(")"); writer("BEGIN"); } var prefix = _idempotent ? "\t" : ""; writer(prefix + sqlQueries.CreateTable); writer(prefix + sqlQueries.CreateNonClusteredIndexOnExpirationTime); if (_idempotent) { writer("END"); } return(0); } catch (Exception ex) { reporter.Error( $"An error occurred while trying to script the table and index. {ex.Message}"); return(1); } finally { streamWriter?.Dispose(); } }
protected async Task <int> UpdateIssueItemState(IConsole console, string issueReference, ItemState newState, string comment) { try { var(issue, repository) = await GetIssueAsync(issueReference); // Check if we're working with an already closed issue if (issue.State == newState) { _reporter.Warn($"Issue {repository.Owner.Login}/{repository.Name}#{issue.Number} is already {newState.ToString().ToLower()}. No action taken."); return(ReturnCodes.Error); } // Add an optional comment if (!string.IsNullOrEmpty(comment)) { await GitHubClient.Issue.Comment.Create(repository.Owner.Login, repository.Name, issue.Number, comment); } // Close the issue await GitHubClient.Issue.Update(repository.Owner.Login, repository.Name, issue.Number, new IssueUpdate { State = newState }); if (newState == ItemState.Closed) { console.Write("Closed "); } else { console.Write("Re-opened "); } console.Write($"{repository.Owner.Login}/{repository.Name}#{issue.Number}", ConsoleColor.Yellow); console.WriteLine(); } catch (CommandValidationException e) { _reporter.Error(e.Message); return(ReturnCodes.Error); } return(ReturnCodes.Ok); }