public void OptionAndOptionWithArgument()
{
String[] args = new String[] {
"-p",
"-attr",
"p"
};
ICommandLine cl = parser.Parse(options, args);
Assert.IsTrue(cl.HasOption("p"), "Confirm -p is set");
Assert.IsTrue(cl.HasOption("attr"), "Confirm -attr is set");
Assert.IsTrue(cl.GetOptionValue("attr").Value.Equals("p"), "Confirm arg of -attr");
Assert.IsTrue(!cl.Arguments.Any(), "Confirm all arguments recognized");
}
public bool Run(string[] args)
{
try
{
var result = _commandLineParser.Parse(args);
if (result != null)
{
_buildLogProcessor.Proces(
result.InputFile,
result.OutputFile,
result.CloneRoot,
result.Owner,
result.Repo,
result.Hash,
result.ConfigurationFile);
return(true);
}
return(false);
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex.ToString());
return(false);
}
}
public IReadOnlyList <StyledSpan <TextStyle> > Highlight(string commandLine)
{
if (commandLine == null)
{
throw new ArgumentNullException(nameof(commandLine));
}
if (commandLine.Length == 0)
{
return(Array.Empty <StyledSpan <TextStyle> >());
}
if (String.IsNullOrWhiteSpace(commandLine))
{
return(GetDefaultForAll(commandLine));
}
var syntax = _parser.Parse(commandLine);
var highlights = new List <StyledSpan <TextStyle> >();
var visitorParams = new CommandLineHighlightingVisitorParams <TextStyle>(
highlights, _highlightingOptions.Palette);
syntax.Accept(_highlightingVisitor, visitorParams);
return(highlights);
}
public static object ParseObject(this ICommandLineParser parser, Type type, Options options, string[] args, bool stopAtNotOption)
{
var commandLine = parser.Parse(options, args, stopAtNotOption);
var obj = Activator.CreateInstance(type, true);
ReflectedOptions.SetToObject(options, commandLine, obj);
return(obj);
}
public Task <string> GetInitialProjectLocationAsync()
{
var commandLineContext = new CommandLineContext();
_commandLineParser.Parse(_commandLineService.GetCommandLine(), commandLineContext);
return(Task.FromResult(commandLineContext.InitialFile));
}
public async Task <string> GetInitialProjectLocationAsync()
{
var commandLineContext = new CommandLineContext();
_commandLineParser.Parse(_startUpInfoProvider.Arguments, commandLineContext);
return(commandLineContext.InitialFile);
}
public static IValidationContext Parse(this ICommandLineParser commandLineParser, string commandLineArguments, IContext targetContext)
{
Argument.IsNotNull(() => commandLineParser);
var splitted = _regex.Matches(commandLineArguments).Cast <Match>()
.Select(m => m.Value)
.ToList();
return(commandLineParser.Parse(splitted, targetContext));
}
public async Task ExecuteAsync <TContext>(string commandLineString, TContext context, CancellationToken cancellationToken)
{
if (commandLineString.IsNullOrEmpty())
{
throw DynamicException.Create("CommandLineNullOrEmpty", "You need to specify at least one command.");
}
var commandLines = _commandLineParser.Parse(commandLineString);
await ExecuteAsync(commandLines, context, cancellationToken);
}
public void HandleCommandLine(string [] args, ICommandLineParser parser)
{
if (parser == null)
{
throw new ArgumentNullException("parser");
}
Initialize();
parser.Options = appOptions;
CommandLine commandLine = parser.Parse(args);
if (commandLine.HasParsed)
{
HandleCommandLine(commandLine);
}
}
public bool Run(string[] args)
{
try
{
var result = _commandLineParser.Parse(args);
if (result != null)
{
return(_submissionService.SubmitAsync(result.InputFile, result.Token, result.HeadSha).Result);
}
return(false);
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex.ToString());
return(false);
}
}
public void Run()
{
var result = parser.Parse(options);
if (!result.Valid)
{
Console.WriteLine(result.InputValue);
Console.WriteLine(result.HelpText);
return;
}
Console.CancelKeyPress += Console_CancelKeyPress;
KillProcesses();//first run check and kill process according to the params
var timer = new Timer(TimeSpan.FromMinutes(options.Frequency).TotalMilliseconds);
timer.AutoReset = true;
timer.Elapsed += Timer_Elapsed;
try
{
timer.Start();
while (true)
{
if (_cancelled)
{
log.Info("The app was canceled");
timer.Dispose();
Console.CancelKeyPress -= Console_CancelKeyPress;
return;
}
}
}
catch (Exception e)
{
log.Error(e.Message);
log.Error(e.StackTrace);
}
finally
{
timer.Dispose();
Console.CancelKeyPress -= Console_CancelKeyPress;
}
}
private int RunInternal(string[] args)
{
_log.Trace("Application starting.");
// Parses command line without sanity checks.
CommandLineParseResult parseResult = _parser.Parse(args);
if (!parseResult.IsCorrect || !parseResult.Verb.HasValue)
{
_log.Error("Command line arguments incorrect.");
return(1);
}
IVerbRunner verbRunner = CreateVerbRunner(parseResult.Verb.Value, parseResult.VerbOptions);
verbRunner.Run();
return(0);
}
public async Task <int> Parse(params string[] args)
{
if (!args.Contains("--verbose"))
{
args = args.Concat(new[] { "--verbose" }).ToArray();
}
try
{
return(await commandLineParserImplementation.Parse(args));
}catch (Exception e)
{
if (!exceptionHandler.HandleException(e))
{
throw;
}
return(-1);
}
}
public async Task <IReadOnlyList <SoftKeySet> > ExecuteAsync(string commandLineString, CancellationToken cancellationToken)
{
if (commandLineString.IsNullOrEmpty())
{
return(NoCommandsExecuted);
}
var commandLines = _commandLineParser.Parse(commandLineString).ToList();
var executables =
(from commandLine in commandLines
let commandName = commandLine.CommandName()
let command = _commandFactory.CreateCommand(commandName, commandLine)
select(commandName, command)).ToList();
var notFoundCommands = executables.Where(exe => exe.command is null).ToList();
if (notFoundCommands.Any())
{
// From each command get only a single name but take the longest one as this is most likely the full-name.
var notFoundCommandNames = notFoundCommands.Select(exe => exe.commandName.OrderByDescending(name => name.Length).First().ToString());
throw DynamicException.Factory.CreateDynamicException(
$"CommandNotFound{nameof(Exception)}",
$"Could not find one or more commands: {notFoundCommandNames.Join(", ").EncloseWith("[]")}.",
null);
}
var executedCommands = new List <SoftKeySet>();
foreach (var executable in executables)
{
await executable.command.ExecuteAsync(cancellationToken);
executedCommands.Add(executable.commandName);
}
return(executedCommands);
}
public IActionResult Post([FromBody] ConvertModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(
new ConvertResult <ConvertModel>(
ModelState.SelectMany(r => r.Value.Errors.Select(e => e.ErrorMessage))
.ToArray())));
}
var parseResult = _commandLineParser.Parse(new Span <char>(model.Curl.ToCharArray()));
if (!parseResult.Success)
{
return(BadRequest(parseResult));
}
var csharp = _converterService.ToCsharp(parseResult.Data);
csharp.AddWarnings(parseResult.Warnings);
return(Ok(csharp));
}
public Task <int> Parse(params string[] args)
{
return(parser.Parse(args));
}
public static ICommandLine Parse(this ICommandLineParser parser, object options, string[] args, bool stopAtNotOption)
{
return(parser.Parse(ReflectedOptions.CreateFromObject(options), args, stopAtNotOption));
}
public void Parse_Empty_EmptyCollection()
{
var commandLines = Parser.Parse(string.Empty).ToList();
Assert.True(commandLines.Empty());
}
public static ICommandLine ParseConsole(this ICommandLineParser parser, Options options, bool stopAtNotOption)
{
return(parser.Parse(options, Environment.GetCommandLineArgs(), stopAtNotOption));
}
public ICommand Create(string cmd)
{
var cmdElements = _parser.Parse(cmd);
var argument = cmdElements.OfType <ArgumentElement>().First();
var definitions = cmdElements.OfType <DefinitionElement>().ToArray();
switch (argument.Id)
{
case "register":
return(new RegisterAccountCommand(_userAgent, new RegisterAccountArguments
{
Domain = definitions.First(x => x.Key == "d").Value,
Extension = definitions.First(x => x.Key == "e").Value,
Password = definitions.First(x => x.Key == "p").Value,
Port = definitions.First(x => x.Key == "Port").Value,
Transport = definitions.First(x => x.Key == "t").Value
}));
case "accounts":
return(new ShowAccountsCommand(_userAgent));
case "unregister":
return(new UnregisterAccountCommand(_userAgent,
new IdArguments {
Id = definitions.First(x => x.Key == "i").Value
}));
case "codecs":
return(new ShowCodecsCommand(_userAgent));
case "setcodec":
return(new SetCodecCommand(_userAgent, new CodecArguments
{
Channels = definitions.First(x => x.Key == "Channels").Value,
CodecId = definitions.First(x => x.Key == "c").Value,
Frequency = definitions.First(x => x.Key == "f").Value,
Priority = definitions.First(x => x.Key == "p").Value,
}));
case "devices":
return(new ShowDevicesCommand(_userAgent));
case "setdevice":
return(new SetDeviceCommand(_userAgent, new DeviceArguments
{
CaptureId = definitions.First(x => x.Key == "c").Value,
PlaybackId = definitions.First(x => x.Key == "p").Value,
}));
case "calls":
return(new ShowCallsCommand(_userAgent));
case "makecall":
return(new MakeCallCommand(_userAgent, new CallArguments
{
At = definitions.First(x => x.Key == "a").Value,
From = definitions.First(x => x.Key == "f").Value,
Through = definitions.First(x => x.Key == "Through").Value,
To = definitions.First(x => x.Key == "t").Value,
}));
case "hangupcall":
return(new HangupCallCommand(_userAgent,
new IdArguments {
Id = definitions.First(x => x.Key == "i").Value
}));
case "dtmf":
return(new SendDtmfCommand(_userAgent, new DtmfArguments
{
CallId = definitions.First(x => x.Key == "c").Value,
Digits = definitions.First(x => x.Key == "d").Value,
}));
case "xfer":
return(new TransferCommand(_userAgent, new TransferArguments
{
CallId = definitions.First(x => x.Key == "c").Value,
Destination = definitions.First(x => x.Key == "d").Value,
}));
case "buddies":
return(new ShowAllBuddiesCommand(_userAgent));
case "registerbuddy":
return(new RegisterBuddyCommand(_userAgent, new RegisterBuddyArguments
{
Domain = definitions.First(x => x.Key == "d").Value,
Extension = definitions.First(x => x.Key == "e").Value,
Port = definitions.First(x => x.Key == "Port").Value,
Subscribe = definitions.First(x => x.Key == "s").Value,
Transport = definitions.First(x => x.Key == "t").Value,
}));
case "unregisterbuddy":
return(new UnregisterBuddyCommand(_userAgent,
new IdArguments {
Id = definitions.First(x => x.Key == "i").Value
}));
case "dumpsub":
return(new DumpSubscriptionCommand(_userAgent, new DumpSubscriptionArguments
{
Verbose = definitions.First(x => x.Key == "v").Value
}));
case "im":
return(new SendImCommand(_userAgent, new ImArguments
{
At = definitions.First(x => x.Key == "a").Value,
Body = definitions.First(x => x.Key == "b").Value,
From = definitions.First(x => x.Key == "f").Value,
InDialog = definitions.First(x => x.Key == "i").Value,
Through = definitions.First(x => x.Key == "Through").Value,
To = definitions.First(x => x.Key == "t").Value,
}, _container.Get <IMessageBuilder>()));
case "playertest":
return(new PlayFileCommand(_userAgent, _container));
case "?":
case "help":
case "print":
return(new PrintUsageCommand());
default:
return(new NoOpCommand());
}
}
public static ICommandLine Parse(this ICommandLineParser parser, Options options, string[] args, bool stopAtNotOption)
{
return(parser.Parse(options, args, null, stopAtNotOption));
}
private async Task CommandLineLoop(CommandDelegate application, CancellationToken loopToken)
{
await Task.Yield();
var consoleTokenSource = new ConsoleCancelEventTokenSource(_console);
loopToken.Register(consoleTokenSource.Cancel);
IsRunning = true;
bool isFirstCancel = true;
string commandLine = null;
try
{
while (!loopToken.IsCancellationRequested)
{
try
{
_outputLock.Lock();
_prompt?.Write(_coloredTextWriter);
commandLine = await _lineReader.ReadLineAsync(consoleTokenSource.Token)
.ConfigureAwait(false);
}
catch (OperationCanceledException ex)
{
// Do not throw because this is a normal loop ending.
if (loopToken.IsCancellationRequested)
{
break;
}
consoleTokenSource.Reset();
_console.WriteLine();
if (ex is ReadingLineCanceledException rex && rex.HadUserInput)
{
// Do not count this as a first cancellation if there was a user input
// and reset the flag if it was not the first one.
isFirstCancel = true;
continue;
}
// Exit on double Ctrl+C hotkey.
if (!isFirstCancel)
{
break;
}
isFirstCancel = false;
_console.WriteLine("Press Ctrl+C again to close application");
continue;
}
finally
{
_outputLock.Unlock();
}
// Reset the flag after a succesfull reading.
isFirstCancel = true;
if (String.IsNullOrWhiteSpace(commandLine))
{
continue;
}
try
{
var parsedCommandLine = _parser.Parse(commandLine, consoleTokenSource.Token);
if (parsedCommandLine.HasErrors)
{
PrintParseErrors(parsedCommandLine);
continue;
}
var context = _contextBuilder
.SetCancelToken(consoleTokenSource.Token)
.SetRawCommandLine(commandLine)
.SetParsedCommandLine(parsedCommandLine)
.Build();
// End command-line loop.
if (loopToken.IsCancellationRequested)
{
break;
}
await application(context).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
// Do not throw because this is a normal loop ending.
if (loopToken.IsCancellationRequested)
{
break;
}
consoleTokenSource.Reset();
_console.WriteLine();
}
catch (Exception ex)
{
PrintErrorMessage(ex, verbose: false);
}
}
}
finally
{
consoleTokenSource.Dispose();
IsRunning = false;
}
}
private static async Task <int> MainAsync(string[] args)
{
if (args.Any() &&
args[0].Equals(CommandLineConstants.MigrateCliVerb, StringComparison.OrdinalIgnoreCase) &&
!args.Any(a => a.TrimEnd().EndsWith("help", StringComparison.OrdinalIgnoreCase)))
{
return(Migrate() ? 0 : 1);
}
Agents.Net.CommunityAnalysis.Analyse(Array.Empty <Assembly>());
#if DEBUG
Stopwatch stopwatch = Stopwatch.StartNew();
#endif
try
{
bool noSdkExploration = args.Any(a => a.Contains("--no-sdk-exploration", StringComparison.Ordinal));
ILog log = CreateLog();
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterInstance(log);
builder.RegisterModule(new DiModule(noSdkExploration));
using (IContainer container = builder.Build())
{
try
{
ICommandLineParser commandLineParser = container.Resolve <ICommandLineParser>();
#if DEBUG
Console.WriteLine($@"Startup timer {stopwatch.Elapsed}");
Console.WriteLine($@"Arguments: {args.Aggregate(string.Empty, (s, s1) => s + "_" + s1)}");
#endif
int result = await commandLineParser.Parse(args).ConfigureAwait(false);
return(result);
}
catch (Exception e)
{
IExceptionHandler exceptionHandler = container.Resolve <IExceptionHandler>();
if (!exceptionHandler.HandleException(e))
{
throw;
}
return(-1);
}
}
}
catch (Exception e)
{
Console.WriteLine($@"Unexpected exception during execution{Environment.NewLine}{e}");
Trace.TraceError(e.ToString());
return(-1);
}
ILog CreateLog()
{
string path = LogHelper.GetLogCatalogLocation();
ILog result = LogCatalog.CreateNewLog(path, string.Join(" ", args));
result.AddInitialLog(args);
return(result);
}
bool Migrate()
{
ILog log = LogHelper.GetMigrationLog();
try
{
log.AddInitialLog(args);
//Not implemented feature: Old version has caches and settings in same location as current version.
//How to identify the version? Probably create a .version file.
return(MigrationChain.Start(m =>
{
Console.WriteLine(m);
log.LogInformation(m);
})
.AddPotentialLocation(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"plcncli.Common"), new Version(19, 0))
.AddMigrationFile("settings.xml")
.AddMigrationFile("sdk-properties.xml")
.SetMigrationDestination(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
(Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly()).GetName().Name))
.AddConversionStep <ConversionFrom190>()
.Execute());
}
finally
{
(log as IDisposable)?.Dispose();
}
}
}
public void Parse_Empty_EmptyCollection()
{
var arguments = Parser.Parse("").ToList();
Assert.That.Collection().IsEmpty(arguments);
}
public void Parse_Empty_EmptyCollection()
{
var commandLines = Parser.Parse(string.Empty).ToList();
Assert.That.Collection().IsEmpty(commandLines);
}
public CommandLineSyntax CommandNameOnly()
{
return(_parser.Parse(Command_NameOnly));
}
public void HandleCommandLine(string [] args, ICommandLineParser parser)
{
if (parser == null)
throw new ArgumentNullException("parser");
Initialize();
parser.Options = appOptions;
CommandLine commandLine = parser.Parse(args);
if (commandLine.HasParsed)
HandleCommandLine(commandLine);
}
