protected override IConsole CreateConsole(ScriptEngine engine, CommandLine commandLine, ConsoleOptions options) { var pyoptions = (PythonConsoleOptions) options; return pyoptions.BasicConsole ? new BasicConsole(options.ColorfulConsole) : new SuperConsole(commandLine, options.ColorfulConsole); }
public static CommandLine Parse(string commandLine) { if (String.IsNullOrEmpty(commandLine)) return null; var args = commandLine.Split(' ') .Select(x => x.Trim()) .Where(x => !String.IsNullOrEmpty(x)) .ToList(); if (args.Count == 0) return null; if (args[0] == "-") throw new InvalidOperationException("Char '-' must be followed by command or option name."); var cmdLine = new CommandLine(args[0].Substring(1)); for (var i = 1; i < args.Count; i++) { var arg = args[i]; if (arg.StartsWith("-")) { cmdLine.Options = CommandOptionCollection.Parse(args.Skip(i).ToList()); break; } else { cmdLine.Parameters.Add(arg); } } return cmdLine; }
public void Then_arguments_should_be_set_if_provided() { var commandLine = new CommandLine("exe value1 \"value2\""); Assert.AreEqual("value1", commandLine.Option1); Assert.AreEqual("value2", commandLine.Option2); }
/// <summary> /// Parses the command-line. /// </summary> /// <param name="args">Arguments from command-line.</param> /// <param name="commandLine">Command line object created from command-line arguments</param> /// <returns>True if command-line is parsed, false if a failure was occurred.</returns> public static bool TryParseArguments(string[] args, out CommandLine commandLine) { bool success = true; commandLine = new CommandLine(); for (int i = 0; i < args.Length; ++i) { if ('-' == args[i][0] || '/' == args[i][0]) { string arg = args[i].Substring(1).ToLowerInvariant(); if ("?" == arg || "help" == arg) { return false; } else if ("o" == arg || "out" == arg) { ++i; if (args.Length == i) { Console.Error.WriteLine(String.Format("Missing file specification for '-out' option.")); success = false; } else { string outputPath = Path.GetFullPath(args[i]); commandLine.OutputFolder = outputPath; } } } else { string[] file = args[i].Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries); string sourcePath = Path.GetFullPath(file[0]); if (!System.IO.File.Exists(sourcePath)) { Console.Error.WriteLine(String.Format("Source file '{0}' could not be found.", sourcePath)); success = false; } else { commandLine.Files.Add(sourcePath); } } } if (0 == commandLine.Files.Count) { Console.Error.WriteLine(String.Format("No inputs specified. Specify at least one file.")); success = false; } if (String.IsNullOrEmpty(commandLine.OutputFolder)) { Console.Error.WriteLine(String.Format("Ouput folder was not specified. Specify an output folder using the '-out' switch.")); success = false; } return success; }
static void Main(string[] args) { Console.Title = "Irony Console Sample"; Console.WriteLine("Irony Console Sample."); Console.WriteLine(""); Console.WriteLine("Select a grammar to load:"); Console.WriteLine(" 1. Expression Evaluator"); Console.WriteLine(" 2. mini-Python"); Console.WriteLine(" Or press any other key to exit."); Console.WriteLine(""); Console.Write("?"); var choice = Console.ReadLine(); Grammar grammar; switch (choice) { case "1": grammar = new ExpressionEvaluatorGrammar(); break; case "2": grammar = new MiniPython.MiniPythonGrammar(); break; default: return; } Console.Clear(); var commandLine = new CommandLine(grammar); commandLine.Run(); }
public void Then_options_should_be_set_if_provided() { var commandLine = new CommandLine("exe -opt1 -opt4 -opt2"); Assert.IsTrue(commandLine.Option1); Assert.IsTrue(commandLine.Option2); }
public CommandExecutorContext(ICommandExecutor executor, CommandLine commandLine, CommandTreeNode commandNode, object parameter) : base(executor, null, commandNode, parameter) { if(commandLine == null) throw new ArgumentNullException("commandLine"); _commandLine = commandLine; }
public void Handle(CommandLine commandLine) { if (_context.CurrentClient == null) { WriteError("You should define the current client first using 'connect %index'."); } HandleInternal(commandLine, _context.CurrentClient.RemoteClient); }
public void Then_options_should_be_set_if_provided() { var commandLine = new CommandLine("exe -opt1:value1 -opt4 -opt2:\"value2\""); Assert.AreEqual("value1", commandLine.Option1); Assert.AreEqual("value2", commandLine.Option2); }
public void DefaultProvider_invalidCommandLine_Throws() { var provider = Provider.Default; var commandLine = new CommandLine {[CommandLineParam.user] = Value.From("user")}; var connectionString = new ConnectionString(); var result = ConnectionStringBuilder.GetConnectionString(provider, commandLine, connectionString); }
public PythonCompletionData(string text, string stub, CommandLine commandLine, bool isInstance) { this.Text = text; this.Stub = stub; this.commandLine = commandLine; this.IsInstance = isInstance; }
/// <summary> /// This is the entry point into the DLL. It parses the command line and /// delegates the work out to each program. /// </summary> /// <param name="commandLine">The commandline that invoked the program. Usually /// this corresponds to System.Environment.CommandLine</param> /// <returns></returns> public static void DllMain(string commandLine) { CommandLine = new CommandLine(); Parser parser = new Parser(commandLine, CommandLine); parser.Parse(); if(CommandLine.Help) { Console.WriteLine("This program is used to import blog data from other blogging programs."); Console.WriteLine(" Note that this program will modify your content directory so back it up."); Console.WriteLine(" Also, the program will require an internet connection in some instances, "); Console.WriteLine(" like importing comments from an external server."); Console.WriteLine( parser.GetHelpText() ); } else { switch(CommandLine.Source) { case BlogSourceType.Radio: if(CommandLine.SourceDirectory != null && CommandLine.SourceDirectory.Length > 0 && CommandLine.ContentDirectory != null && CommandLine.ContentDirectory.Length > 0) { Console.WriteLine("Importing entries from Radio..."); DasBlog.Import.Radio.EntryImporter.Import( CommandLine.SourceDirectory, CommandLine.ContentDirectory); } else { Console.WriteLine("Entries from Radio not imported because either source directory or content directory were not specified."); } if(CommandLine.UserID != null && CommandLine.UserID.Length > 0 && CommandLine.ContentDirectory != null && CommandLine.ContentDirectory.Length > 0) { if(CommandLine.CommentServer != null && CommandLine.CommentServer.Length > 0) { Console.WriteLine("Defaulting to comment server {0}. You may need to check your radio source. radiocomments2, etc",DasBlog.Import.Radio.CommentImporter.DefaultCommentServer); } Console.WriteLine("BETA: Importing comments from Radio..."); DasBlog.Import.Radio.CommentImporter.Import( CommandLine.UserID, CommandLine.ContentDirectory, CommandLine.CommentServer ); } else { Console.WriteLine("Comments from Radio not imported because comment server, userid or content directory were not specified."); } break; case BlogSourceType.none: goto default; default: throw new ApplicationException( string.Format("The source option was not specified or else was invalid.")); } } }
public void DefaultProvider_EmptyCommandLine_Throws() { var provider = Provider.Default; var commandLine = new CommandLine(); var connectionString = new ConnectionString(); var result = ConnectionStringBuilder.GetConnectionString(provider, commandLine, connectionString); }
public void WithEmptyOption__GetOption__ReturnEmptyString() { string[] arguments = { "/" }; var commandLine = new CommandLine(arguments); var option = commandLine.Option(""); Assert.IsEmpty(option); }
public void Then_options_should_be_set_if_provided() { var commandLine = new CommandLine("exe -opt1:two -opt4 -opt2:\"bbb\""); Assert.AreEqual(Enum1.two, commandLine.Option1); Assert.AreEqual(Enum2.bbb, commandLine.Option2); }
public void WithValidOption__GetOptionWithNameInCaps__ReturnOption() { string[] arguments = { "/keyfile:file" }; var commandLine = new CommandLine(arguments); var option = commandLine.Option("KEYFILE"); Assert.AreEqual("file", option); }
public void WithValidOption__GetOtherOption__ReturnNull() { string[] arguments = { "/keyfile:file" }; var commandLine = new CommandLine(arguments); var option = commandLine.Option("union"); Assert.IsNull(option); }
public void WithInvalidOptionPrefix__GetOption__ReturnNull() { string[] arguments = { "&ver" }; var commandLine = new CommandLine(arguments); var option = commandLine.Option("ver"); Assert.IsNull(option); }
public void WithValidOptionPrefix__GetOption__ReturnNull() { string[] arguments = { "--keyfile:file", "--log" }; var commandLine = new CommandLine(arguments); var option = commandLine.Option("keyfile"); Assert.AreEqual("file", option); }
public static CommandLine Load(ICollection<string> args) { var assembly = Assembly.GetExecutingAssembly(); var info = FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion; Console.WriteLine(Resources.Splash, info); if (null == args) { return new CommandLine(); } var result = new CommandLine(args); if (!result.Help) { Console.WriteLine(string.Empty); Console.WriteLine(Resources.Usage); Console.WriteLine(string.Empty); Console.WriteLine(Resources.UsageDetails); Console.WriteLine(string.Empty); Console.WriteLine(Resources.Parameters); Console.WriteLine(string.Empty); Console.WriteLine(Resources.ParametersHelp); Console.WriteLine(Resources.ParametersInfo); Console.WriteLine(string.Empty); Console.WriteLine(Resources.HelpLink); } return result; }
public void WithEmptyOption__GetOption__ReturnNull() { string[] arguments = { "" }; var commandLine = new CommandLine(arguments); string option = commandLine.Option(""); Assert.IsNull(option); }
public void Then_options_should_be_set_if_provided() { var commandLine = new CommandLine("exe -opt1:12 -opt4 -opt2:\"13\""); Assert.AreEqual(12, commandLine.Option1); Assert.AreEqual(13, commandLine.Option2); }
/// <remarks> /// After the engine is created the standard output is replaced with our custom Stream class so we /// can redirect the stdout to the text editor window. /// This can be done in this method since the Runtime object will have been created before this method /// is called. /// </remarks> protected override IConsole CreateConsole(ScriptEngine engine, CommandLine commandLine, ConsoleOptions options) { ScriptingConsoleOutputStream stream = pythonConsole.CreateOutputStream(); SetOutput(stream); pythonConsole.CommandLine = commandLine; return pythonConsole; }
static void Main(string[] args) { var commandLine = new CommandLine(args); if (commandLine.Help) { commandLine.ShowHelp(Console.Out); Environment.ExitCode = 1; return; } if (commandLine.HasErrors) { commandLine.ShowErrors(Console.Error); Environment.ExitCode = 1; return; } try { if (SolutionFile.IsSolutionFileName(commandLine.ProjectFile)) { ProcessSolutionFile(commandLine); } else { ProcessProjectFile(commandLine); } Log.Info("Done"); } catch (Exception ex) { Log.Error("Unexpected exception: " + ex.Message); Environment.ExitCode = 1; } }
public void Execute(Session session, CommandLine line) { session.WriteLine("usage:"); session.WriteLine(" <command> [patameters ...]"); session.WriteLine(); session.WriteLine("commands:"); var mapper = session.GetCommandMapper(line); if (mapper == null) { foreach (var m in session.Engine.MapperManager.GetCommandMappers()) { this.HelpFor(m, session, line); } } else { this.HelpFor(mapper, session, line); var parameterFormater = session.Engine.GetCommandMember(z => z.ParametersFormater); var ParameterParser = session.Engine.GetCommandMember(z => z.CommandParameterParser); session.WriteLine(); session.WriteLine("parameters:"); foreach (var formatedString in parameterFormater.Format(mapper, mapper.ExecutorBuilder.Mappers, ParameterParser)) { session.WriteLine(" " + formatedString); } } }
private void Execute(CommandMapper mapper, CommandLine command) { var obj = mapper.CommandClassBuilder.Build(); var executor = mapper.ExecutorBuilder.CreateExecutor(obj); foreach (var kvp in command.Parameters) { var r = executor.SetParameter(kvp.Key, kvp.Value, this.Engine.MapperManager.GetAgent()); if (r.HasError) { this.WriteLine(r); return; } } var missing = executor.GetMissingParameters().ToArray(); if (missing.Length != 0) { this.Engine.GetCommandMember(z => z.MissingParametersFormater) .Format(this.Engine.GetCommandMember(z => z.Output), mapper, missing, this.Engine.GetCommandMember(z => z.CommandParameterParser)); this.Help(command); return; } executor.Execute(this, command); }
public IUpdateProcess CreateProcess(CommandLine cmdline) { Version ver; var version = cmdline["version"]; if(string.IsNullOrEmpty(version)) { ver = new Version(0, 0, 0, 0); } else { if(!Version.TryParse(version, out ver)) { ver = new Version(0, 0, 0, 0); } } var git = cmdline["git"]; if(string.IsNullOrEmpty(git)) { git = DetectGitExePath(); if(string.IsNullOrEmpty(git)) return null; } var url = cmdline["url"]; if(string.IsNullOrEmpty(url)) return null; var target = cmdline["target"]; if(string.IsNullOrEmpty(target)) return null; bool skipVersionCheck = cmdline.IsDefined("skipversioncheck"); return new UpdateFromGitRepositoryProcess(ver, git, url, target, skipVersionCheck); }
public void AutoLoadWithQuotes() { CommandLine commandLine = new CommandLine(); Parser parser = new Parser("DummyProgram.exe /SourceDir:\"c:\\Program Files\"", commandLine); parser.Parse(); Assert.AreEqual("c:\\Program Files", commandLine.SourceDirectory, "The source parameter is not correct."); }
static int Main( string[] args ) { CommandLine commandLine = new CommandLine(); int returnVal = 0; try { commandLine.Parse( args ); if( commandLine.Mode == SyncAppMode.RunEngine ) { RunSyncEngine( commandLine ); } else if( commandLine.Mode == SyncAppMode.CreateConfigTemplate ) { CreateConfigTemplateFile( commandLine ); } } catch( Exception e ) { Console.Error.WriteLine( "Error: {0}", e.ToString() ); returnVal = -1; } if( commandLine.PauseOnExit ) { Console.WriteLine(); Console.WriteLine( "Press any key to exit..." ); Console.ReadKey( true ); } return returnVal; }
public static void RunCommand(string[] inputArgs, CommandStatusWriter consoleOut) { using (CommandLine cmd = new CommandLine(consoleOut)) { cmd.Run(inputArgs); } }
/// <summary> /// This is the program entrypoint. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { string platform; KubeSetupHelper helper; commandLine = new CommandLine(args); var command = commandLine.Arguments.FirstOrDefault(); if (command != null) { command = command.ToLowerInvariant(); } if (commandLine.Arguments.Length == 0 || commandLine.HasHelpOption || command == "help") { Console.WriteLine(usage); Program.Exit(0); } try { Program.RepoRootFolder = Environment.GetEnvironmentVariable("NF_ROOT"); if (string.IsNullOrEmpty(Program.RepoRootFolder) || !Directory.Exists(Program.RepoRootFolder)) { Console.Error.WriteLine("*** ERROR: NF_ROOT environment variable does not reference the local neonKUBE repostory."); Program.Exit(1); } Program.DefaultKubernetesVersion = File.ReadAllText(Path.Combine(Program.RepoRootFolder, "kube-version.txt")).Trim(); // Handle the commands. switch (command) { case "clean": var buildFolder = Path.Combine(Program.RepoRootFolder, "Build"); if (Directory.Exists(buildFolder)) { NeonHelper.DeleteFolderContents(buildFolder); } if (commandLine.HasOption("--all")) { var buildCacheFolder = Path.Combine(Program.RepoRootFolder, "Build-cache"); if (Directory.Exists(buildCacheFolder)) { NeonHelper.DeleteFolderContents(buildCacheFolder); } } var cadenceResourcesPath = Path.Combine(Program.RepoRootFolder, "Lib", "Neon.Cadence", "Resources"); if (Directory.Exists(cadenceResourcesPath)) { NeonHelper.DeleteFolder(cadenceResourcesPath); } foreach (var folder in Directory.EnumerateDirectories(Program.RepoRootFolder, "bin", SearchOption.AllDirectories)) { if (Directory.Exists(folder)) { NeonHelper.DeleteFolder(folder); } } foreach (var folder in Directory.EnumerateDirectories(Program.RepoRootFolder, "obj", SearchOption.AllDirectories)) { if (Directory.Exists(folder)) { NeonHelper.DeleteFolder(folder); } } break; case "installer": platform = commandLine.Arguments.ElementAtOrDefault(1); if (string.IsNullOrEmpty(platform)) { Console.Error.WriteLine("*** ERROR: PLATFORM argument is required."); Program.Exit(1); } helper = new KubeSetupHelper(platform, commandLine, outputAction: text => Console.Write(text), errorAction: text => Console.Write(text)); EnsureOption("--kube-version", Program.DefaultKubernetesVersion); switch (helper.Platform) { case KubeClientPlatform.Windows: new WinInstallBuilder(helper).Run(); break; case KubeClientPlatform.Osx: throw new NotImplementedException(); } break; case "clear": platform = commandLine.Arguments.ElementAtOrDefault(1); if (string.IsNullOrEmpty(platform)) { Console.Error.WriteLine("*** ERROR: PLATFORM argument is required."); Program.Exit(1); } helper = new KubeSetupHelper(platform, commandLine, outputAction: text => Console.Write(text), errorAction: text => Console.Write(text)); helper.Clear(); break; case "download": platform = commandLine.Arguments.ElementAtOrDefault(1); if (string.IsNullOrEmpty(platform)) { Console.Error.WriteLine("*** ERROR: PLATFORM argument is required."); Program.Exit(1); } helper = new KubeSetupHelper(platform, commandLine, outputAction: text => Console.Write(text), errorAction: text => Console.Write(text)); EnsureOption("--kube-version", Program.DefaultKubernetesVersion); helper.Download(); break; case "copy": { var sourcePath = commandLine.Arguments.ElementAtOrDefault(1); var targetPath = commandLine.Arguments.ElementAtOrDefault(2); if (sourcePath == null) { Console.Error.WriteLine("*** ERROR: SOURCE argument is required."); Program.Exit(1); } if (targetPath == null) { Console.Error.WriteLine("*** ERROR: TARGET argument is required."); Program.Exit(1); } if (!File.Exists(sourcePath)) { Console.Error.WriteLine($"*** ERROR: SOURCE file [{sourcePath}] does not exist."); Program.Exit(1); } Directory.CreateDirectory(Path.GetDirectoryName(targetPath)); if (File.Exists(targetPath) && File.GetLastWriteTimeUtc(targetPath) > File.GetLastWriteTimeUtc(sourcePath)) { Console.WriteLine($"File [{targetPath}] is up to date."); Program.Exit(0); } Console.WriteLine($"COPY: [{sourcePath}] --> [{targetPath}]."); File.Copy(sourcePath, targetPath); } break; case "gzip": Gzip(commandLine); break; case "build-version": BuildVersion(commandLine); break; case "pack-version": PackVersion(commandLine); break; case "shfb": Shfb(commandLine); break; default: Console.Error.WriteLine($"*** ERROR: Unexpected command [{command}]."); Program.Exit(1); break; } Program.Exit(0); } catch (Exception e) { Console.Error.WriteLine($"*** ERROR: {e.GetType().FullName}: {e.Message}"); Program.Exit(1); } }
static int Main(string[] args) { var nodeIndex = CommandLine.GetInt32("multinode.index"); var nodeRole = CommandLine.GetProperty("multinode.role"); var assemblyFileName = CommandLine.GetProperty("multinode.test-assembly"); var typeName = CommandLine.GetProperty("multinode.test-class"); var testName = CommandLine.GetProperty("multinode.test-method"); var displayName = testName; var listenAddress = IPAddress.Parse(CommandLine.GetProperty("multinode.listen-address")); var listenPort = CommandLine.GetInt32("multinode.listen-port"); var listenEndpoint = new IPEndPoint(listenAddress, listenPort); var system = ActorSystem.Create("NoteTestRunner-" + nodeIndex); var tcpClient = _logger = system.ActorOf <RunnerTcpClient>(); system.Tcp().Tell(new Tcp.Connect(listenEndpoint), tcpClient); #if CORECLR // In NetCore, if the assembly file hasn't been touched, // XunitFrontController would fail loading external assemblies and its dependencies. AssemblyLoadContext.Default.Resolving += (assemblyLoadContext, assemblyName) => DefaultOnResolving(assemblyLoadContext, assemblyName, assemblyFileName); var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyFileName); DependencyContext.Load(assembly) .CompileLibraries .Where(dep => dep.Name.ToLower() .Contains(assembly.FullName.Split(new[] { ',' })[0].ToLower())) .Select(dependency => AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(dependency.Name))); #endif Thread.Sleep(TimeSpan.FromSeconds(10)); using (var controller = new XunitFrontController(AppDomainSupport.IfAvailable, assemblyFileName)) { /* need to pass in just the assembly name to Discovery, not the full path * i.e. "Akka.Cluster.Tests.MultiNode.dll" * not "bin/Release/Akka.Cluster.Tests.MultiNode.dll" - this will cause * the Discovery class to actually not find any individual specs to run */ var assemblyName = Path.GetFileName(assemblyFileName); Console.WriteLine("Running specs for {0} [{1}]", assemblyName, assemblyFileName); using (var discovery = new Discovery(assemblyName, typeName)) { using (var sink = new Sink(nodeIndex, nodeRole, tcpClient)) { try { controller.Find(true, discovery, TestFrameworkOptions.ForDiscovery()); discovery.Finished.WaitOne(); controller.RunTests(discovery.TestCases, sink, TestFrameworkOptions.ForExecution()); } catch (AggregateException ex) { var specFail = new SpecFail(nodeIndex, nodeRole, displayName); specFail.FailureExceptionTypes.Add(ex.GetType().ToString()); specFail.FailureMessages.Add(ex.Message); specFail.FailureStackTraces.Add(ex.StackTrace); foreach (var innerEx in ex.Flatten().InnerExceptions) { specFail.FailureExceptionTypes.Add(innerEx.GetType().ToString()); specFail.FailureMessages.Add(innerEx.Message); specFail.FailureStackTraces.Add(innerEx.StackTrace); } _logger.Tell(specFail.ToString()); Console.WriteLine(specFail); //make sure message is send over the wire FlushLogMessages(); Environment.Exit(1); //signal failure return(1); } catch (Exception ex) { var specFail = new SpecFail(nodeIndex, nodeRole, displayName); specFail.FailureExceptionTypes.Add(ex.GetType().ToString()); specFail.FailureMessages.Add(ex.Message); specFail.FailureStackTraces.Add(ex.StackTrace); var innerEx = ex.InnerException; while (innerEx != null) { specFail.FailureExceptionTypes.Add(innerEx.GetType().ToString()); specFail.FailureMessages.Add(innerEx.Message); specFail.FailureStackTraces.Add(innerEx.StackTrace); innerEx = innerEx.InnerException; } _logger.Tell(specFail.ToString()); Console.WriteLine(specFail); //make sure message is send over the wire FlushLogMessages(); Environment.Exit(1); //signal failure return(1); } var timedOut = false; if (!sink.Finished.WaitOne(MaxProcessWaitTimeout)) //timed out { var line = string.Format("Timed out while waiting for test to complete after {0} ms", MaxProcessWaitTimeout); _logger.Tell(line); Console.WriteLine(line); timedOut = true; } FlushLogMessages(); system.Terminate().Wait(); Environment.Exit(sink.Passed && !timedOut ? 0 : 1); return(sink.Passed ? 0 : 1); } } } }
/// <inheritdoc/> public override void Run(CommandLine commandLine) { Help(); }
/// <summary> /// The program entry point. /// </summary> /// <param name="args">The command line arguments.</param> public static async Task <int> Main(params string[] args) { string usage = $@" {Program.Name} [v{Program.Version}] {Neon.Build.Copyright} USAGE: gh-tool COMMAND [ARG...] COMMANDS: gh-tool action run delete REPO [WORKFLOW-NAME] [--max-age-days=AGE] "; try { ICommand command; CommandLine = new CommandLine(args); var validOptions = new HashSet <string>(); validOptions.Add("--help"); if (CommandLine.Arguments.Length == 0) { Console.WriteLine(usage); Program.Exit(0); } // Scan for enabled commands in the current assembly. var commands = new List <ICommand>(); foreach (var type in Assembly.GetExecutingAssembly().GetTypes()) { if (!type.Implements <ICommand>()) { continue; } var commandAttribute = type.GetCustomAttribute <CommandAttribute>(); if (commandAttribute == null || commandAttribute.Disabled) { continue; } commands.Add((ICommand)Activator.CreateInstance(type)); } // Short-circuit the help command. if (CommandLine.Arguments[0] == "help") { if (CommandLine.Arguments.Length == 1) { Console.WriteLine(usage); Program.Exit(0); } CommandLine = CommandLine.Shift(1); command = GetCommand(CommandLine, commands); if (command == null) { Console.Error.WriteLine($"*** ERROR: Unexpected [{CommandLine.Arguments[0]}] command."); Program.Exit(1); } command.Help(); Program.Exit(0); } // Lookup the command. command = GetCommand(CommandLine, commands); if (command == null) { Console.Error.WriteLine($"*** ERROR: Unexpected [{CommandLine.Arguments[0]}] command."); Program.Exit(1); } // Ensure that there are no unexpected command line options. if (command.CheckOptions) { foreach (var optionName in command.ExtendedOptions) { validOptions.Add(optionName); } foreach (var option in CommandLine.Options) { if (!validOptions.Contains(option.Key)) { var commandWords = string.Empty; foreach (var word in command.Words) { if (commandWords.Length > 0) { commandWords += " "; } commandWords += word; } Console.Error.WriteLine($"*** ERROR: [{commandWords}] command does not support [{option.Key}]."); Program.Exit(1); } } } // Run the command. if (command.SplitItem != null) { // We don't shift the command line for pass-thru commands // because we don't want to change the order of any options. await command.RunAsync(CommandLine); } else { await command.RunAsync(CommandLine.Shift(command.Words.Length)); } } catch (ProgramExitException e) { return(e.ExitCode); } catch (Exception e) { Console.Error.WriteLine($"*** ERROR: {NeonHelper.ExceptionError(e)}"); Console.Error.WriteLine(e.StackTrace); Console.Error.WriteLine(string.Empty); return(1); } return(0); }
public static void RunTests(Options o) { var nullMessage = new Xunit.NullMessageSink(); var discoveryOptions = TestFrameworkOptions.ForDiscovery(); using (var c = new XunitFrontController(AppDomainSupport.Denied, o.Assembly, null, false)) { var tv = new TestDiscoverySink(); var excludeTestCaseSet = new TestDiscoverySink(); c.Find(true, tv, discoveryOptions); tv.Finished.WaitOne(); foreach (var tc in tv.TestCases) { var method = tc.TestMethod.Method; var attributes = method.GetCustomAttributes(typeof(FactAttribute)); foreach (ReflectionAttributeInfo at in attributes) { var result = at.GetNamedArgument<string>("Skip"); if (result != null) { Console.WriteLine("SKIPPY! {0} because {1}", method, result); } if (o.TestType != TestType.All) { if (!at.ToString().EndsWith(o.TestType.ToString())) { excludeTestCaseSet.TestCases.Add(tc); } } } } foreach (var tc in excludeTestCaseSet.TestCases) { tv.TestCases.Remove(tc); } Console.WriteLine("TEST COUNT: {0}", tv.TestCases.Count); //core execution Sink int testCaseCount = tv.TestCases.Count; Stream file = new FileStream(".\\result.xml", FileMode.Create); int totalResult = 0; int totalErrors = 0; int totalFailed = 0; int totalSkipped = 0; for (int i = 0; i < testCaseCount; i++) { IExecutionSink resultsSink; ConcurrentDictionary<string, ExecutionSummary> completionMessages = new ConcurrentDictionary<string, ExecutionSummary>(); IMessageSinkWithTypes reporterMessageHandler; var reporters = GetAvailableRunnerReporters(); var commandLine = CommandLine.Parse(reporters, @"CoreXunit.dll"); IRunnerLogger logger = new ConsoleRunnerLogger(!commandLine.NoColor); reporterMessageHandler = MessageSinkWithTypesAdapter.Wrap(commandLine.Reporter.CreateMessageHandler(logger)); var xmlElement = new XElement("TestResult"); resultsSink = new XmlAggregateSink(reporterMessageHandler, completionMessages, xmlElement, () => true); var message = new Xunit.NullMessageSink(); var executionOptions = TestFrameworkOptions.ForExecution(); c.RunTests(tv.TestCases.Take<Xunit.Abstractions.ITestCase>(1), resultsSink, executionOptions); resultsSink.Finished.WaitOne(o.TimeOut); tv.TestCases.RemoveAt(0); totalResult++; totalErrors = totalErrors + resultsSink.ExecutionSummary.Errors; totalFailed = totalFailed + resultsSink.ExecutionSummary.Failed; totalSkipped = totalSkipped + resultsSink.ExecutionSummary.Skipped; xmlElement.Save(file); file.Flush(); } file.Dispose(); Console.WriteLine("Total tests: " + totalResult); Console.ForegroundColor = ConsoleColor.DarkRed; Console.WriteLine("Error tests: " + totalErrors); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Failed tests: " + totalFailed); Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Skipped tests: " + totalSkipped); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Passed tests: " + (totalResult - totalErrors - totalFailed - totalSkipped)); Console.ResetColor(); } }
public static bool Parse(string commandText) { return(CommandLine.Parse <Command>(commandText, InitializeCommandLineParser) .All(option => option.Execute())); }
static void Main(params string[] args) { System.Threading.Thread.CurrentThread.Name = "Manager"; Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); // Parse Command Line options CommandLineOptions mpArgs = new CommandLineOptions(); try { CommandLine.Parse(args, mpArgs); } catch (ArgumentException) { mpArgs.DisplayOptions(); return; } using (new ServiceScope(true)) //This is the first servicescope { ApplicationCore.RegisterCoreServices(); IPathManager pathManager = ServiceScope.Get <IPathManager>(); // Check if user wants to override the default Application Data location. if (mpArgs.IsOption(CommandLineOptions.Option.Data)) { pathManager.ReplacePath("DATA", (string)mpArgs.GetOption(CommandLineOptions.Option.Data)); } //Check whether the user wants to log method names in the logger //This adds an extra 10 to 40 milliseconds to the log call, depending on the length of the stack trace bool logMethods = mpArgs.IsOption(CommandLineOptions.Option.LogMethods); LogLevel level = LogLevel.All; if (mpArgs.IsOption(CommandLineOptions.Option.LogLevel)) { level = (LogLevel)mpArgs.GetOption(CommandLineOptions.Option.LogLevel); } ILogger logger = ServiceScope.Get <ILogger>(); logger.Level = level; logger.LogMethodNames = logMethods; logger.Debug("Manager: Registering Strings Manager"); ServiceScope.Add <ILocalisation>(new StringManager()); #if !DEBUG // Not in Debug mode (ie Release) then catch all Exceptions // In Debug mode these will be left unhandled. try { #endif // Start the system logger.Debug("ApplicationLauncher: Starting MediaPortal manager"); IPluginManager pluginManager = ServiceScope.Get <IPluginManager>(); pluginManager.Initialize(); pluginManager.Startup(true); Application.Run(new MainWindow()); pluginManager.Shutdown(); #if !DEBUG } catch (Exception ex) { CrashLogger crash = new CrashLogger(pathManager.GetPath("<LOG>")); crash.CreateLog(ex); //Form frm = // new YesNoDialogScreen("MediaPortal 2", "Unrecoverable Error", // "MediaPortal has encountered an unrecoverable error\r\nDetails have been logged\r\n\r\nRestart?", // BaseScreen.Image.bug); //restart = frm.ShowDialog() == DialogResult.Yes; } #endif } }
private static void WriteWarning(string message) { CommandLine.WriteLineColor(ConsoleColor.Yellow, Strings.WarningMessage(message)); }
private static void WriteVerbose(string message) { CommandLine.WriteLineColor(ConsoleColor.DarkGray, message); }
public static async Task Run() { // Disable Grpc logging GrpcEnvironment.DisableLogging(); // Locals var client = default(SimpleClient); try { // Get examples config var config = Utilities.GetConfig(); // Create a Native .Net BigTable Client client = new SimpleClient(config); // Connect to the Googles await client.Connect(); // Get a list of table names var tableNames = client.GetTableNames().Result; // Ensure pricing table exists if (!tableNames.Value.Contains(Constants.PricingTable)) { // Inform user CommandLine.InformUser("Setup", "Missing example table. Please run the Examples.Bootstrap project."); // Hard stop return; } // Show the user DisplayTables(tableNames); // Wait for keypress CommandLine.WaitForUserAndThen("scan for rows"); // Scan for data var rows = client.Scan(Constants.PricingTable, Constants.ScanKeyStart, Constants.ScanKeyEnd).Result; // Show the user DisplayRows(rows); // Wait for keypress CommandLine.WaitForUserAndThen("seek for row"); // Seek for data var row = client.Seek(Constants.PricingTable, Constants.SeekKey).Result; // Show the user DisplayRows(row); } catch (Exception exception) { CommandLine.InformUser("Oops", "Example didn't work out as planned"); CommandLine.RenderException(exception); } finally { // Pretty Console.WriteLine(); // Dispose if (client != default(SimpleClient)) { client.Dispose(); } // All done CommandLine.WaitForUserAndThen("exit"); } }
public void OnNext(BigRow value) { //Console.WriteLine(Thread.CurrentThread.ManagedThreadId); CommandLine.DisplayRows(new[] { value }); }
private static void WriteError(string message) { CommandLine.WriteLineColor(ConsoleColor.Red, Strings.ErrorMessage(message)); }
private static int Main() { if (CommandLine.ContainParameter("breakintodebugger")) { #if NETFRAMEWORK if (Environment.OSVersion.Platform == PlatformID.Win32NT) { System.Windows.Forms.MessageBox.Show("Debugger requested. Please attach a debugger and press OK"); } else #endif { Console.WriteLine("Debugger requested. Please attach a debugger and press ENTER to continue"); while (Console.ReadKey(true).Key != ConsoleKey.Enter) { Console.WriteLine("Press ENTER to continue"); } } Debugger.Break(); } // This GC gives a little bit better results than the other ones. "LowLatency" is giving really bad results(twice slower than the other ones). System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.SustainedLowLatency; AppDomain currentDomain = AppDomain.CurrentDomain; currentDomain.UnhandledException += AppDomain_UnhandledException; Mutex oneInstanceMutex = null; Argument parameters = new Argument(); ExitCode exitCode = ExitCode.Success; try { DebugEnable = CommandLine.ContainParameter("verbose") || CommandLine.ContainParameter("debug") || CommandLine.ContainParameter("diagnostics"); var sharpmakeAssembly = Assembly.GetExecutingAssembly(); Version version = sharpmakeAssembly.GetName().Version; string versionString = string.Join(".", version.Major, version.Minor, version.Build); string informationalVersion = sharpmakeAssembly.GetCustomAttribute <AssemblyInformationalVersionAttribute>()?.InformationalVersion; if (version.Revision != 0 || (informationalVersion != null && informationalVersion.IndexOf("+Branch.") == -1)) { versionString += " (non-official)"; if (DebugEnable && informationalVersion != null) { versionString += " " + informationalVersion; } } LogWriteLine($"sharpmake {versionString}"); LogWriteLine(" arguments: {0}", CommandLine.GetProgramCommandLine()); LogWriteLine(" directory: {0}", Directory.GetCurrentDirectory()); LogWriteLine(" platform: {0} - {1}", Util.GetExecutingPlatform().ToString(), RuntimeInformation.OSDescription); LogWriteLine(" compiled with framework: {0}", Util.FrameworkDisplayName()); LogWriteLine(" running on framework: {0}", RuntimeInformation.FrameworkDescription); LogWriteLine(string.Empty); // display help if wanted and quit if ((CommandLine.GetProgramCommandLine().Length == 0) || CommandLine.ContainParameter("help")) { LogWriteLine(CommandLine.GetCommandLineHelp(typeof(Argument), false)); return(CommandLine.ContainParameter("help") ? (int)ExitCode.Success : (int)ExitCode.Error); } AppDomain.CurrentDomain.AssemblyLoad += AppDomain_AssemblyLoad; // Log warnings and errors from builder Assembler.EventOutputError += ErrorWrite; Assembler.EventOutputWarning += WarningWrite; CommandLine.ExecuteOnObject(parameters); if (parameters.Exit) { return((int)ExitCode.Success); } const string sharpmakeSymbolPrefix = "_SHARPMAKE"; List <string> invalidSymbols = parameters.Defines.Where(define => define.StartsWith(sharpmakeSymbolPrefix)).ToList(); if (invalidSymbols.Any()) { string invalidSymbolsString = string.Join(", ", invalidSymbols); throw new Error($"Only Sharpmake process can define symbols starting with {sharpmakeSymbolPrefix}. Invalid symbols defined: {invalidSymbolsString}"); } parameters.Defines.Add(sharpmakeSymbolPrefix); // A generic sharpmake define to allow scripts to exclude part of code if not used with sharpmake parameters.Defines.Add($"{sharpmakeSymbolPrefix}_{version.Major}_{version.Minor}_X"); parameters.Defines.Add($"{sharpmakeSymbolPrefix}_{version.Major}_{version.Minor}_{version.Build}"); parameters.Validate(); // CommonPlatforms.dll is always loaded by default because those are shipped with // the Sharpmake package. PlatformRegistry.RegisterExtensionAssembly(typeof(Windows.Win32Platform).Assembly); // If any platform declares its own command line options, execute and validate // them as well. IEnumerable <Platform> platformsCmdLines = PlatformRegistry.GetAvailablePlatforms <ICommandLineInterface>(); foreach (var platform in platformsCmdLines) { var platformCmdLine = PlatformRegistry.Get <ICommandLineInterface>(platform); CommandLine.ExecuteOnObject(platformCmdLine); platformCmdLine.Validate(); } bool oneInstanceMutexCreated; string mutexName = string.Format("SharpmakeSingleInstanceMutex{0}", parameters.MutexSuffix); // Allow custom mutex name suffix. Useful to debug concurrently multiple sharpmake running from different branches oneInstanceMutex = new Mutex(true, mutexName, out oneInstanceMutexCreated); if (!oneInstanceMutexCreated) { try { if (!oneInstanceMutex.WaitOne(0)) { LogWriteLine("wait for another instance(s) of sharpmake to terminate..."); oneInstanceMutex.WaitOne(); } } catch (AbandonedMutexException) { // This occurs if another sharpmake is killed in the debugger } finally { LogWriteLine("waiting done."); } } if (parameters.RegexMatchCacheEnabled) { GlobalRegexMatchCache.Init(parameters.RegexMatchCacheInitialCapacity); } switch (parameters.TestOption) { case TestOptions.Regression: { var regressionTest = new BuildContext.RegressionTest(parameters.OutputDirectory, parameters.ReferenceDirectory, parameters.RemapRoot); GenerateAll(regressionTest, parameters); exitCode = ExitCode.Success; var regressions = regressionTest.GetRegressions().ToList(); if (regressions.Count > 0) { exitCode = ExitCode.Error; DebugWriteLine($"{regressions.Count} Regressions detected:"); List <BuildContext.RegressionTest.OutputInfo> fileChanges = regressions.Where(x => x.FileStatus == BuildContext.RegressionTest.FileStatus.Different).ToList(); LogFileChanges(fileChanges, parameters.RegressionDiff); var fileMissing = regressions.Where(x => x.FileStatus == BuildContext.RegressionTest.FileStatus.NotGenerated).Select(x => x.ReferencePath).ToList(); if (fileMissing.Count > 0) { fileMissing.Sort(); DebugWriteLine($" {fileMissing.Count} files are missing from the output:"); fileMissing.ForEach(x => DebugWriteLine($" {x}")); } } } break; case TestOptions.QuickConfigure: { exitCode = AnalyzeConfigureOrder(parameters, true); } break; case TestOptions.Configure: { exitCode = AnalyzeConfigureOrder(parameters, false); } break; case TestOptions.None: default: { if (parameters.OutputDirectory != null) { // output redirect mode var redirectOutput = new BuildContext.RedirectOutput(parameters.OutputDirectory, parameters.RemapRoot); GenerateAll(redirectOutput, parameters); exitCode = ExitCode.Success; } else { var generateAll = new BuildContext.GenerateAll(parameters.DebugLog, parameters.WriteFiles); GenerateAll(generateAll, parameters); exitCode = ExitCode.Success; Util.ExecuteFilesAutoCleanup(); } } break; } if (CSproj.AllCsProjSubTypesInfos.Any()) { Util.SerializeAllCsprojSubTypes(CSproj.AllCsProjSubTypesInfos); } if (parameters.RegexMatchCacheEnabled) { int regexMatchCacheInitialCapacity = parameters.RegexMatchCacheInitialCapacity; int regexMatchCacheSize = GlobalRegexMatchCache.Count; if (regexMatchCacheInitialCapacity < regexMatchCacheSize) { WarningWriteLine("Warning (perf): Consider increasing regex match cache initial capacity from {0} to at least {1} ( /regexMatchCacheInitialCapacity({1}) ).", regexMatchCacheInitialCapacity, regexMatchCacheSize); } GlobalRegexMatchCache.UnInit(); } } catch (Error e) { // Log error message Exception innerException = e; while (innerException.InnerException != null) { innerException = innerException.InnerException; } ErrorWriteLine(Environment.NewLine + "Error:" + Environment.NewLine + innerException.Message); // Then log details LogWriteLine(Util.GetCompleteExceptionMessage(e, "\t")); exitCode = ExitCode.Error; } catch (InternalError e) { ErrorWriteLine(Environment.NewLine + "Internal Error:"); LogWriteLine(Util.GetCompleteExceptionMessage(e, "\t")); exitCode = ExitCode.InternalError; } #if !DEBUG // Use this to catch right away if an exception throw catch (Exception e) { LogWriteLine(Environment.NewLine + "Exception Error:"); LogWriteLine(Util.GetCompleteExceptionMessage(e, "\t")); exitCode = ExitCode.UnknownError; } #endif finally { if (oneInstanceMutex != null) { oneInstanceMutex.ReleaseMutex(); GC.KeepAlive(oneInstanceMutex); } if (parameters.Debug) { Console.WriteLine("DEBUG Sharpmake.Application: Press any key to exit..."); Console.ReadKey(); } } LogWriteLine(@"{0} errors, {1} warnings", s_errorCount, s_warningCount); if (s_errorCount != 0) { if (Debugger.IsAttached) { LogWriteLine("Please look at the errors."); Debugger.Break(); } } // returning exit code and error count separately because they can result in an exit code of 0 if they are added together. if (s_errorCount != 0) { return(s_errorCount); } return((int)exitCode); }
/// <inheritdoc/> public override void Run(CommandLine commandLine) { if (commandLine.HasHelpOption) { Console.WriteLine(usage); Program.Exit(0); } var cluster = Program.GetCluster(); var extensions = KubeHelper.CurrentContext.Extension; NodeDefinition node; if (commandLine.Arguments.Length == 0) { node = cluster.GetReachableMaster().Metadata; } else { var name = commandLine.Arguments[0]; node = cluster.Definition.Nodes.SingleOrDefault(n => n.Name == name); if (node == null) { Console.Error.WriteLine($"*** ERROR: The node [{name}] was not found."); Program.Exit(1); } } // The host's SSH key fingerprint looks something like the example below. // We need to extract extract the bitcount and MD5 hash to generate a // WinSCP compatible host key fingerprint. // // 2048 MD5:cb:2f:f1:68:4b:aa:b3:8a:72:4d:53:f6:9f:5f:6a:fa root@manage-0 (RSA) const string md5Pattern = "MD5:"; string fingerprint; int bitCount; string md5; int startPos; int endPos; endPos = extensions.SshNodeFingerprint.IndexOf(' '); if (!int.TryParse(extensions.SshNodeFingerprint.Substring(0, endPos), out bitCount) || bitCount <= 0) { Console.Error.WriteLine($"*** ERROR: Cannot parse host's SSH key fingerprint [{extensions.SshNodeFingerprint}]."); Program.Exit(1); } startPos = extensions.SshNodeFingerprint.IndexOf(md5Pattern); if (startPos == -1) { Console.Error.WriteLine($"*** ERROR: Cannot parse host's SSH key fingerprint [{extensions.SshNodeFingerprint}]."); Program.Exit(1); } startPos += md5Pattern.Length; endPos = extensions.SshNodeFingerprint.IndexOf(' ', startPos); if (endPos == -1) { md5 = extensions.SshNodeFingerprint.Substring(startPos).Trim(); } else { md5 = extensions.SshNodeFingerprint.Substring(startPos, endPos - startPos).Trim(); } fingerprint = $"ssh-rsa {bitCount} {md5}"; // Launch WinSCP. if (!File.Exists(Program.WinScpPath)) { Console.Error.WriteLine($"*** ERROR: WinSCP application is not installed at [{Program.WinScpPath}]."); Program.Exit(1); } Process.Start(Program.WinScpPath, $@"scp://{extensions.SshUsername}:{extensions.SshPassword}@{node.PrivateAddress}:22 /hostkey=""{fingerprint}"" /newinstance /rawsettings Shell=""sudo%20-s"" compression=1"); }
private void OnPageLoaded(object sender, RoutedEventArgs e) { CommandLine.Focus(FocusState.Pointer); }
public void OnError(Exception exception) { CommandLine.RenderException(exception); }
/// <summary> /// Parse the command line options for this extension. /// </summary> /// <param name="type">The active harvester type.</param> /// <param name="args">The option arguments.</param> public override void ParseOptions(string type, string[] args) { if ("project" == type) { string[] allOutputGroups = VSProjectHarvester.GetOutputGroupNames(); bool suppressUniqueId = false; bool generateWixVars = false; GenerateType generateType = GenerateType.Components; string directoryIds = null; string projectName = null; string configuration = null; string platform = null; ArrayList outputGroups = new ArrayList(); for (int i = 0; i < args.Length; i++) { if ("-configuration" == args[i]) { configuration = args[++i]; } else if ("-directoryid" == args[i]) { if (!CommandLine.IsValidArg(args, ++i)) { throw new WixException(VSErrors.InvalidDirectoryId(args[i])); } directoryIds = args[i]; } else if ("-generate" == args[i]) { if (!CommandLine.IsValidArg(args, ++i)) { throw new WixException(VSErrors.InvalidOutputType(args[i])); } string genType = args[i].ToUpperInvariant(); switch (genType) { case "LAYOUT": generateType = GenerateType.Layout; break; case "CONTAINER": generateType = GenerateType.Container; break; case "COMPONENTS": generateType = GenerateType.Components; break; case "PACKAGEGROUP": generateType = GenerateType.PackageGroup; break; case "PAYLOADGROUP": generateType = GenerateType.PayloadGroup; break; default: throw new WixException(VSErrors.InvalidOutputType(genType)); } } else if ("-platform" == args[i]) { platform = args[++i]; } else if ("-pog" == args[i]) { if (!CommandLine.IsValidArg(args, ++i)) { throw new WixException(VSErrors.InvalidOutputGroup(args[i])); } string pogName = args[i]; bool found = false; foreach (string availableOutputGroup in allOutputGroups) { if (String.Equals(pogName, availableOutputGroup, StringComparison.Ordinal)) { outputGroups.Add(availableOutputGroup); found = true; break; } } if (!found) { throw new WixException(VSErrors.InvalidOutputGroup(pogName)); } } else if (args[i].StartsWith("-pog:", StringComparison.Ordinal)) { this.MessageHandler.Display(this, WixWarnings.DeprecatedCommandLineSwitch("pog:", "pog")); string pogName = args[i].Substring(5); bool found = false; foreach (string availableOutputGroup in allOutputGroups) { if (String.Equals(pogName, availableOutputGroup, StringComparison.Ordinal)) { outputGroups.Add(availableOutputGroup); found = true; break; } } if (!found) { throw new WixException(VSErrors.InvalidOutputGroup(pogName)); } } else if ("-projectname" == args[i]) { if (!CommandLine.IsValidArg(args, ++i)) { throw new WixException(VSErrors.InvalidProjectName(args[i])); } projectName = args[i]; } else if ("-suid" == args[i]) { suppressUniqueId = true; } else if ("-wixvar" == args[i]) { generateWixVars = true; } } if (outputGroups.Count == 0) { throw new WixException(VSErrors.NoOutputGroupSpecified()); } VSProjectHarvester harvester = new VSProjectHarvester( (string[])outputGroups.ToArray(typeof(string))); harvester.SetUniqueIdentifiers = !suppressUniqueId; harvester.GenerateWixVars = generateWixVars; harvester.GenerateType = generateType; harvester.DirectoryIds = directoryIds; harvester.ProjectName = projectName; harvester.Configuration = configuration; harvester.Platform = platform; this.Core.Harvester.Extension = harvester; } }
public void ReadXml(XmlReader reader) { Utility.Code.Require(reader, "reader"); string extension = reader.GetAttribute(Xml.Type); if (!string.IsNullOrEmpty(extension)) { this.ExtensionType = new Regex(extension); } reader.ReadStartElement(); reader.ConsumeUntilFirst(XmlReaderHelper.ElementFilter); string name = reader.Name; if ((name == Xml.DiscoveryCommandLine) || (name == Xml.DiscoveryFileMap)) { this.DiscoveryMethodType = (DiscoveryMethodType)Enum.Parse(typeof(DiscoveryMethodType), name); bool empty = reader.IsEmptyElement; reader.ReadStartElement(); if (name == Xml.DiscoveryCommandLine) { empty = false; this.DiscoveryCommandLine = CommandLine.FromString(reader.ReadString()); } else if (name == Xml.DiscoveryFileMap) { reader.ConsumeUntilFirst(XmlReaderHelper.ElementFilter); while (reader.NodeType == XmlNodeType.Element) { string key = reader.GetAttribute(Xml.DiscoveryFileMapSource); reader.MoveToElement(); empty = reader.IsEmptyElement; reader.ReadStartElement(); this.DiscoveryFileMap[key] = (empty) ? string.Empty : reader.ReadString(); if (!empty) { reader.ReadEndElement(); } reader.ConsumeUntilFirst(XmlReaderHelper.ElementFilter); } } if (!empty) { reader.ReadEndElement(); } reader.ConsumeUntilFirst(XmlReaderHelper.ElementFilter); } this.ExecutionCommandLine = CommandLine.FromString(reader.ReadElementString(Xml.ExecutionCommandLine)); reader.ReadEndElement(); }
public static string[] GetCommandLineArgs() => CommandLine.InternalCreateCommandLine(includeArg0: true);
private void CloseStatusButton_Click(object sender, RoutedEventArgs e) { CmdEnabledStatusPopup.IsOpen = false; CommandLine.Focus(FocusState.Keyboard); }
/// <inheritdoc/> public override async Task RunAsync(CommandLine commandLine) { Help(); Program.Exit(commandLine.Arguments.Length == 0 ? 0 : 1); await Task.CompletedTask; }
static int Main() { #if USE_EVENTSOURCE_REFLECTION // If this app does not take a dependency on a specific EventSource implementation we'll need to use the EventSource // type that represents the base type of the custom event source that needs to be registered. To accomplish this we // need to set up a separate domain that has the app base set to the location of the assembly to be registered, and // the config file set to the config file that might be associated with this assembly, in the case the assembly is // an EXE. Having the worker domain set up in this way allows for the regular assembly lookup rules to kick in and // perform the expected lookup the the EventSource-base assembly based on the passed in assembly. // In the worker domain we load in the "reflection-only" context the assembly passed in as an argument and allow its // dependency to be loaded as well. Once the base assembly is loaded in the reflection-only context we retrieve its // location and call LoadFrom() on the assembly in order to get access to the EventSource static methods we need to // call. var workerDomainFriendlyName = "eventRegister_workerDomain"; if (AppDomain.CurrentDomain.FriendlyName != workerDomainFriendlyName) { // See code:#CommandLineDefinitions for Command line defintions CommandLine commandLine = new CommandLine(); var ads = new AppDomainSetup(); // ads.PrivateBinPath = Path.GetDirectoryName(Path.GetFullPath(commandLine.DllPath)); ads.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory; // ads.ApplicationBase = Path.GetDirectoryName(Path.GetFullPath(commandLine.DllPath)); // var configName = Path.GetFullPath(commandLine.DllPath) + ".config"; // if (Path.GetExtension(commandLine.DllPath) == ".exe" && File.Exists(configName)) // ads.ConfigurationFile = configName; var workerDom = AppDomain.CreateDomain(workerDomainFriendlyName, null, ads, new System.Security.PermissionSet(System.Security.Permissions.PermissionState.Unrestricted)); // make sure the worker domain is aware of the additional paths to probe when resolving the EventSource base type if (commandLine.ReferencePath != null) { workerDom.SetData("ReferencePath", Environment.ExpandEnvironmentVariables(commandLine.ReferencePath)); } return(workerDom.ExecuteAssembly(typeof(Program).Assembly.Location)); } else #endif return(CommandLineUtilities.RunConsoleMainWithExceptionProcessing(delegate { // See code:#CommandLineDefinitions for Command line defintions CommandLine commandLine = new CommandLine(); List <Tuple <string, string> > regDlls; EventSourceReflectionProxy.ManifestGenerator = commandLine.ManifestGenerator; switch (commandLine.Command) { // Create the XML description in the data directory "will be called case CommandLine.CommandType.DumpManifest: var manifests = CreateManifestsFromManagedDll(commandLine.DllPath, commandLine.ManifestPrefix); if (manifests.Count == 0) { Console.WriteLine("Info: No event source classes " + (commandLine.ForceAll ? "" : "needing registration ") + "found in " + commandLine.DllPath); } break; case CommandLine.CommandType.CompileManifest: CompileManifest(commandLine.ManPath, System.IO.Path.ChangeExtension(commandLine.ManPath, ".dll")); break; case CommandLine.CommandType.DumpRegDlls: regDlls = CreateRegDllsFromManagedDll(commandLine.DllPath, commandLine.ForceAll, commandLine.ManifestPrefix); if (regDlls.Count == 0) { Console.WriteLine("Info: No event source classes " + (commandLine.ForceAll ? "" : "needing registration ") + "found in " + commandLine.DllPath); } break; case CommandLine.CommandType.Install: regDlls = RegisterManagedDll(commandLine.DllPath, false, commandLine.ManifestPrefix); if (regDlls.Count == 0) { Console.WriteLine("Info: No event source classes " + (commandLine.ForceAll ? "" : "needing registration ") + "found in " + commandLine.DllPath); } break; case CommandLine.CommandType.Uninstall: regDlls = RegisterManagedDll(commandLine.DllPath, true, commandLine.ManifestPrefix); if (regDlls.Count == 0) { Console.WriteLine("Info: No event source classes " + (commandLine.ForceAll ? "" : "needing registration ") + "found in " + commandLine.DllPath); } break; } return 0; })); }
public static int MainInner() { TextEncoding.WritingDefault = TextEncoding.UTF8; var CmdLine = CommandLine.GetCmdLine(); var argv = CmdLine.Arguments; if (CmdLine.Arguments.Length != 0) { DisplayInfo(); return(-1); } if (CmdLine.Options.Length == 0) { DisplayInfo(); return(0); } foreach (var opt in CmdLine.Options) { var optNameLower = opt.Name.ToLower(); if ((optNameLower == "?") || (optNameLower == "help")) { DisplayInfo(); return(0); } else if (optNameLower == "load") { var args = opt.Arguments; if (args.Length == 1) { var CookedObjectSchemaPath = args[0]; InvalidateSchema(); osl.LoadSchema(CookedObjectSchemaPath); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "save") { var args = opt.Arguments; if (args.Length == 1) { var CookedObjectSchemaPath = args[0]; var s = GetObjectSchema(); var ts = new TreeSerializer(); var t = ts.Write(s); TreeFile.WriteDirect(CookedObjectSchemaPath, t); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "loadtyperef") { var args = opt.Arguments; if (args.Length == 1) { var ObjectSchemaPath = args[0]; if (Directory.Exists(ObjectSchemaPath)) { foreach (var f in Directory.GetFiles(ObjectSchemaPath, "*.tree", SearchOption.AllDirectories).OrderBy(s => s, StringComparer.OrdinalIgnoreCase)) { InvalidateSchema(); osl.LoadTypeRef(f); } } else { InvalidateSchema(); osl.LoadTypeRef(ObjectSchemaPath); } } else { DisplayInfo(); return(-1); } } else if (optNameLower == "loadtype") { var args = opt.Arguments; if (args.Length == 1) { var ObjectSchemaPath = args[0]; if (Directory.Exists(ObjectSchemaPath)) { foreach (var f in Directory.GetFiles(ObjectSchemaPath, "*.tree", SearchOption.AllDirectories).OrderBy(s => s, StringComparer.OrdinalIgnoreCase)) { InvalidateSchema(); osl.LoadType(f); } } else { InvalidateSchema(); osl.LoadType(ObjectSchemaPath); } } else { DisplayInfo(); return(-1); } } else if (optNameLower == "import") { var args = opt.Arguments; if (args.Length == 1) { osl.AddImport(args[0]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "async") { var args = opt.Arguments; if (args.Length == 1) { InvalidateSchema(); LoadAsync(args[0]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2b") { var args = opt.Arguments; if (args.Length == 3) { TreeToBinary(args[0], args[1], args[2]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "b2t") { var args = opt.Arguments; if (args.Length == 3) { BinaryToTree(args[0], args[1], args[2]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2vb") { var args = opt.Arguments; if (args.Length == 1) { ObjectSchemaToVBCode(args[0], "", true); } else if (args.Length == 2) { ObjectSchemaToVBCode(args[0], args[1], true); } else if (args.Length == 3) { ObjectSchemaToVBCode(args[0], args[1], Boolean.Parse(args[2])); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2cs") { var args = opt.Arguments; if (args.Length == 1) { ObjectSchemaToCSharpCode(args[0], "", true); } else if (args.Length == 2) { ObjectSchemaToCSharpCode(args[0], args[1], true); } else if (args.Length == 3) { ObjectSchemaToCSharpCode(args[0], args[1], Boolean.Parse(args[2])); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2csb") { var args = opt.Arguments; if (args.Length == 1) { ObjectSchemaToCSharpBinaryCode(args[0], "", true); } else if (args.Length == 2) { ObjectSchemaToCSharpBinaryCode(args[0], args[1], true); } else if (args.Length == 3) { ObjectSchemaToCSharpBinaryCode(args[0], args[1], Boolean.Parse(args[2])); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2csj") { var args = opt.Arguments; if (args.Length == 1) { ObjectSchemaToCSharpJsonCode(args[0], ""); } else if (args.Length == 2) { ObjectSchemaToCSharpJsonCode(args[0], args[1]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2csc") { var args = opt.Arguments; if (args.Length == 4) { ObjectSchemaToCSharpCompatibleCode(args[0], args[1], args[2], args[3]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2csv") { var args = opt.Arguments; if (args.Length >= 2) { ObjectSchemaToCSharpVersionCode(args[0], args[1], args.Skip(2).ToList()); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2jv") { var args = opt.Arguments; if (args.Length == 2) { ObjectSchemaToJavaCode(args[0], args[1]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2jvb") { var args = opt.Arguments; if (args.Length == 2) { ObjectSchemaToJavaBinaryCode(args[0], args[1]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2cpp") { var args = opt.Arguments; if (args.Length == 1) { ObjectSchemaToCppCode(args[0], ""); } else if (args.Length == 2) { ObjectSchemaToCppCode(args[0], args[1]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2cppb") { var args = opt.Arguments; if (args.Length == 1) { ObjectSchemaToCppBinaryCode(args[0], "", true, true); } else if (args.Length == 2) { ObjectSchemaToCppBinaryCode(args[0], args[1], true, true); } else if (args.Length == 4) { ObjectSchemaToCppBinaryCode(args[0], args[1], Boolean.Parse(args[2]), Boolean.Parse(args[3])); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2cppc") { var args = opt.Arguments; if (args.Length == 4) { ObjectSchemaToCppCompatibleCode(args[0], args[1], args[2], args[3]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2cppv") { var args = opt.Arguments; if (args.Length >= 2) { ObjectSchemaToCppVersionCode(args[0], args[1], args.Skip(2).ToList()); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2hx") { var args = opt.Arguments; if (args.Length == 2) { ObjectSchemaToHaxeCode(args[0], args[1]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2hxj") { var args = opt.Arguments; if (args.Length == 2) { ObjectSchemaToHaxeJsonCode(args[0], args[1]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2py") { var args = opt.Arguments; if (args.Length == 1) { ObjectSchemaToPythonCode(args[0]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2pyb") { var args = opt.Arguments; if (args.Length == 1) { ObjectSchemaToPythonBinaryCode(args[0]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "t2xhtml") { var args = opt.Arguments; if (args.Length == 3) { ObjectSchemaToXhtml(args[0], args[1], args[2]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "gentypecmpt") { var args = opt.Arguments; if (args.Length % 2 == 1) { var ListOfObjectSchemaDirOrCookedObjectSchemaFileAndVersion = new List <KeyValuePair <String, String> >(); for (int k = 0; k < args.Length - 1; k += 2) { ListOfObjectSchemaDirOrCookedObjectSchemaFileAndVersion.Add(new KeyValuePair <String, String>(args[k], args[k + 1])); } GenerateTypeCompatibilityTreeFile(ListOfObjectSchemaDirOrCookedObjectSchemaFileAndVersion, args[args.Length - 1]); } else { DisplayInfo(); return(-1); } } else if (optNameLower == "gencomcmpt") { var args = opt.Arguments; if (args.Length % 2 == 1) { var ListOfObjectSchemaDirOrCookedObjectSchemaFileAndVersion = new List <KeyValuePair <String, String> >(); for (int k = 0; k < args.Length - 1; k += 2) { ListOfObjectSchemaDirOrCookedObjectSchemaFileAndVersion.Add(new KeyValuePair <String, String>(args[k], args[k + 1])); } GenerateTypeCompatibilityTreeFile(ListOfObjectSchemaDirOrCookedObjectSchemaFileAndVersion, args[args.Length - 1], true); } else { DisplayInfo(); return(-1); } } else { throw new ArgumentException(opt.Name); } } return(0); }
/// <summary> /// MultiNodeTestRunner takes the following <see cref="args"/>: /// /// C:\> Akka.MultiNodeTestRunner.exe [assembly name] [-Dmultinode.enable-filesink=on] [-Dmultinode.output-directory={dir path}] [-Dmultinode.spec={spec name}] /// /// <list type="number"> /// <listheader> /// <term>Argument</term> /// <description>The name and possible value of a given Akka.MultiNodeTestRunner.exe argument.</description> /// </listheader> /// <item> /// <term>AssemblyName</term> /// <description> /// The full path or name of an assembly containing as least one MultiNodeSpec in the current working directory. /// /// i.e. "Akka.Cluster.Tests.MultiNode.dll" /// "C:\akka.net\src\Akka.Cluster.Tests\bin\Debug\Akka.Cluster.Tests.MultiNode.dll" /// </description> /// </item> /// <item> /// <term>-Dmultinode.enable-filesink</term> /// <description>Having this flag set means that the contents of this test run will be saved in the /// current working directory as a .JSON file. /// </description> /// </item> /// <item> /// <term>-Dmultinode.multinode.output-directory</term> /// <description>Setting this flag means that any persistent multi-node test runner output files /// will be written to this directory instead of the default, which is the same folder /// as the test binary. /// </description> /// </item> /// <item> /// <term>-Dmultinode.listen-address={ip}</term> /// <description> /// Determines the address that this multi-node test runner will use to listen for log messages from /// individual NodeTestRunner.exe processes. /// /// Defaults to 127.0.0.1 /// </description> /// </item> /// <item> /// <term>-Dmultinode.listen-port={port}</term> /// <description> /// Determines the port number that this multi-node test runner will use to listen for log messages from /// individual NodeTestRunner.exe processes. /// /// Defaults to 6577 /// </description> /// </item> /// <item> /// <term>-Dmultinode.spec={spec name}</term> /// <description> /// Setting this flag means that only tests which contains the spec name will be executed /// otherwise all tests will be executed /// </description> /// </item> /// </list> /// </summary> static void Main(string[] args) { OutputDirectory = CommandLine.GetPropertyOrDefault("multinode.output-directory", string.Empty); FailedSpecsDirectory = CommandLine.GetPropertyOrDefault("multinode.failed-specs-directory", "FAILED_SPECS_LOGS"); string logLevel = CommandLine.GetPropertyOrDefault("multinode.loglevel", "WARNING"); TestRunSystem = ActorSystem.Create("TestRunnerLogging", $"akka.loglevel={logLevel}"); var suiteName = Path.GetFileNameWithoutExtension(Path.GetFullPath(args[0].Trim('"'))); var teamCityFormattingOn = CommandLine.GetPropertyOrDefault("multinode.teamcity", "false"); if (!Boolean.TryParse(teamCityFormattingOn, out TeamCityFormattingOn)) { throw new ArgumentException("Invalid argument provided for -Dteamcity"); } var listenAddress = IPAddress.Parse(CommandLine.GetPropertyOrDefault("multinode.listen-address", "127.0.0.1")); var listenPort = CommandLine.GetInt32OrDefault("multinode.listen-port", 6577); var listenEndpoint = new IPEndPoint(listenAddress, listenPort); var specName = CommandLine.GetPropertyOrDefault("multinode.spec", ""); var platform = CommandLine.GetPropertyOrDefault("multinode.platform", "net"); var reporter = CommandLine.GetPropertyOrDefault("multinode.reporter", "console"); var clearOutputDirectory = CommandLine.GetInt32OrDefault("multinode.clear-output", 0); if (clearOutputDirectory > 0 && Directory.Exists(OutputDirectory)) { Directory.Delete(OutputDirectory, true); } Props coordinatorProps; switch (reporter.ToLowerInvariant()) { case "trx": coordinatorProps = Props.Create(() => new SinkCoordinator(new[] { new TrxMessageSink(suiteName) })); break; case "teamcity": coordinatorProps = Props.Create(() => new SinkCoordinator(new[] { new TeamCityMessageSink(Console.WriteLine, suiteName) })); break; case "console": coordinatorProps = Props.Create(() => new SinkCoordinator(new[] { new ConsoleMessageSink() })); break; default: throw new ArgumentException($"Given reporter name '{reporter}' is not understood, valid reporters are: trx and teamcity"); } SinkCoordinator = TestRunSystem.ActorOf(coordinatorProps, "sinkCoordinator"); #if CORECLR if (!_validNetCorePlatform.Contains(platform)) { throw new Exception($"Target platform not supported: {platform}. Supported platforms are net and netcore"); } #else if (platform != "net") { throw new Exception($"Target platform not supported: {platform}. Supported platforms are net"); } #endif var tcpLogger = TestRunSystem.ActorOf(Props.Create(() => new TcpLoggingServer(SinkCoordinator)), "TcpLogger"); TestRunSystem.Tcp().Tell(new Tcp.Bind(tcpLogger, listenEndpoint), sender: tcpLogger); var assemblyPath = Path.GetFullPath(args[0].Trim('"')); //unquote the string first EnableAllSinks(assemblyPath, platform); PublishRunnerMessage($"Running MultiNodeTests for {assemblyPath}"); #if CORECLR // In NetCore, if the assembly file hasn't been touched, // XunitFrontController would fail loading external assemblies and its dependencies. var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath); var asms = assembly.GetReferencedAssemblies(); var basePath = Path.GetDirectoryName(assemblyPath); foreach (var asm in asms) { try { Assembly.Load(new AssemblyName(asm.FullName)); } catch (Exception) { var path = Path.Combine(basePath, asm.Name + ".dll"); try { AssemblyLoadContext.Default.LoadFromAssemblyPath(path); } catch (Exception e) { Console.Out.WriteLine($"Failed to load dll: {path}"); } } } #endif using (var controller = new XunitFrontController(AppDomainSupport.IfAvailable, assemblyPath)) { using (var discovery = new Discovery()) { controller.Find(false, discovery, TestFrameworkOptions.ForDiscovery()); discovery.Finished.WaitOne(); if (discovery.WasSuccessful) { foreach (var test in discovery.Tests.Reverse()) { if (!string.IsNullOrEmpty(test.Value.First().SkipReason)) { PublishRunnerMessage($"Skipping test {test.Value.First().MethodName}. Reason - {test.Value.First().SkipReason}"); continue; } if (!string.IsNullOrWhiteSpace(specName) && CultureInfo.InvariantCulture.CompareInfo.IndexOf(test.Value.First().TestName, specName, CompareOptions.IgnoreCase) < 0) { PublishRunnerMessage($"Skipping [{test.Value.First().MethodName}] (Filtering)"); continue; } var processes = new List <Process>(); PublishRunnerMessage($"Starting test {test.Value.First().MethodName}"); Console.Out.WriteLine($"Starting test {test.Value.First().MethodName}"); StartNewSpec(test.Value); #if CORECLR var ntrNetPath = Path.Combine(AppContext.BaseDirectory, "Akka.NodeTestRunner.exe"); var ntrNetCorePath = Path.Combine(AppContext.BaseDirectory, "Akka.NodeTestRunner.dll"); var alternateIndex = 0; #endif var timelineCollector = TestRunSystem.ActorOf(Props.Create(() => new TimelineLogCollectorActor())); string testOutputDir = null; string runningSpecName = null; foreach (var nodeTest in test.Value) { //Loop through each test, work out number of nodes to run on and kick off process var sbArguments = new StringBuilder() //.Append($@"-Dmultinode.test-assembly=""{assemblyPath}"" ") .Append($@"-Dmultinode.test-class=""{nodeTest.TypeName}"" ") .Append($@"-Dmultinode.test-method=""{nodeTest.MethodName}"" ") .Append($@"-Dmultinode.max-nodes={test.Value.Count} ") .Append($@"-Dmultinode.server-host=""{"localhost"}"" ") .Append($@"-Dmultinode.host=""{"localhost"}"" ") .Append($@"-Dmultinode.index={nodeTest.Node - 1} ") .Append($@"-Dmultinode.role=""{nodeTest.Role}"" ") .Append($@"-Dmultinode.listen-address={listenAddress} ") .Append($@"-Dmultinode.listen-port={listenPort} "); #if CORECLR string fileName = null; switch (platform) { case "net": fileName = ntrNetPath; sbArguments.Insert(0, $@" -Dmultinode.test-assembly=""{assemblyPath}"" "); break; case "netcore": case "net5": fileName = "dotnet"; sbArguments.Insert(0, $@" -Dmultinode.test-assembly=""{assemblyPath}"" "); sbArguments.Insert(0, ntrNetCorePath); break; } var process = new Process { StartInfo = new ProcessStartInfo { FileName = fileName, UseShellExecute = false, RedirectStandardOutput = true, Arguments = sbArguments.ToString(), WorkingDirectory = Path.GetDirectoryName(assemblyPath) } }; #else sbArguments.Insert(0, $@"-Dmultinode.test-assembly=""{assemblyPath}"" "); var process = new Process { StartInfo = new ProcessStartInfo { FileName = "Akka.NodeTestRunner.exe", UseShellExecute = false, RedirectStandardOutput = true, Arguments = sbArguments.ToString() } }; #endif processes.Add(process); var nodeIndex = nodeTest.Node; var nodeRole = nodeTest.Role; #if CORECLR if (platform == "netcore" || platform == "net5") { process.StartInfo.FileName = "dotnet"; process.StartInfo.Arguments = ntrNetCorePath + " " + process.StartInfo.Arguments; process.StartInfo.WorkingDirectory = Path.GetDirectoryName(assemblyPath); } #endif //TODO: might need to do some validation here to avoid the 260 character max path error on Windows var folder = Directory.CreateDirectory(Path.Combine(OutputDirectory, nodeTest.TestName)); testOutputDir = testOutputDir ?? folder.FullName; var logFilePath = Path.Combine(folder.FullName, $"node{nodeIndex}__{nodeRole}__{platform}.txt"); runningSpecName = nodeTest.TestName; var nodeInfo = new TimelineLogCollectorActor.NodeInfo(nodeIndex, nodeRole, platform, nodeTest.TestName); var fileActor = TestRunSystem.ActorOf(Props.Create(() => new FileSystemAppenderActor(logFilePath))); process.OutputDataReceived += (sender, eventArgs) => { if (eventArgs?.Data != null) { fileActor.Tell(eventArgs.Data); timelineCollector.Tell(new TimelineLogCollectorActor.LogMessage(nodeInfo, eventArgs.Data)); if (TeamCityFormattingOn) { // teamCityTest.WriteStdOutput(eventArgs.Data); TODO: open flood gates } } }; var closureTest = nodeTest; process.Exited += (sender, eventArgs) => { if (process.ExitCode == 0) { ReportSpecPassFromExitCode(nodeIndex, nodeRole, closureTest.TestName); } }; process.Start(); process.BeginOutputReadLine(); PublishRunnerMessage($"Started node {nodeIndex} : {nodeRole} on pid {process.Id}"); } var specFailed = false; foreach (var process in processes) { process.WaitForExit(); specFailed = specFailed || process.ExitCode > 0; process.Dispose(); } PublishRunnerMessage("Waiting 3 seconds for all messages from all processes to be collected."); Thread.Sleep(TimeSpan.FromSeconds(3)); if (testOutputDir != null) { var dumpTasks = new List <Task>() { // Dump aggregated timeline to file for this test timelineCollector.Ask <Done>(new TimelineLogCollectorActor.DumpToFile(Path.Combine(testOutputDir, "aggregated.txt"))), // Print aggregated timeline into the console timelineCollector.Ask <Done>(new TimelineLogCollectorActor.PrintToConsole(logLevel)) }; if (specFailed) { var dumpFailureArtifactTask = timelineCollector.Ask <Done>( new TimelineLogCollectorActor.DumpToFile(Path.Combine(Path.GetFullPath(OutputDirectory), FailedSpecsDirectory, $"{runningSpecName}.txt"))); dumpTasks.Add(dumpFailureArtifactTask); } Task.WaitAll(dumpTasks.ToArray()); } FinishSpec(test.Value, timelineCollector); } Console.WriteLine("Complete"); PublishRunnerMessage("Waiting 5 seconds for all messages from all processes to be collected."); Thread.Sleep(TimeSpan.FromSeconds(5)); } else { var sb = new StringBuilder(); sb.AppendLine("One or more exception was thrown while discovering test cases. Test Aborted."); foreach (var err in discovery.Errors) { for (int i = 0; i < err.ExceptionTypes.Length; ++i) { sb.AppendLine(); sb.Append($"{err.ExceptionTypes[i]}: {err.Messages[i]}"); sb.Append(err.StackTraces[i]); } } PublishRunnerMessage(sb.ToString()); Console.Out.WriteLine(sb.ToString()); } } } AbortTcpLoggingServer(tcpLogger); CloseAllSinks(); //Block until all Sinks have been terminated. TestRunSystem.WhenTerminated.Wait(TimeSpan.FromMinutes(1)); if (Debugger.IsAttached) { Console.ReadLine(); //block when debugging } //Return the proper exit code Environment.Exit(ExitCodeContainer.ExitCode); }
/* Function: ParseCommandLine * * Parses the command line and applies the relevant settings in in <NaturalDocs.Engine's> modules. If there were * errors they will be placed on errorList and it will return <ParseCommandLineResult.Error>. * * Supported: * * - -i, --input, --source * - -o, --output * - -p, --project, --project-config --project-configuration * - -w, --data, --working-data * - -xi, --exclude-input, --exclude-source * - -xip, --exclude-input-pattern, --exclude-source-pattern * - -img, --images * - -t, --tab, --tab-width, --tab-length * - -do, --documented-only * - -nag, --no-auto-group * - -s, --style * - -r, --rebuild * - -ro, --rebuild-output * - -q, --quiet * - -v, --version * - --benchmark * - --worker-threads, --threads * - --pause-before-exit, --pause * - --pause-on-error * - --dont-shrink-files * - -h, --help * - -? * * No Longer Supported: * * - -cs, --char-set, --charset, --character-set, --characterset * - -ho, --headers-only, --headersonly * - -ag, --auto-group, --autogroup */ private static ParseCommandLineResult ParseCommandLine(string[] commandLineSegments, out ProjectConfig commandLineConfig, ErrorList errorList) { int originalErrorCount = errorList.Count; Engine.CommandLine commandLine = new CommandLine(commandLineSegments); commandLine.AddAliases("--input", "-i", "--source"); commandLine.AddAliases("--output", "-o"); commandLine.AddAliases("--project", "-p", "--project-config", "--projectconfig", "--project-configuration", "--projectconfiguration"); commandLine.AddAliases("--working-data", "-w", "--data", "--workingdata"); commandLine.AddAliases("--exclude-input", "-xi", "--excludeinput", "--exclude-source", "--excludesource"); commandLine.AddAliases("--exclude-input-pattern", "-xip", "--excludeinputpattern", "--exclude-source-pattern", "--excludesourcepattern"); commandLine.AddAliases("--images", "-img"); commandLine.AddAliases("--tab-width", "-t", "--tab", "--tabwidth", "--tab-length", "--tablength"); commandLine.AddAliases("--documented-only", "-do", "--documentedonly"); commandLine.AddAliases("--no-auto-group", "-nag", "--noautogroup"); commandLine.AddAliases("--style", "-s"); commandLine.AddAliases("--rebuild", "-r"); commandLine.AddAliases("--rebuild-output", "-ro", "--rebuildoutput"); commandLine.AddAliases("--quiet", "-q"); commandLine.AddAliases("--version", "-v"); commandLine.AddAliases("--pause-before-exit", "--pausebeforexit", "--pause"); commandLine.AddAliases("--pause-on-error", "--pauseonerror"); commandLine.AddAliases("--dont-shrink-files", "--dontshrinkfiles", "--dont-shrink-output", "--dontshrinkoutput", "--dont-shrink", "--dontshrink"); commandLine.AddAliases("--worker-threads", "--threads"); // no aliases for --benchmark commandLine.AddAliases("--help", "-h", "-?"); // No longer supported commandLine.AddAliases("--charset", "-cs", "--char-set", "--character-set", "--characterset"); commandLine.AddAliases("--headers-only", "-ho", "--headersonly"); commandLine.AddAliases("--auto-group", "-ag", "--autogroup"); commandLineConfig = new ProjectConfig(Source.CommandLine); string parameter, parameterAsEntered; bool isFirst = true; while (commandLine.IsInBounds) { // If the first segment isn't a parameter, assume it's the project folder specified without -p. if (isFirst && !commandLine.IsOnParameter) { parameter = "--project"; parameterAsEntered = parameter; } else { if (!commandLine.GetParameter(out parameter, out parameterAsEntered)) { string bareWord; commandLine.GetBareWord(out bareWord); errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.UnrecognizedParameter(param)", bareWord) ); commandLine.SkipToNextParameter(); } } isFirst = false; // Input folders if (parameter == "--input") { Path folder; if (!commandLine.GetPathValue(out folder)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { if (folder.IsRelative) { folder = System.Environment.CurrentDirectory + "/" + folder; } var target = new Engine.Config.Targets.SourceFolder(Source.CommandLine, Engine.Files.InputType.Source); target.Folder = folder; target.FolderPropertyLocation = Source.CommandLine; commandLineConfig.InputTargets.Add(target); } } // Output folders else if (parameter == "--output") { string format; Path folder; if (!commandLine.GetBareWordAndPathValue(out format, out folder)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFormatAndFolder(param)", parameter) ); commandLine.SkipToNextParameter(); } else { if (folder.IsRelative) { folder = System.Environment.CurrentDirectory + "/" + folder; } format = format.ToLower(); if (format == "html" || format == "framedhtml") { var target = new Engine.Config.Targets.HTMLOutputFolder(Source.CommandLine); target.Folder = folder; target.FolderPropertyLocation = Source.CommandLine; commandLineConfig.OutputTargets.Add(target); } else { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.UnrecognizedOutputFormat(format)", format) ); commandLine.SkipToNextParameter(); } } } // Project configuration folder else if (parameter == "--project") { Path folder; if (!commandLine.GetPathValue(out folder)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { if (folder.IsRelative) { folder = System.Environment.CurrentDirectory + "/" + folder; } // Accept the parameter being set to Project.txt instead of the folder. if (folder.NameWithoutPath.ToLower() == "project.txt") { folder = folder.ParentFolder; } if (commandLineConfig.ProjectConfigFolderPropertyLocation.IsDefined) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.OnlyOneProjectConfigFolder") ); } else { commandLineConfig.ProjectConfigFolder = folder; commandLineConfig.ProjectConfigFolderPropertyLocation = Source.CommandLine; } } } // Working data folder else if (parameter == "--working-data") { Path folder; if (!commandLine.GetPathValue(out folder)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { if (folder.IsRelative) { folder = System.Environment.CurrentDirectory + "/" + folder; } if (commandLineConfig.WorkingDataFolderPropertyLocation.IsDefined) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.OnlyOneWorkingDataFolder") ); } else { commandLineConfig.WorkingDataFolder = folder; commandLineConfig.WorkingDataFolderPropertyLocation = Source.CommandLine; } } } // Ignored input folders else if (parameter == "--exclude-input") { Path folder; if (!commandLine.GetPathValue(out folder)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { if (folder.IsRelative) { folder = System.Environment.CurrentDirectory + "/" + folder; } var target = new Engine.Config.Targets.IgnoredSourceFolder(Source.CommandLine); target.Folder = folder; target.FolderPropertyLocation = Source.CommandLine; commandLineConfig.FilterTargets.Add(target); } } // Ignored input folder patterns else if (parameter == "--exclude-input-pattern") { string pattern; if (!commandLine.GetBareOrQuotedWordsValue(out pattern)) { errorList.Add( Engine.Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedPattern(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { var target = new Engine.Config.Targets.IgnoredSourceFolderPattern(Source.CommandLine); target.Pattern = pattern; target.PatternPropertyLocation = Source.CommandLine; commandLineConfig.FilterTargets.Add(target); } } // Image folders else if (parameter == "--images") { Path folder; if (!commandLine.GetPathValue(out folder)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedFolder(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { if (folder.IsRelative) { folder = System.Environment.CurrentDirectory + "/" + folder; } var target = new Engine.Config.Targets.SourceFolder(Source.CommandLine, Engine.Files.InputType.Image); target.Folder = folder; target.FolderPropertyLocation = Source.CommandLine; commandLineConfig.InputTargets.Add(target); } } // Tab Width else if (parameter == "--tab-width") { int tabWidth; if (!commandLine.GetIntegerValue(out tabWidth)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNumber(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else if (tabWidth < 1) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.InvalidTabWidth") ); commandLine.SkipToNextParameter(); } else { commandLineConfig.TabWidth = tabWidth; commandLineConfig.TabWidthPropertyLocation = Source.CommandLine; } } // Support the -t4 form ini addition to -t 4. Doesn't support --tablength4. else if (parameter.StartsWith("-t") && parameter.Length > 2 && parameter[2] >= '0' && parameter[2] <= '9') { string tabWidthString = parameter.Substring(2); int tabWidth; if (!Int32.TryParse(tabWidthString, out tabWidth)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNumber(param)", "-t") ); commandLine.SkipToNextParameter(); } else if (tabWidth < 1) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.InvalidTabWidth") ); commandLine.SkipToNextParameter(); } else if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { commandLineConfig.TabWidth = tabWidth; commandLineConfig.TabWidthPropertyLocation = Source.CommandLine; } } // Documented Only else if (parameter == "--documented-only") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { commandLineConfig.DocumentedOnly = true; commandLineConfig.DocumentedOnlyPropertyLocation = Source.CommandLine; } } // No Auto-Group else if (parameter == "--no-auto-group") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { commandLineConfig.AutoGroup = false; commandLineConfig.AutoGroupPropertyLocation = Source.CommandLine; } } // Don't Shrink Files else if (parameter == "--dont-shrink-files") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { commandLineConfig.ShrinkFiles = false; commandLineConfig.ShrinkFilesPropertyLocation = Source.CommandLine; } } // Style else if (parameter == "--style") { string styleName; if (!commandLine.GetBareOrQuotedWordsValue(out styleName)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedStyleName(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { commandLineConfig.ProjectInfo.StyleName = styleName; commandLineConfig.ProjectInfo.StyleNamePropertyLocation = Source.CommandLine; } } // Rebuild else if (parameter == "--rebuild") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { EngineInstance.Config.ReparseEverything = true; EngineInstance.Config.RebuildAllOutput = true; } } else if (parameter == "--rebuild-output") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { EngineInstance.Config.RebuildAllOutput = true; } } // Quiet else if (parameter == "--quiet") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { quiet = true; } } // Worker Threads else if (parameter == "--worker-threads") { int value; if (!commandLine.GetIntegerValue(out value)) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNumber(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else if (value < 1) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.InvalidWorkerThreadCount") ); commandLine.SkipToNextParameter(); } else { workerThreadCount = value; } } // Benchmark else if (parameter == "--benchmark") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { benchmark = true; } } // Pause Before Exit else if (parameter == "--pause-before-exit") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { pauseBeforeExit = true; } } // Pause on Error else if (parameter == "--pause-on-error") { if (!commandLine.NoValue()) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.ExpectedNoValue(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } else { pauseOnError = true; } } // Help else if (parameter == "--help") { return(ParseCommandLineResult.ShowCommandLineReference); } // Version else if (parameter == "--version") { return(ParseCommandLineResult.ShowVersion); } // No longer supported parameters else if (parameter == "--charset" || parameter == "--headers-only" || parameter == "--auto-group") { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.NoLongerSupported(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } // Everything else else { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.UnrecognizedParameter(param)", parameterAsEntered) ); commandLine.SkipToNextParameter(); } } // Validation if (!commandLineConfig.ProjectConfigFolderPropertyLocation.IsDefined) { errorList.Add( Locale.Get("NaturalDocs.CLI", "CommandLine.NoProjectConfigFolder") ); } // Done. if (errorList.Count == originalErrorCount) { return(ParseCommandLineResult.Run); } else { return(ParseCommandLineResult.Error); } }
/// <summary> /// Parse the commandline arguments. /// </summary> /// <param name="args">Commandline arguments.</param> private void ParseCommandLine(string[] args) { for (int i = 0; i < args.Length; ++i) { string arg = args[i]; if (null == arg || 0 == arg.Length) { // skip blank arguments continue; } if (1 == arg.Length) { // treat '-' and '@' as filenames when by themselves. this.inputFiles.AddRange(CommandLine.GetFiles(arg, "Source")); continue; } if ('-' == arg[0] || '/' == arg[0]) { string parameter = arg.Substring(1); if ("ext" == parameter) { if (!CommandLine.IsValidArg(args, ++i)) { Messaging.Instance.OnMessage(WixErrors.TypeSpecificationForExtensionRequired("-ext")); return; } this.extensionList.Add(args[i]); } else if ("nologo" == parameter) { this.showLogo = false; } else if ("o" == parameter || "out" == parameter) { string path = CommandLine.GetFileOrDirectory(parameter, args, ++i); if (String.IsNullOrEmpty(path)) { return; } else { this.outputFile = path; } } else if ("v" == parameter) { Messaging.Instance.ShowVerboseMessages = true; } else if ("?" == parameter || "help" == parameter) { this.showHelp = true; return; } else { this.invalidArgs.Add(parameter); } } else if ('@' == arg[0]) { this.ParseCommandLine(CommandLineResponseFile.Parse(arg.Substring(1))); } else { this.inputFiles.AddRange(CommandLine.GetFiles(arg, "Source")); } } return; }
/// <exception cref="Org.Apache.Commons.Cli.ParseException"/> private void ProcessOptions(CommandLine line, Options opts) { if (line.HasOption("help") || line.HasOption('?')) { HelpFormatter formatter = new HelpFormatter(); System.Console.Out.WriteLine("Protobuf IPC benchmark."); System.Console.Out.WriteLine(); formatter.PrintHelp(100, "java ... PBRPCBenchmark [options]", "\nSupported options:" , opts, string.Empty); return; } if (line.HasOption('s')) { serverThreads = System.Convert.ToInt32(line.GetOptionValue('s')); } if (line.HasOption('r')) { serverReaderThreads = System.Convert.ToInt32(line.GetOptionValue('r')); } if (line.HasOption('c')) { clientThreads = System.Convert.ToInt32(line.GetOptionValue('c')); } if (line.HasOption('t')) { secondsToRun = System.Convert.ToInt32(line.GetOptionValue('t')); } if (line.HasOption('m')) { msgSize = System.Convert.ToInt32(line.GetOptionValue('m')); } if (line.HasOption('p')) { port = System.Convert.ToInt32(line.GetOptionValue('p')); } if (line.HasOption('h')) { host = line.GetOptionValue('h'); } if (line.HasOption('e')) { string eng = line.GetOptionValue('e'); if ("protobuf".Equals(eng)) { rpcEngine = typeof(ProtobufRpcEngine); } else { if ("writable".Equals(eng)) { rpcEngine = typeof(WritableRpcEngine); } else { throw new ParseException("invalid engine: " + eng); } } } string[] remainingArgs = line.GetArgs(); if (remainingArgs.Length != 0) { throw new ParseException("Extra arguments: " + Joiner.On(" ").Join(remainingArgs) ); } }
static void Main(string[] args) { Console.ForegroundColor = ConsoleColor.DarkYellow; Console.WriteLine("spkl Task Runner v" + Assembly.GetEntryAssembly().GetName().Version + "\tTasks v" + Assembly.GetAssembly(typeof(SparkleXrm.Tasks.BaseTask)).GetName().Version); Console.ForegroundColor = ConsoleColor.Gray; bool error = false; CommandLineArgs arguments = null; try { arguments = CommandLine.Parse <CommandLineArgs>(); Run(arguments); } catch (CommandLineException exception) { Console.WriteLine(exception.ArgumentHelp.Message); Console.WriteLine(exception.ArgumentHelp.GetHelpText(Console.BufferWidth)); } catch (SparkleTaskException ex) { Console.WriteLine(ex.Message); error = true; } catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> ex) { Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("The application terminated with an error."); Console.WriteLine("Timestamp: {0}", ex.Detail.Timestamp); Console.WriteLine("Code: {0}", ex.Detail.ErrorCode); Console.WriteLine("Message: {0}", ex.Detail.Message); Console.ForegroundColor = ConsoleColor.DarkGray; Console.WriteLine(ex.StackTrace); if (!string.IsNullOrEmpty(ex.Detail.TraceText)) { Console.WriteLine("Plugin Trace: {0}", ex.Detail.TraceText); } if (ex.Detail.InnerFault != null) { Console.WriteLine("Inner Fault: {0}", null == ex.Detail.InnerFault ? "No Inner Fault" : "Has Inner Fault"); } error = true; Console.ForegroundColor = ConsoleColor.White; } catch (System.TimeoutException ex) { Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("The application terminated with an error."); Console.WriteLine("Message: {0}", ex.Message); Console.WriteLine("Stack Trace: {0}", ex.StackTrace); if (ex.InnerException != null) { Console.WriteLine("Inner Fault: {0}", null == ex.InnerException.Message ? "No Inner Fault" : ex.InnerException.Message); } error = true; Console.ForegroundColor = ConsoleColor.White; } catch (System.Exception ex) { Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("The application terminated with an error."); Console.WriteLine(ex.Message); Console.ForegroundColor = ConsoleColor.DarkGray; Console.WriteLine(ex.StackTrace); // Display the details of the inner exception. if (ex.InnerException != null) { Console.WriteLine(ex.InnerException.Message); FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> fe = ex.InnerException as FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault>; if (fe != null) { Console.WriteLine("Timestamp: {0}", fe.Detail.Timestamp); Console.WriteLine("Code: {0}", fe.Detail.ErrorCode); Console.WriteLine("Message: {0}", fe.Detail.Message); if (!string.IsNullOrEmpty(fe.Detail.TraceText)) { Console.WriteLine("Plugin Trace: {0}", fe.Detail.TraceText); } if (fe.Detail.InnerFault != null) { Console.WriteLine("Inner Fault: {0}", null == fe.Detail.InnerFault ? "No Inner Fault" : "Has Inner Fault"); } } } error = true; Console.ForegroundColor = ConsoleColor.White; } finally { if (error) { Environment.ExitCode = 1; } } if (arguments != null && arguments.WaitForKey == true) { Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("Press any key..."); Console.ReadKey(); } Console.ForegroundColor = ConsoleColor.Gray; }
/// <inheritdoc/> public override async Task RunAsync(CommandLine commandLine) { Help(); await Task.CompletedTask; }
private static int Help(string action = null) { return(CommandLine.Describe <Program>(action)); }