def execute(context):
# choose which module(s) to look for command
if context.args.built_in:
modules = [BUILTIN_MODULE]
elif context.args.module:
modules = [context.args.module]
else:
modules = list_modules()
matched_commands = []
for module_name in modules:
commands = load_commands_from_module(module_name)
found_command = commands.get(context.args.command, None)
if found_command:
matched_commands.append(found_command)
if len(matched_commands) == 0:
log.error("Command %s is not found" % context.args.command)
return False
elif len(matched_commands) == 1:
matched_commands[0].show_help()
else:
log.title("Found multiple commands")
log.write("Use suggested argument to show help for specified command only.")
for command in matched_commands:
if command.module_name == BUILTIN_MODULE:
narrow_help = "run with --built-in"
else:
narrow_help = "run with --module=%s" % command.module_name
log.write(" " * 4 + "%-25s%s" % (str(command), narrow_help))
return True
def not_empty(self, arg_name):
arg_value = getattr(self.context.args, arg_name, None)
if arg_value is None:
return
if len(arg_value) == 0:
self.valid = False
log.error("No value specified for [%s]" % arg_name)
def arg_required(self, arg_name):
""" Check that required argument is specified """
if not self.valid: return
attr = getattr(self.context.args, arg_name, None)
if not attr:
self.valid = False
self.show_usage = True
log.error("Argument %s is not specified, but required\n" % arg_name)
def load_py_module(module_name, path):
import imp
try:
return imp.load_source(module_name, path)
except IOError:
# file is not found, log and return None
log.error("module %s is not found" % path)
return None
def any_arg_required(self, *args):
if not self.valid: return
num = 0
for arg in args:
attr = getattr(self.context.args, arg, None)
if attr:
num += 1
if num == 0:
self.valid = False
self.show_usage = True
log.error("At least one of [%s] arguments is required.\n" % ", ".join(args))
def project_path_required(self):
""" Check if project path is specified and it exists """
if not self.valid: return
self.valid = False
if not self.context.project_path:
log.error("project path is not specified")
return
if not os.path.exists(self.context.project_path):
log.error("project path %s is not found" % self.context.project_path)
return
self.valid = True
def no_args_conflicts(self, *args):
""" Check there is not conflicts between arguments """
if not self.valid: return
num = 0
found_args = []
for arg in args:
attr = getattr(self.context.args, arg, None)
if attr:
num += 1
found_args.append(arg)
if num > 1:
self.valid = False
self.show_usage = True
log.error("Found conflict between arguments [%s], which can't be used together.\n" % ", ".join(found_args))
def main():
if len(sys.argv) < 2:
print_help()
sys.exit(-1)
args, command_name, module_name = get_twister_args()
builtin_commands = load_builtin()
if module_name is None:
if not command_name:
log.error("Missing command name. See usage below:")
print_help()
sys.exit(-1)
if command_name not in builtin_commands.keys():
log.error("Unknown command: %s" % command_name)
log.help(("Run " + log.command("find-command %s") + " to find command.") % command_name)
sys.exit(-1)
elif module_name in builtin_commands.keys():
command_name = module_name
module_name = None
args = sys.argv[2:]
command = None
if module_name is None:
command = builtin_commands[command_name]
else:
if module_name not in list_modules():
log.error("Unknown module %s." % module_name)
log.help("Run " + log.command("list-modules") + " to get list of available modules")
sys.exit(-1)
commands = load_commands_from_module(module_name)
if command_name not in commands.keys():
if command_name in builtin_commands.keys():
# interesting hook for built-in commands to allow them use within specified module
command = builtin_commands[command_name]
args.append("--module")
args.append(module_name)
else:
# command not found in module
log.error("Unknown command %s in module %s." % (command_name, module_name))
log.help(("Run " + log.command("%(module)s list-commands") +
" to get list of available commands in module %(module)s.") % dict(module=module_name))
log.help(("Run " + log.command("find-command %s") + " to find command.") % command_name)
sys.exit(-1)
# in case if command already found in built-ins
command = command or commands[command_name]
if not command.validate():
sys.exit(-1)
context = build_command_context(command, args)
if not command.execute(context):
sys.exit(-1)
def execute(context):
command_name = context.args.command
module_name = context.args.module
best_matched_commands = []
matched_module_commands = []
matched_description_commands = []
modules = module.list_modules()
if module_name:
if module_name not in modules:
log.error("Unknown module %s" % module_name)
return False
# module name is specified, find commands in this module only
modules = [module_name]
for module_name in modules:
module_commands = module.load_commands_from_module(module_name)
for module_command_name, command in module_commands.items():
if command_name in module_command_name:
best_matched_commands.append(command)
elif module_name == command_name:
# include all module_commands if module name is
# same as searched command
matched_module_commands.append(command)
elif len(command_name) >= 3 and (command_name in command.get_short_description() or command_name in command.get_help()):
# include command if searched command is mentioned
# in the description
matched_description_commands.append(command)
matched_commands = best_matched_commands + matched_module_commands + matched_description_commands
if not matched_commands:
print "No commands found"
return False
print ("[ Found %d commands ]" % len(matched_commands)).ljust(80, "-")
for command in sorted(best_matched_commands):
show_command_info(command)
for command in sorted(matched_module_commands):
show_command_info(command)
for command in sorted(matched_description_commands):
show_command_info(command)
return True
def execute(
command, output=False, show_command=True, command_title=None, output_on_error=True, error_text=None, checked=True
):
""" executes the command """
if show_command:
if command_title:
title = "~ " + command_title
elif output:
title = command
else:
title = command if len(command) < 70 else command[0:20] + " ... " + command[-20:]
log.title("execute " + title)
if not checked:
return subprocess.call(
command, shell=True, stdout=(None if output else DEVNULL), stderr=(None if output else DEVNULL)
)
if output:
try:
return subprocess.check_call(
command, shell=True, stdout=(None if output else DEVNULL), stderr=(None if output else DEVNULL)
)
except subprocess.CalledProcessError as e:
if error_text:
log.error(error_text)
raise e
try:
subprocess.check_output(command, shell=True)
return 0
except subprocess.CalledProcessError as e:
if output_on_error:
print_failed_command_output(e)
if error_text:
log.error("%s: error code %d. Run with --verbose flag to see more output" % (error_text, e.returncode))
raise e
def find_and_execute(parent_context, module, command, args=()):
module_commands = load_commands_from_module(module)
module_command = module_commands.get(command, None)
if module_command:
cmd_args = list(args)
# add twisted path and project path
cmd_args.append('--use-twisted-path')
cmd_args.append(parent_context.twisted_path)
cmd_args.append('--use-project-path')
cmd_args.append(parent_context.project_path)
# add verbose parameter if need
verbose = getattr(parent_context.args, 'verbose', False)
if verbose: cmd_args.append("--verbose")
context = build_command_context(module_command, cmd_args)
log.title("command %s %s" % (module_command, " ".join(args)))
return module_command.execute(context, show_exec_time=False)
else:
log.error("Command %s %s is not found" % (module, command))
return False
