Ejemplo n.º 1
0
        private Task ProcessWithHelp(IInput input, IHostContext context, ICommandProvider commandProvider)
        {
            string helpCommand = null;

            if (input.Options.TryGetValue("command", out object commandOption))
            {
                if (commandOption is string)
                {
                    helpCommand = (string)commandOption;
                }
                else if (commandOption is IEnumerable <string> commandEnum)
                {
                    helpCommand = commandEnum.FirstOrDefault();
                }
            }
            if (helpCommand == null)
            {
                foreach (object arg in input.Arguments)
                {
                    if (arg is string)
                    {
                        helpCommand = (string)arg;
                        break;
                    }
                    else if (arg is IEnumerable <string> argEnum)
                    {
                        helpCommand = argEnum.FirstOrDefault();
                        if (helpCommand != null)
                        {
                            break;
                        }
                    }
                }
            }
            if (helpCommand == null)
            {
                context.SetResult(GetCommandsList(commandProvider));
            }
            else
            {
                CommandRecord commandRecord = commandProvider.MatchCommandByName(helpCommand);
                if (commandRecord == null)
                {
                    Exception error = new Exception($"command not found: {helpCommand}");
                    context.Exception = error;
                }
                else
                {
                    string     commandName = commandRecord.Command;
                    MethodInfo entryMethod = commandRecord.CommandEntry;
                    context.SetResult(CommandInfo.GetInfo(commandName, entryMethod));
                }
            }
            return(Task.CompletedTask);
        }
Ejemplo n.º 2
0
        public Task Invoke(IHostContext context, Func <Task> next,
                           IServiceProvider services, ICommandProvider commandProvider, IEnvironment env, IOutputEngine outputEngine, IHostInput hostInput)
        {
            IInput input = context.Command;

            if (input.Name == "help")
            {
                return(ProcessWithHelp(input, context, commandProvider));
            }

            CommandRecord command = commandProvider.MatchCommand(context);

            if (command == null)
            {
                return(next());
            }

            MethodInfo methodInfo = command.CommandEntry;

            ParameterInfo[] parameters  = methodInfo.GetParameters();
            List <int>      pathIndices = new List <int>();

            foreach (var parameter in parameters)
            {
                if (parameter.GetCustomAttribute <PathAttribute>() != null)
                {
                    pathIndices.Add(parameter.Position);
                }
            }

            try
            {
                CommandSet instance = (CommandSet)ObjectFactory.CreateInstance(command.InstanceType, services, input.Options, input.Arguments);
                instance.Command      = input;
                instance.Context      = context;
                instance.InputObject  = context.InputObject;
                instance.OutputEngine = outputEngine;
                instance.HostInput    = hostInput;
                instance.Environment  = env;
                object value;
                if (pathIndices.Count <= 0)
                {
                    value = ObjectFactory.InvokeMethod(instance, methodInfo, services, input.Options, input.Arguments);
                }
                else
                {
                    MethodInvokeContext invokeContext = ObjectFactory.CreateInvokeContext(methodInfo, services, input.Options, input.Arguments);
                    string currentPath = env.WorkingDirectory.FullName;
                    ProcessPathAttribute(pathIndices, parameters, invokeContext.Arguments, currentPath);
                    value = invokeContext.Invoke(instance);
                }
                if (command.CommandEntry.ReturnType != typeof(void))
                {
                    context.SetResult(value);
                }
            }
            catch (Exception ex)
            {
                context.Exception = ex;
            }
            return(Task.CompletedTask);
        }
Ejemplo n.º 3
0
        private Dictionary <string, CommandRecord> LoadCommands()
        {
            Dictionary <string, CommandRecord> commands = new Dictionary <string, CommandRecord>();
            string        dir           = new FileInfo(Assembly.GetEntryAssembly().Location).Directory.FullName;
            DirectoryInfo directoryInfo = new DirectoryInfo(dir);

            FileInfo[] files          = directoryInfo.GetFiles("*.dll");
            Type       commandsetType = typeof(CommandSet);
            string     typeName;
            string     methodName;
            string     command;
            IEnumerable <CommandAttribute> commandAttributes;

            foreach (FileInfo file in files)
            {
                Assembly assembly = Assembly.Load(AssemblyLoadContext.GetAssemblyName(file.FullName));
                Type[]   types    = assembly.GetTypes();
                foreach (Type type in types)
                {
                    TypeInfo typeInfo = type.GetTypeInfo();
                    if (typeInfo.IsArray == true)
                    {
                        continue;
                    }
                    if (typeInfo.IsEnum == true)
                    {
                        continue;
                    }
                    if (typeInfo.IsAbstract == true)
                    {
                        continue;
                    }
                    if (typeInfo.IsInterface == true)
                    {
                        continue;
                    }
                    if (typeInfo.IsClass == false)
                    {
                        continue;
                    }
                    if (!commandsetType.IsAssignableFrom(type))
                    {
                        continue;
                    }

                    typeName = type.Name;
                    if (typeName.EndsWith("Commands"))
                    {
                        typeName = typeName.Substring(0, typeName.Length - 8);
                    }
                    typeName = typeName.ToLower();
                    foreach (MethodInfo method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
                    {
                        methodName        = method.Name.ToLower();
                        commandAttributes = method.GetCustomAttributes <CommandAttribute>();
                        foreach (CommandAttribute commandAttribute in commandAttributes)
                        {
                            command = commandAttribute.Name.Trim().ToLower();
                            if (command.Length <= 0)
                            {
                                continue;
                            }
                            commands[command] = new CommandRecord(command, type, method);
                        }
                    }
                }
            }
            return(commands);
        }