public static void ProcessCommandLineArguments(string[] args, out string argument, out string value, out string helpText)
{
argument = string.Empty;
value = string.Empty;
//CommandLineParser does not support slashes, to support legacy apps,
//convert / to -. Can be removed if legacy apps are not a concern.
for (var index = 0; index < args.Length; index++)
{
if (args[index].Length == 2 && args[index].StartsWith("/"))
{
args[index] = args[index].Replace("/", "-");
}
}
var localArgument = string.Empty;
var localValue = string.Empty;
var localHelpText = string.Empty;
using (var parser = new Parser(config =>
{
config.HelpWriter = null;
config.AutoVersion = false;
}))
{
var parseResult = parser.ParseArguments <CommandLineOptions>(args);
parseResult.WithParsed(o =>
{
if (!string.IsNullOrWhiteSpace(o.Namespace))
{
localArgument = "/n";
localValue = o.Namespace.Trim();
}
else if (!string.IsNullOrWhiteSpace(o.ConnectionString))
{
localArgument = "/c";
localValue = o.ConnectionString.Trim();
}
if (!string.IsNullOrWhiteSpace(o.QueueFilter))
{
FilterExpressionHelper.QueueFilterExpression = o.QueueFilter;
}
if (!string.IsNullOrWhiteSpace(o.TopicFilter))
{
FilterExpressionHelper.TopicFilterExpression = o.TopicFilter;
}
if (!string.IsNullOrWhiteSpace(o.SubscriptionFilter))
{
FilterExpressionHelper.SubscriptionFilterExpression = o.SubscriptionFilter;
}
})
.WithNotParsed(errors =>
{
localHelpText = HelpText.AutoBuild(parseResult, helpTextOptions =>
{
helpTextOptions.AddNewLineBetweenHelpSections = true;
helpTextOptions.AdditionalNewLineAfterOption = false;
helpTextOptions.Copyright = "";
helpTextOptions.Heading = "Command Line Options";
return(HelpText.DefaultParsingErrorsHandler(parseResult, helpTextOptions));
});
});
argument = localArgument;
value = localValue;
helpText = localHelpText;
}
}
public static string GetUsage(CommandLineOptions options)
{
return(HelpText.AutoBuild(options,
(HelpText current) => HelpText.DefaultParsingErrorsHandler(options, current)));
}
private void OnError(HelpText current)
{
HelpText.DefaultParsingErrorsHandler(this, current);
}
public string GetHelp()
{
return(HelpText.AutoBuild(this, c => HelpText.DefaultParsingErrorsHandler(this, c)));
}
public override string GetUsage()
{
return(HelpText.AutoBuild(this, delegate(HelpText current) {
HelpText.DefaultParsingErrorsHandler(this, current);
}));
}
public string GetUsage()
{
return("Adds additional copies of cards into a hearthstonejson file and randomizes the order. \n\n" +
HelpText.AutoBuild(this,
(current) => HelpText.DefaultParsingErrorsHandler(this, current)));
}
/// <summary>
/// Displays the help usage, possibly with some error messages, and then exits (non-zero).
/// </summary>
/// <param name="parserResult">The results from a CommandLine.Parser.ParseArguments() operation.</param>
/// <param name="errors">An errors reported by the parserResult.</param>
/// <param name="msg">An optional error message to accompany the output.</param>
private static void ShowUsageHelp <T>(ParserResult <T> parserResult, IEnumerable <Error> errors = null, string msg = null)
{
if (msg != null)
{
Console.Error.WriteLine(msg);
Console.Error.WriteLine();
}
if (errors == null)
{
errors = new List <Error>();
}
HelpText helpText = null;
if (errors.IsVersion())
{
helpText = HelpText.AutoBuild(parserResult);
}
else
{
helpText = HelpText.AutoBuild(
parserResult,
onError: ht =>
{
return(HelpText.DefaultParsingErrorsHandler(parserResult, ht));
},
e => e);
helpText.AddNewLineBetweenHelpSections = true;
helpText.AddPreOptionsLines(new[]
{
string.Empty,
// Use a single long line of text to let the help output get wrapped automatically for us.
"The Mlos.Agent.Server acts as an external agent for MLOS integrated components, allowing them to "
+ "send it messages over shared memory, which it can process and use to interface with an optimizer "
+ "service to tune the components over their shared memory communication channels.",
string.Empty,
// Indent the actual commands to make them stand out a bit more.
// Note: The help out preserves the indent across wrapping.
"usage mode 1: Wait for an application to register over global shared memory, without an optimizer.",
" dotnet Mlos.Agent.Server.dll",
string.Empty,
"usage mode 2: Wait for an application to register over global shared memory, and prepare to "
+ "communicate with an MLOS optimizer listening at the given Grpc URI.",
" dotnet Mlos.Agent.Server.dll --optimizer-uri http://localhost:50051",
string.Empty,
"usage mode 3: Start an executable to communicate over freshly prepared global shared memory.",
" dotnet Mlos.Agent.Server.dll --executable path/to/executable --settings-registry-path path/to/settings_assemblies",
string.Empty,
"usage mode 4: Start an executable to communicate over freshly prepared global shared memory and "
+ "prepare to communicate with an MLOS optimizer listening at the given Grpc URI.",
" dotnet Mlos.Agent.Server.dll --executable path/to/executable --settings-registry-path path/to/settings_assemblies --experiment path/to/Experiment.dll --optimizer-uri http://localhost:50051",
string.Empty,
"Note: the optimizer service used in these examples can be started using the 'start_optimizer_microservice "
+ "launch --port 50051' command from the mlos Python module.",
});
}
Console.WriteLine(helpText);
Environment.Exit(1);
}
private static int Main(string[] args)
{
#if DEBUG // short command syntax
if (args?.Length > 0)
{
switch (args[0])
{
case "f":
{
ReplaceArgs("find");
break;
}
case "r":
{
ReplaceArgs("replace");
break;
}
}
void ReplaceArgs(string commandName)
{
Array.Resize(ref args, args.Length + 1);
for (int i = args.Length - 1; i >= 2; i--)
{
args[i] = args[i - 1];
}
args[0] = commandName;
args[1] = "-c";
}
}
#endif
try
{
Parser parser = CreateParser(ignoreUnknownArguments: true);
if (args == null ||
args.Length == 0)
{
HelpCommand.WriteCommandsHelp();
return(ExitCodes.Match);
}
var help = false;
ParserResult <BaseCommandLineOptions> defaultResult = parser
.ParseArguments <BaseCommandLineOptions>(args)
.WithParsed(options =>
{
if (!options.Help)
{
return;
}
string?commandName = args?.FirstOrDefault();
Command?command = (commandName != null)
? CommandLoader.LoadCommand(typeof(Program).Assembly, commandName)
: null;
ParseVerbosityAndOutput(options);
WriteArgs(args);
if (command != null)
{
HelpCommand.WriteCommandHelp(command);
}
else
{
HelpCommand.WriteCommandsHelp();
}
help = true;
})
#if DEBUG
.WithNotParsed(_ =>
{
});
#else
;
#endif
if (help)
{
return(ExitCodes.Match);
}
var success = true;
parser = CreateParser();
ParserResult <object> parserResult = parser.ParseArguments <
CopyCommandLineOptions,
DeleteCommandLineOptions,
EscapeCommandLineOptions,
FindCommandLineOptions,
HelpCommandLineOptions,
ListPatternsCommandLineOptions,
MatchCommandLineOptions,
MoveCommandLineOptions,
RenameCommandLineOptions,
ReplaceCommandLineOptions,
SplitCommandLineOptions
>(args);
parserResult.WithNotParsed(_ =>
{
var helpText = new HelpText(SentenceBuilder.Create(), HelpCommand.GetHeadingText());
helpText = HelpText.DefaultParsingErrorsHandler(parserResult, helpText);
VerbAttribute?verbAttribute = parserResult.TypeInfo.Current.GetCustomAttribute <VerbAttribute>();
if (verbAttribute != null)
{
helpText.AddPreOptionsText(Environment.NewLine + HelpCommand.GetFooterText(verbAttribute.Name));
}
Console.Error.WriteLine(helpText);
success = false;
});
if (!success)
{
return(ExitCodes.Error);
}
parserResult.WithParsed <AbstractCommandLineOptions>(options =>
{
success = ParseVerbosityAndOutput(options);
WriteArgs(args);
});
if (!success)
{
return(ExitCodes.Error);
}
return(parserResult.MapResult(
(CopyCommandLineOptions options) => Copy(options),
(MoveCommandLineOptions options) => Move(options),
(DeleteCommandLineOptions options) => Delete(options),
(EscapeCommandLineOptions options) => Escape(options),
(FindCommandLineOptions options) => Find(options),
(HelpCommandLineOptions options) => Help(options),
(ListPatternsCommandLineOptions options) => ListPatterns(options),
(MatchCommandLineOptions options) => Match(options),
(RenameCommandLineOptions options) => Rename(options),
(ReplaceCommandLineOptions options) => Replace(options),
(SplitCommandLineOptions options) => Split(options),
_ => ExitCodes.Error));
}
catch (Exception ex)
{
WriteError(ex);
}
finally
{
Out?.Dispose();
Out = null;
}
return(ExitCodes.Error);
}
public string GetUsage(string verb, bool isAdditionalHelp = false)
{
StringBuilder helpStringBuilder;
switch (verb)
{
case "subs":
helpStringBuilder = new StringBuilder(HelpText.AutoBuild(SubstituteVerb, current => HelpText.DefaultParsingErrorsHandler(SubstituteVerb, current)));
if (isAdditionalHelp)
{
helpStringBuilder.AppendLine();
helpStringBuilder.AppendLine(Resources.additionalUsage);
helpStringBuilder.Append(Resources.AdditionalSubsDictUsage);
helpStringBuilder.Append(Resources.AdditionalSubsMethodUsage);
helpStringBuilder.Append(Resources.AdditionalSubs_i_Usages);
}
return(helpStringBuilder.ToString());
case "comb":
helpStringBuilder = new StringBuilder(HelpText.AutoBuild(CombineVerb, current => HelpText.DefaultParsingErrorsHandler(CombineVerb, current)));
if (isAdditionalHelp)
{
helpStringBuilder.AppendLine();
helpStringBuilder.AppendLine(Resources.additionalUsage);
helpStringBuilder.Append(Resources.AdditionalComb_m_Usage);
helpStringBuilder.Append(Resources.AdditionalComb_delimiter_Usage);
helpStringBuilder.Append(Resources.AdditionalComb_prefix_Usage);
helpStringBuilder.Append(Resources.AdditionalComb_suffix_Usage);
helpStringBuilder.Append(Resources.AdditionalComb_r_Usage);
}
return(helpStringBuilder.ToString());
default:
return(HelpText.AutoBuild(this, verb));
}
}
public string GetUsage()
{
StringBuilder builder = new StringBuilder(HelpText.AutoBuild(this, current => HelpText.DefaultParsingErrorsHandler(this, current)));
builder.AppendLine("Providers: " + string.Join(",", GetProviders().Select(prov => prov.GetName())));
return(builder.ToString());
}
static void DisplayHelp <T>(ParserResult <T> result, IEnumerable <Error> errs)
{
var helpText = HelpText.AutoBuild(result, (current) => HelpText.DefaultParsingErrorsHandler(result, current));
Console.WriteLine(helpText);
}
public string GetUsage()
{
return
("Extracts the Winium.Cruciatus xml from an application.\r\n\r\n"
+ HelpText.AutoBuild(this, current => HelpText.DefaultParsingErrorsHandler(this, current)));
}
private static int Main(string[] args)
{
//WriteLine($"Orang Command Line Tool version {typeof(Program).GetTypeInfo().Assembly.GetName().Version}");
//WriteLine("Copyright (c) Josef Pihrt. All rights reserved.");
//WriteLine();
if (args != null)
{
if (args.Length == 1)
{
if (IsHelpOption(args[0]))
{
Console.Write(HelpProvider.GetHelpText());
return(0);
}
}
else if (args.Length == 2)
{
if (args?.Length == 2 &&
IsHelpOption(args[1]))
{
Command command = CommandLoader.LoadCommand(typeof(HelpCommand).Assembly, args[0]);
if (command != null)
{
Console.Write(HelpProvider.GetHelpText(command));
return(0);
}
}
}
}
try
{
ParserSettings defaultSettings = Parser.Default.Settings;
var parser = new Parser(settings =>
{
settings.AutoHelp = false;
settings.AutoVersion = defaultSettings.AutoVersion;
settings.CaseInsensitiveEnumValues = defaultSettings.CaseInsensitiveEnumValues;
settings.CaseSensitive = defaultSettings.CaseSensitive;
settings.EnableDashDash = true;
settings.HelpWriter = null;
settings.IgnoreUnknownArguments = defaultSettings.IgnoreUnknownArguments;
settings.MaximumDisplayWidth = defaultSettings.MaximumDisplayWidth;
settings.ParsingCulture = defaultSettings.ParsingCulture;
});
ParserResult <object> parserResult = parser.ParseArguments <
CopyCommandLineOptions,
DeleteCommandLineOptions,
EscapeCommandLineOptions,
FindCommandLineOptions,
HelpCommandLineOptions,
ListSyntaxCommandLineOptions,
MatchCommandLineOptions,
MoveCommandLineOptions,
RenameCommandLineOptions,
ReplaceCommandLineOptions,
SplitCommandLineOptions
>(args);
bool help = false;
bool success = true;
parserResult.WithNotParsed(_ =>
{
var helpText = new HelpText(SentenceBuilder.Create(), HelpProvider.GetHeadingText());
helpText = HelpText.DefaultParsingErrorsHandler(parserResult, helpText);
VerbAttribute verbAttribute = parserResult.TypeInfo.Current.GetCustomAttribute <VerbAttribute>();
if (verbAttribute != null)
{
helpText.AddPreOptionsText(Environment.NewLine + HelpProvider.GetFooterText(verbAttribute.Name));
}
Console.Error.WriteLine(helpText);
success = false;
});
parserResult.WithParsed <AbstractCommandLineOptions>(options =>
{
if (options.Help)
{
string commandName = options.GetType().GetCustomAttribute <VerbAttribute>().Name;
Console.WriteLine(HelpProvider.GetHelpText(commandName));
help = true;
return;
}
success = false;
var defaultVerbosity = Verbosity.Normal;
if (options.Verbosity == null ||
TryParseVerbosity(options.Verbosity, out defaultVerbosity))
{
ConsoleOut.Verbosity = defaultVerbosity;
if (TryParseOutputOptions(options.Output, OptionNames.Output, out string filePath, out Verbosity fileVerbosity, out Encoding encoding, out bool append))
{
if (filePath != null)
{
FileMode fileMode = (append)
? FileMode.Append
: FileMode.Create;
var stream = new FileStream(filePath, fileMode, FileAccess.Write, FileShare.Read);
var writer = new StreamWriter(stream, encoding, bufferSize: 4096, leaveOpen: false);
Out = new TextWriterWithVerbosity(writer)
{
Verbosity = fileVerbosity
};
}
success = true;
}
else
{
success = false;
}
}
});
if (help)
{
return(0);
}
if (!success)
{
return(2);
}
return(parserResult.MapResult(
(CopyCommandLineOptions options) => Copy(options),
(MoveCommandLineOptions options) => Move(options),
(DeleteCommandLineOptions options) => Delete(options),
(EscapeCommandLineOptions options) => Escape(options),
(FindCommandLineOptions options) => Find(options),
(HelpCommandLineOptions options) => Help(options),
(ListSyntaxCommandLineOptions options) => ListSyntax(options),
(MatchCommandLineOptions options) => Match(options),
(RenameCommandLineOptions options) => Rename(options),
(ReplaceCommandLineOptions options) => Replace(options),
(SplitCommandLineOptions options) => Split(options),
_ => 2));
}
public string GetUsage()
{
return("\n\t\tExcel格式转换和C#代码生成工具\n\n" + HelpText.AutoBuild(this, (HelpText current) => HelpText.DefaultParsingErrorsHandler(this, current)));
}
private async static void Go(Options opts)
{
var print = new Print();
// -g
if (opts.Gui)
{
// TODO Spawn WinPrint GUI App with args
Console.WriteLine($"Starting WinPrint GUI App...");
System.Environment.Exit(0);
}
try {
// --s
string sheetID;
Sheet sheet = FindSheet(opts, out sheetID);
// --l and --o
if (opts.Landscape)
{
sheet.Landscape = true;
}
if (opts.Portrait)
{
sheet.Landscape = false;
}
// --p
print.SetPrinter(opts.Printer);
// --z
print.SetPaperSize(opts.PaperSize);
// Must set landsacpe after printer/paper selection
print.PrintDocument.DefaultPageSettings.Landscape = sheet.Landscape;
await print.SheetVM.LoadAsync(opts.Files.ToList().FirstOrDefault()).ConfigureAwait(false);
print.SheetVM.SetSheet(sheet);
// --v
if (opts.Verbose)
{
Console.WriteLine($"Printing {opts.Files.ToList().FirstOrDefault()}");
Console.WriteLine($" Printer: {print.PrintDocument.PrinterSettings.PrinterName}");
Console.WriteLine($" Paper Size: {print.PrintDocument.DefaultPageSettings.PaperSize.PaperName}");
string s = print.PrintDocument.DefaultPageSettings.Landscape ? $"Landscape" : $"Portrait";
Console.WriteLine($" Orientation: {s}");
Console.WriteLine($" Sheet Definition: {sheet.Name} ({sheetID})");
}
// --c
if (opts.CountPages)
{
int n = await print.CountPages(fromSheet : opts.FromPage, toSheet : opts.ToPage);
if (opts.Verbose)
{
Console.WriteLine($"Would print {n} pages.");
}
System.Environment.Exit(n);
}
if (opts.FromPage != 0)
{
print.PrintDocument.PrinterSettings.FromPage = opts.FromPage;
}
if (opts.ToPage != 0)
{
print.PrintDocument.PrinterSettings.ToPage = opts.ToPage;
}
print.DoPrint();
}
catch (System.IO.FileNotFoundException fnfe) {
Console.WriteLine($"{fnfe.Message}");
System.Environment.Exit(-1);
}
catch (Exception e) {
Console.WriteLine($"{e.Message}");
//var result = new ParserResult<Options>();
var helpText = HelpText.AutoBuild(result, h => {
h.AutoHelp = true;
h.AutoVersion = true;
//h.AddPostOptionsLine("Files\tOne or more filenames of files to be printed.");
return(HelpText.DefaultParsingErrorsHandler(result, h));
}, e => e);
Console.WriteLine(helpText);
System.Environment.Exit(-1);
}
}
private static void Main(string[] args)
{
var options = new TailFeatherCommandLineOptions();
if (Parser.Default.ParseArguments(args, options) == false)
{
var autoBuild = HelpText.AutoBuild(options);
HelpText.DefaultParsingErrorsHandler(options, autoBuild);
Console.WriteLine(autoBuild.ToString());
return;
}
var nodeName = options.NodeName ?? (Environment.MachineName + ":" + options.Port);
Console.Title = string.Format("Node name: {0}, port: {1}", nodeName, options.Port);
var kvso = StorageEnvironmentOptions.ForPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, options.DataPath, "KeyValue"));
using (var statemachine = new KeyValueStateMachine(kvso))
{
var storageEnvironmentOptions = StorageEnvironmentOptions.ForPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, options.DataPath, "Raft"));
var httpTransport = new HttpTransport(nodeName);
var raftEngineOptions = new RaftEngineOptions(
new NodeConnectionInfo
{
Name = nodeName,
Uri = new Uri("http://" + Environment.MachineName + ":" + options.Port),
},
storageEnvironmentOptions,
httpTransport,
statemachine
)
{
ElectionTimeout = 5 * 1000,
HeartbeatTimeout = 1000,
MaxLogLengthBeforeCompaction = 25
};
if (options.Boostrap)
{
PersistentState.ClusterBootstrap(raftEngineOptions);
Console.WriteLine("Setup node as the cluster seed, exiting...");
return;
}
using (var raftEngine = new RaftEngine(raftEngineOptions))
{
using (WebApp.Start(new StartOptions
{
Urls = { "http://+:" + options.Port + "/" }
}, builder =>
{
var httpConfiguration = new HttpConfiguration();
httpConfiguration.Formatters.Remove(httpConfiguration.Formatters.XmlFormatter);
httpConfiguration.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
httpConfiguration.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
RaftWebApiConfig.Load();
httpConfiguration.MapHttpAttributeRoutes();
httpConfiguration.Properties[typeof(HttpTransportBus)] = httpTransport.Bus;
httpConfiguration.Properties[typeof(RaftEngine)] = raftEngine;
builder.UseWebApi(httpConfiguration);
}))
{
Console.WriteLine("Ready @ http://" + Environment.MachineName + ":" + options.Port + "/, press ENTER to stop");
Console.ReadLine();
}
}
}
}
public void Invoke_AutoBuild_for_Options_with_Usage_returns_appropriate_formatted_text(bool newlineBetweenSections)
{
// Fixture setup
var fakeResult = new NotParsed <Options_With_Usage_Attribute>(
TypeInfo.Create(typeof(Options_With_Usage_Attribute)),
new Error[]
{
new BadFormatTokenError("badtoken")
});
// Exercize system
var helpText = HelpText.AutoBuild(fakeResult,
h =>
{
h.AddNewLineBetweenHelpSections = newlineBetweenSections;
return(HelpText.DefaultParsingErrorsHandler(fakeResult, h));
},
e => e
);
// Verify outcome
var expected = new List <string>()
{
HeadingInfo.Default.ToString(),
CopyrightInfo.Default.ToString(),
"",
"ERROR(S):",
"Token 'badtoken' is not recognized.",
"USAGE:",
"Normal scenario:",
"mono testapp.exe --input file.bin --output out.bin",
"Logging warnings:",
"mono testapp.exe -w --input file.bin",
"Logging errors:",
"mono testapp.exe -e --input file.bin",
"mono testapp.exe --errs --input=file.bin",
"List:",
"mono testapp.exe -l 1,2",
"Value:",
"mono testapp.exe value",
"",
"-i, --input Set input file.",
"",
"-i, --output Set output file.",
"",
"--verbose Set verbosity level.",
"",
"-w, --warns Log warnings.",
"",
"-e, --errs Log errors.",
"",
"-l List.",
"",
"--help Display this help screen.",
"",
"--version Display version information.",
"",
"value pos. 0 Value."
};
if (newlineBetweenSections)
{
expected.Insert(5, "");
}
var text = helpText.ToString();
var lines = text.ToLines().TrimStringArray();
lines.Should().StartWith(expected);
}
static void Main(string[] args)
{
try
{
var options = new ConsoleOptions();
if (!Parser.Default.ParseArguments(args, options) || options.ShowHelp == true)
{
if (options.LastParserState != null && options.LastParserState.Errors.Count > 0)
{
var help = new HelpText();
var errors = help.RenderParsingErrorsText(options, 2); // indent with two spaces
Console.WriteLine("Jackett v" + Engine.ConfigService.GetVersion());
Console.WriteLine("Switch error: " + errors);
Console.WriteLine("See --help for further details on switches.");
Environment.ExitCode = 1;
return;
}
else
{
var text = HelpText.AutoBuild(options, (HelpText current) => HelpText.DefaultParsingErrorsHandler(options, current));
text.Copyright = " ";
text.Heading = "Jackett v" + Engine.ConfigService.GetVersion() + " options:";
Console.WriteLine(text);
Environment.ExitCode = 1;
return;
}
}
else
{
if (options.ListenPublic && options.ListenPrivate)
{
Console.WriteLine("You can only use listen private OR listen publicly.");
Environment.ExitCode = 1;
return;
}
/* ====== Options ===== */
// SSL Fix
Startup.DoSSLFix = options.SSLFix;
// Use curl
if (options.Client != null)
{
Startup.ClientOverride = options.Client.ToLowerInvariant();
}
// Use Proxy
if (options.ProxyConnection != null)
{
Startup.ProxyConnection = options.ProxyConnection.ToLowerInvariant();
Engine.Logger.Info("Proxy enabled. " + Startup.ProxyConnection);
}
// Logging
if (options.Logging)
{
Startup.LogRequests = true;
}
// Tracing
if (options.Tracing)
{
Startup.TracingEnabled = true;
}
// Log after the fact as using the logger will cause the options above to be used
if (options.Logging)
{
Engine.Logger.Info("Logging enabled.");
}
if (options.Tracing)
{
Engine.Logger.Info("Tracing enabled.");
}
if (options.SSLFix == true)
{
Engine.Logger.Info("SSL ECC workaround enabled.");
}
else if (options.SSLFix == false)
{
Engine.Logger.Info("SSL ECC workaround has been disabled.");
}
// Ignore SSL errors on Curl
Startup.IgnoreSslErrors = options.IgnoreSslErrors;
if (options.IgnoreSslErrors == true)
{
Engine.Logger.Info("Curl will ignore SSL certificate errors.");
}
// Choose Data Folder
if (!string.IsNullOrWhiteSpace(options.DataFolder))
{
Startup.CustomDataFolder = options.DataFolder.Replace("\"", string.Empty).Replace("'", string.Empty).Replace(@"\\", @"\");
Engine.Logger.Info("Jackett Data will be stored in: " + Startup.CustomDataFolder);
}
/* ====== Actions ===== */
// Install service
if (options.Install)
{
Engine.ServiceConfig.Install();
return;
}
// Uninstall service
if (options.Uninstall)
{
Engine.Server.ReserveUrls(doInstall: false);
Engine.ServiceConfig.Uninstall();
return;
}
// Reserve urls
if (options.ReserveUrls)
{
Engine.Server.ReserveUrls(doInstall: true);
return;
}
// Start Service
if (options.StartService)
{
if (!Engine.ServiceConfig.ServiceRunning())
{
Engine.ServiceConfig.Start();
}
return;
}
// Stop Service
if (options.StopService)
{
if (Engine.ServiceConfig.ServiceRunning())
{
Engine.ServiceConfig.Stop();
}
return;
}
// Migrate settings
if (options.MigrateSettings)
{
Engine.ConfigService.PerformMigration();
return;
}
// Show Version
if (options.ShowVersion)
{
Console.WriteLine("Jackett v" + Engine.ConfigService.GetVersion());
return;
}
/* ====== Overrides ===== */
// Override listen public
if (options.ListenPublic || options.ListenPrivate)
{
if (Engine.Server.Config.AllowExternal != options.ListenPublic)
{
Engine.Logger.Info("Overriding external access to " + options.ListenPublic);
Engine.Server.Config.AllowExternal = options.ListenPublic;
if (System.Environment.OSVersion.Platform != PlatformID.Unix)
{
if (ServerUtil.IsUserAdministrator())
{
Engine.Server.ReserveUrls(doInstall: true);
}
else
{
Engine.Logger.Error("Unable to switch to public listening without admin rights.");
Environment.ExitCode = 1;
return;
}
}
Engine.Server.SaveConfig();
}
}
// Override port
if (options.Port != 0)
{
if (Engine.Server.Config.Port != options.Port)
{
Engine.Logger.Info("Overriding port to " + options.Port);
Engine.Server.Config.Port = options.Port;
if (System.Environment.OSVersion.Platform != PlatformID.Unix)
{
if (ServerUtil.IsUserAdministrator())
{
Engine.Server.ReserveUrls(doInstall: true);
}
else
{
Engine.Logger.Error("Unable to switch ports when not running as administrator");
Environment.ExitCode = 1;
return;
}
}
Engine.Server.SaveConfig();
}
}
}
Engine.Server.Initalize();
Engine.Server.Start();
Engine.RunTime.Spin();
Engine.Logger.Info("Server thread exit");
}
catch (Exception e)
{
Engine.Logger.Error(e, "Top level exception");
}
}
public string GetUsage()
{
return("Decodes mtg-rnn output. Into a hearthstone api json file. \n\n" +
HelpText.AutoBuild(this,
(current) => HelpText.DefaultParsingErrorsHandler(this, current)));
}
public string GetUsage()
{
string usage = HelpText.AutoBuild(this, current => HelpText.DefaultParsingErrorsHandler(this, current));
return(usage);
}
private string ConstructHelp(ParserResult <object> result, ParserTypeInfo typeInfo)
{
List <string> helpText = new List <string>();
IEnumerable <Error> errors = ((NotParsed <object>)result).Errors.ToArray();
CopyrightInfo CreateCopyrightInfo()
{
try
{
return(CopyrightInfo.Default);
}
catch (Exception e)
{
executionContext.WriteError($"Exception while creating the copyright:{Environment.NewLine}{e}", false);
}
return(CopyrightInfo.Empty);
}
bool helpVerbRequested = errors.Any(e => e.Tag == ErrorType.HelpVerbRequestedError);
Assembly assembly = Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly();
GenerateHelpTextHeader();
GenerateHelpTextBody();
GenerateHelpTextFooter();
string help = string.Join(Environment.NewLine, helpText);
return(help);
void GenerateHelpTextHeader()
{
HelpText helpTextHeader = new HelpText
{
Heading = CreateHeadingInfo(),
Copyright = CreateCopyrightInfo(),
AdditionalNewLineAfterOption = true,
AddDashesToOption = true,
MaximumDisplayWidth = DisplayWidth
};
helpTextHeader = HelpText.DefaultParsingErrorsHandler(result, helpTextHeader);
AssemblyLicenseAttribute licenseAttribute = assembly.GetCustomAttribute <AssemblyLicenseAttribute>();
licenseAttribute?.AddToHelpText(helpTextHeader);
helpText.AddRange(helpTextHeader.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None));
}
void GenerateHelpTextBody()
{
if ((helpVerbRequested && typeInfo.Choices.Any()) ||
errors.Any(e => e.Tag == ErrorType.NoVerbSelectedError) ||
errors.Any(e => e.Tag == ErrorType.BadVerbSelectedError))
{
HelpText helpTextBody = new HelpText
{
AdditionalNewLineAfterOption = true,
AddDashesToOption = true,
MaximumDisplayWidth = DisplayWidth
};
helpTextBody.AddDashesToOption = false;
helpTextBody.AddVerbs(typeInfo.Choices.ToArray());
List <string> helpLines = new List <string>(helpTextBody.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None));
//direct base type == VerbBase means first level - show version option
if (typeInfo.Choices.Any() &&
typeInfo.Choices.First().BaseType != typeof(VerbBase))
{
RemoveVersion(helpLines);
}
helpText.AddRange(helpLines);
}
else
{
if (typeInfo.Current.GetCustomAttribute <UseChildVerbsAsCategoryAttribute>() != null)
{
ChildVerbsAttribute childVerbs = typeInfo.Current.GetCustomAttribute <ChildVerbsAttribute>();
IEnumerable <Type> childVerbTypes = (childVerbs?.Types ?? Enumerable.Empty <Type>())
.Concat(dynamicVerbFactory.GetDynamicVerbs(typeInfo.Current));
foreach (Type childVerbType in childVerbTypes)
{
HelpText helpTextBody = new HelpText
{
AdditionalNewLineAfterOption = true,
AddDashesToOption = true,
MaximumDisplayWidth = DisplayWidth
};
helpTextBody.AddPreOptionsLine(childVerbType.GetCustomAttribute <VerbAttribute>().HelpText);
if (typeof(TypeInfo).GetMethod("Create", BindingFlags.NonPublic | BindingFlags.Static,
null, new[] { typeof(Type) }, null)
?.Invoke(null, new object[] { childVerbType }) is TypeInfo childTypeInfo &&
typeof(Parsed <object>).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null,
new[]
{
typeof(object),
typeof(TypeInfo)
}, null)?.Invoke(new[] { null, childTypeInfo })
is ParserResult <object> childResult)
{
helpTextBody.AddOptions(childResult);
}
List <string> helpLines = new List <string>(helpTextBody.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None));
RemoveVersion(helpLines);
helpText.AddRange(helpLines);
}
}
else
{
HelpText helpTextBody = new HelpText
{
AdditionalNewLineAfterOption = true,
AddDashesToOption = true,
MaximumDisplayWidth = DisplayWidth
};
helpTextBody.AddOptions(result);
List <string> helpLines = new List <string>(helpTextBody.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None));
RemoveVersion(helpLines);
helpText.AddRange(helpLines);
}
}
}
void RemoveVersion(List <string> list)
{
string versionLine = list.FirstOrDefault(l => l.Trim().StartsWith("version ", StringComparison.Ordinal) ||
l.Trim().StartsWith("--version ", StringComparison.Ordinal));
if (!string.IsNullOrEmpty(versionLine))
{
int index = list.IndexOf(versionLine);
do
{
list.RemoveAt(index - 1);
} while (!string.IsNullOrEmpty(list[index - 1]));
}
}
void GenerateHelpTextFooter()
{
UsageExample[] examples = GetExamplesFromVerb(typeInfo.Current);
if (examples.Any())
{
HelpText helpTextFooter = new HelpText
{
AdditionalNewLineAfterOption = true,
AddDashesToOption = true,
MaximumDisplayWidth = DisplayWidth
};
helpTextFooter.AddPostOptionsLine("Examples:");
helpTextFooter.AddPostOptionsLine(string.Empty);
string commandName = assembly.GetName().Name.ToLowerInvariant();
foreach (UsageExample usageExample in examples)
{
PrintExample(helpTextFooter, usageExample, commandName);
}
if (typeInfo.Current.GetCustomAttribute <UseChildVerbsAsCategoryAttribute>() != null)
{
ChildVerbsAttribute childVerbs = typeInfo.Current.GetCustomAttribute <ChildVerbsAttribute>();
IEnumerable <Type> childVerbTypes = (childVerbs?.Types ?? Enumerable.Empty <Type>())
.Concat(dynamicVerbFactory.GetDynamicVerbs(typeInfo.Current));
IEnumerable <(string verbName, UsageExample[] examples)> childExamples = childVerbTypes.Select(t => (t.GetCustomAttribute <VerbAttribute>().Name,
GetExamplesFromVerb(t)))
.Where(e => e.Item2.Any());
foreach ((string verbName, UsageExample[] usageExamples) in childExamples)
{
helpTextFooter.AddPostOptionsLine(string.Empty);
helpTextFooter.AddPostOptionsLine($"For {verbName}s:");
helpTextFooter.AddPostOptionsLine(string.Empty);
foreach (UsageExample usageExample in usageExamples)
{
PrintExample(helpTextFooter, usageExample, commandName);
}
}
}
helpText.AddRange(helpTextFooter.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None));
}
void PrintExample(HelpText helpTextFooter, UsageExample usageExample, string commandName)
{
helpTextFooter.AddPostOptionsLine(usageExample.HelpText.EndsWith(":", StringComparison.Ordinal)
? usageExample.HelpText
: $"{usageExample.HelpText}:");
helpTextFooter.AddPostOptionsLine($@"{commandName} {usageExample.Command}");
helpTextFooter.AddPostOptionsLine(string.Empty);
}
UsageExample[] GetExamplesFromVerb(Type verbType)
{
PropertyInfo property = verbType.GetProperties(BindingFlags.Public | BindingFlags.Static)
.FirstOrDefault(p => p.GetCustomAttribute <UsageAttribute>() != null &&
p.PropertyType ==
typeof(IEnumerable <UsageExample>));
UsageExample[] verbExamples =
((IEnumerable <UsageExample>)property?.GetValue(null) ?? Enumerable.Empty <UsageExample>())
.ToArray();
return(verbExamples);
}
}
}
public string DoHelpForVerb(string verbName)
{
return(HelpText.AutoBuild(this,
current => HelpText.DefaultParsingErrorsHandler(this, current),
true));
}
private static int Main(string[] args)
{
const int defaultReturnCodeFail = -1;
var parser = new Parser(settings => {
settings.IgnoreUnknownArguments = true;
});
var parsedResult = parser.ParseArguments <Options>(args);
var isOptionsValid = parsedResult.Tag == ParserResultType.Parsed;
if (!isOptionsValid)
{
var helpText = HelpText.AutoBuild(parsedResult);
HelpText.DefaultParsingErrorsHandler(parsedResult, helpText);
Console.WriteLine(helpText);
return(defaultReturnCodeFail);
}
var options = ((Parsed <Options>)parsedResult).Value;
options.SongID = Math.Abs(options.SongID) % 10000;
if (string.IsNullOrEmpty(options.ImageFileName) && !File.Exists(options.ImageFileName))
{
Console.WriteLine($"ERROR: image file '{options.ImageFileName}' is not found.");
return(defaultReturnCodeFail);
}
var fullDirectoryName = (new DirectoryInfo(options.OutputDirectory)).FullName;
if (!Directory.Exists(fullDirectoryName))
{
try {
Directory.CreateDirectory(fullDirectoryName);
} catch (Exception ex) {
Console.WriteLine($"ERROR: Tried to create directory '{fullDirectoryName}' but failed.\n{ex.Message}");
return(defaultReturnCodeFail);
}
}
Bitmap bitmap;
try {
bitmap = (Bitmap)Image.FromFile(options.ImageFileName);
} catch (Exception ex) {
Console.WriteLine($"ERROR: Cannot read image file '{options.ImageFileName}'.\n{ex.Message}");
return(defaultReturnCodeFail);
}
// Magic begins!
byte[] pvr, dds;
using (var smallImage = new Bitmap(bitmap, BundleOptions.SmallImageSize, BundleOptions.SmallImageSize)) {
pvr = PvrUtilities.GetPvrTextureFromImage(smallImage);
}
using (var mediumImage = new Bitmap(bitmap, BundleOptions.MediumImageSize, BundleOptions.MediumImageSize)) {
dds = DdsUtilities.GetDdsTextureFromImage(mediumImage);
}
bitmap.Dispose();
var bundleOptions = new BundleOptions();
bundleOptions.PvrImage = pvr;
bundleOptions.DdsImage = dds;
bundleOptions.PvrPathID = options.PvrPathID;
bundleOptions.DdsPathID = options.DdsPathID;
bundleOptions.SongID = options.SongID;
var fileName = Path.Combine(fullDirectoryName, $"jacket_{options.SongID}_android.unity3d");
using (var fileStream = File.Open(fileName, FileMode.Create, FileAccess.Write)) {
bundleOptions.Platform = UnityPlatformID.Android;
JacketBundle.Serialize(bundleOptions, fileStream);
}
fileName = Path.Combine(fullDirectoryName, $"jacket_{options.SongID}_ios.unity3d");
using (var fileStream = File.Open(fileName, FileMode.Create, FileAccess.Write)) {
bundleOptions.Platform = UnityPlatformID.iOS;
JacketBundle.Serialize(bundleOptions, fileStream);
}
Console.WriteLine($"Building complete. Files are written to '{fullDirectoryName}', song ID = {options.SongID}.");
return(0);
}
public static string GetUsage(ParserResult <SampleOptions> results)
{
return(HelpText.AutoBuild(results, (HelpText current) => HelpText.DefaultParsingErrorsHandler(results, current)));
}
public string GetUsage()
{
ShowingHelp = true;
return(HelpText.AutoBuild(this, current => HelpText.DefaultParsingErrorsHandler(this, current)));
}
public string GetUsage()
{
return(HelpText.AutoBuild(this, (HelpText current) => HelpText.DefaultParsingErrorsHandler(this, current)));
}
public string GetUsage()
{
string helpText = HelpText.AutoBuild(this, current => HelpText.DefaultParsingErrorsHandler(this, current));
return(helpText.Replace("License type.", LicenseTypeHelp));
}
