private static IEnumerable<Match> MatchCommands(CommandParameters parameters, int argCount, CommandHandlerDescriptor descriptor, ICommandHandler handler)
{
foreach (var commandDescriptor in descriptor.Commands)
{
foreach (var name in commandDescriptor.Names)
{
var names = name.Split(' ');
// We check here number of arguments a command can recieve against
// arguments provided for the command to identify the correct command
// and avoid matching multiple commands.
if(commandDescriptor.MethodInfo.GetParameters().Length == argCount - names.Count())
{
names = parameters.Arguments.ToArray();
}
if (parameters.Arguments.Take(argCount).SequenceEqual(names, StringComparer.OrdinalIgnoreCase))
{
yield return new Match
{
Context = new CommandContext
{
Arguments = parameters.Arguments.Skip(name.Split(' ').Count()),
Command = string.Join(" ", names),
CommandDescriptor = commandDescriptor,
Input = parameters.Input,
Output = parameters.Output,
Switches = parameters.Switches,
},
CommandHandler = handler
};
}
}
}
}
private static IEnumerable<Match> MatchCommands(CommandParameters parameters, int argCount, CommandHandlerDescriptor descriptor, ICommandHandler handler)
{
foreach (var commandDescriptor in descriptor.Commands)
{
foreach (var name in commandDescriptor.Names)
{
var names = name.Split(' ');
if (parameters.Arguments.Take(argCount).SequenceEqual(names, StringComparer.OrdinalIgnoreCase))
{
yield return new Match
{
Context = new CommandContext
{
Arguments = parameters.Arguments.Skip(names.Count()),
Command = string.Join(" ", names),
CommandDescriptor = commandDescriptor,
Input = parameters.Input,
Output = parameters.Output,
Switches = parameters.Switches,
},
CommandHandler = handler
};
}
}
}
}
private IEnumerable<Match> MatchCommands(CommandParameters parameters)
{
// Commands are matched with arguments. first argument
// is the command others are arguments to the command.
return _commandHandlers.SelectMany(h =>
MatchCommands(parameters, parameters.Arguments.Count(), _builder.Build(h.GetType()), h)).ToList();
}
public OrchardParameters Parse(CommandParameters parameters)
{
var result = new OrchardParameters
{
Arguments = new List<string>(),
ResponseFiles = new List<string>(),
Switches = new Dictionary<string, string>()
};
foreach (var arg in parameters.Arguments)
{
// @response-file
if (arg[0] == '@')
{
var filename = arg.Substring(1);
if (string.IsNullOrEmpty(filename))
{
throw new ArgumentException("Incorrect syntax: response file name can not be empty");
}
result.ResponseFiles.Add(filename);
}
// regular argument
else
{
result.Arguments.Add(arg);
}
}
foreach (var sw in parameters.Switches)
{
// Built-in switches
switch (sw.Key.ToLowerInvariant())
{
case "v":
case "verbose":
bool verbose;
if (!bool.TryParse(sw.Value, out verbose))
verbose = true;
result.Verbose = verbose;
break;
case "t":
case "tenant":
result.Tenant = sw.Value;
break;
default:
result.Switches.Add(sw.Key, sw.Value);
break;
}
}
return result;
}
private IEnumerable<Match> MatchCommands(CommandParameters parameters)
{
// Command names are matched with as many arguments as possible, in decreasing order
foreach (var argCount in Enumerable.Range(1, parameters.Arguments.Count()).Reverse())
{
int count = argCount;
var matches = _commandHandlers.SelectMany(h =>
MatchCommands(parameters, count, _builder.Build(h.GetType()), h)).ToList();
if (matches.Any())
return matches;
}
return Enumerable.Empty<Match>();
}
public CommandReturnCodes RunCommand(TextReader input, TextWriter output, string tenant, string[] args, IDictionary<string, string> switches)
{
try
{
tenant = tenant ?? ShellHelper.DefaultShellName;
using (var env = CreateStandaloneEnvironment(tenant))
{
var commandManager = env.ServiceProvider.GetService<ICommandManager>();
var parameters = new CommandParameters
{
Arguments = args,
Switches = switches,
Input = input,
Output = output
};
commandManager.Execute(parameters);
}
return CommandReturnCodes.Ok;
}
catch (OrchardCommandHostRetryException ex)
{
// Special "Retry" return code for our host
output.WriteLine(T("{0} (Retrying...)", ex.Message));
return CommandReturnCodes.Retry;
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
if (ex is TargetInvocationException &&
ex.InnerException != null)
{
// If this is an exception coming from reflection and there is an innerexception which is the actual one, redirect
ex = ex.InnerException;
}
OutputException(output, T("Error executing command \"{0}\"", string.Join(" ", args)), ex);
return CommandReturnCodes.Fail;
}
}
public void Execute(CommandParameters parameters)
{
var matches = MatchCommands(parameters);
if (matches.Count() == 1) {
var match = matches.Single();
match.CommandHandler.Execute(match.Context);
}
else {
var commandMatch = string.Join(" ", parameters.Arguments.ToArray());
var commandList = string.Join(",", GetCommandDescriptors().Select(d => d.Name).ToArray());
if (matches.Any()) {
throw new OrchardCoreException(T("Multiple commands found matching arguments \"{0}\". Commands available: {1}.",
commandMatch, commandList));
}
throw new OrchardCoreException(T("No command found matching arguments \"{0}\". Commands available: {1}.",
commandMatch, commandList));
}
}
public async Task <CommandReturnCodes> RunCommandAsync(TextReader input, TextWriter output, string tenant, string[] args, IDictionary <string, string> switches)
{
try
{
tenant = tenant ?? ShellHelper.DefaultShellName;
using (var env = await CreateStandaloneEnvironmentAsync(tenant))
{
var commandManager = env.ServiceProvider.GetService <ICommandManager>();
var parameters = new CommandParameters
{
Arguments = args,
Switches = switches,
Input = input,
Output = output
};
await commandManager.ExecuteAsync(parameters);
}
return(CommandReturnCodes.Ok);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
if (ex is TargetInvocationException &&
ex.InnerException != null)
{
// If this is an exception coming from reflection and there is an innerexception which is the actual one, redirect
ex = ex.InnerException;
}
await OutputExceptionAsync(output, T["Error executing command \"{0}\"", string.Join(" ", args)], ex);
return(CommandReturnCodes.Fail);
}
}
public CommandReturnCodes RunCommand(TextReader input, TextWriter output, string tenant, string[] args, IDictionary <string, string> switches)
{
try {
tenant = tenant ?? ShellHelper.DefaultShellName;
using (var env = CreateStandaloneEnvironment(tenant)) {
var commandManager = env.LifetimeScope.GetService <ICommandManager>();
var parameters = new CommandParameters {
Arguments = args,
Switches = switches,
Input = input,
Output = output
};
commandManager.Execute(parameters);
}
return(CommandReturnCodes.Ok);
}
catch (OrchardCommandHostRetryException ex) {
// Special "Retry" return code for our host
output.WriteLine(T("{0} (Retrying...)", ex.Message));
return(CommandReturnCodes.Retry);
}
catch (Exception ex) {
if (ex.IsFatal())
{
throw;
}
if (ex is TargetInvocationException &&
ex.InnerException != null)
{
// If this is an exception coming from reflection and there is an innerexception which is the actual one, redirect
ex = ex.InnerException;
}
OutputException(output, T("Error executing command \"{0}\"", string.Join(" ", args)), ex);
return(CommandReturnCodes.Fail);
}
}
public void Execute(CommandParameters parameters)
{
var matches = MatchCommands(parameters);
if (matches.Count() == 1)
{
var match = matches.Single();
match.CommandHandler.Execute(match.Context);
}
else
{
var commandMatch = string.Join(" ", parameters.Arguments.ToArray());
var commandList = string.Join(",", GetCommandDescriptors().Select(d => d.Name).ToArray());
if (matches.Any())
{
throw new OrchardCoreException(T("Multiple commands found matching arguments \"{0}\". Commands available: {1}.",
commandMatch, commandList));
}
throw new OrchardCoreException(T("No command found matching arguments \"{0}\". Commands available: {1}.",
commandMatch, commandList));
}
}
public async Task ExecuteAsync(CommandParameters parameters)
{
var matches = MatchCommands(parameters) ?? Enumerable.Empty <Match>();
if (matches.Count() == 1)
{
var match = matches.Single();
await match.CommandHandler.ExecuteAsync(match.Context);
}
else
{
var commandMatch = string.Join(" ", parameters.Arguments.ToArray());
var commandList = string.Join(",", GetCommandDescriptors().SelectMany(d => d.Names).ToArray());
if (matches.Any())
{
throw new OrchardCoreException(T["Multiple commands found matching arguments \"{0}\". Commands available: {1}.",
commandMatch, commandList]);
}
throw new OrchardCoreException(T["No command found matching arguments \"{0}\". Commands available: {1}.",
commandMatch, commandList]);
}
}
private static IEnumerable <Match> MatchCommands(CommandParameters parameters, int argCount, CommandHandlerDescriptor descriptor, ICommandHandler handler)
{
foreach (var commandDescriptor in descriptor.Commands)
{
var names = commandDescriptor.Name.Split(' ');
if (!parameters.Arguments.Take(argCount).SequenceEqual(names, StringComparer.OrdinalIgnoreCase))
{
// leading arguments not equal to command name
continue;
}
yield return(new Match {
Context = new CommandContext {
Arguments = parameters.Arguments.Skip(names.Count()),
Command = string.Join(" ", names),
CommandDescriptor = commandDescriptor,
Input = parameters.Input,
Output = parameters.Output,
Switches = parameters.Switches,
},
CommandHandler = handler
});
}
}
public void ManagerCanRunACompositeCommand()
{
var context = new CommandParameters { Arguments = ("Foo Bar Bleah").Split(' '), Output = new StringWriter() };
_manager.Execute(context);
Assert.Equal("Bleah", context.Output.ToString());
}
public void ManagerCanRunACommand()
{
var context = new CommandParameters { Arguments = new string[] { "FooBar" }, Output = new StringWriter() };
_manager.Execute(context);
Assert.Equal("success!", context.Output.ToString());
}
