def do_history (self, line):
        '''Manage the command history\n'''

        item = parsing_opts.ArgumentPack(['item'],
                                         {"nargs": '?',
                                          'metavar': 'item',
                                          'type': parsing_opts.check_negative,
                                          'help': "an history item index",
                                          'default': 0})

        parser = parsing_opts.gen_parser(self.stateless_client,
                                         "history",
                                         self.do_history.__doc__,
                                         item)

        opts = parser.parse_args(line.split())
        if opts is None:
            return

        if opts.item == 0:
            self.print_history()
        else:
            cmd = self.get_history_item(opts.item)
            if cmd == None:
                return

            print("Executing '{0}'".format(cmd))

            return self.onecmd(cmd)
    def do_tui (self, line):
        '''Shows a graphical console\n'''
        parser = parsing_opts.gen_parser(self.stateless_client,
                                         "tui",
                                         self.do_tui.__doc__,
                                         parsing_opts.XTERM,
                                         parsing_opts.LOCKED)

        opts = parser.parse_args(line.split())

        if not opts:
            return opts
        if opts.xterm:
            if not os.path.exists('/usr/bin/xterm'):
                print(format_text("XTERM does not exists on this machine", 'bold'))
                return

            info = self.stateless_client.get_connection_info()

            exe = './trex-console --top -t -q -s {0} -p {1} --async_port {2}'.format(info['server'], info['sync_port'], info['async_port'])
            cmd = ['/usr/bin/xterm', '-geometry', '{0}x{1}'.format(self.tui.MIN_COLS, self.tui.MIN_ROWS), '-sl', '0', '-title', 'trex_tui', '-e', exe]

            # detach child
            self.terminal = subprocess.Popen(cmd, preexec_fn = os.setpgrp)

            return

        
        try:
            with self.stateless_client.logger.supress():
                self.tui.show(self.stateless_client, self.save_console_history, locked = opts.locked)

        except self.tui.ScreenSizeException as e:
            print(format_text(str(e) + "\n", 'bold'))
Example #3
0
    def do_tui (self, line):
        '''Shows a graphical console\n'''

        parser = parsing_opts.gen_parser(self,
                                         "tui",
                                         self.do_tui.__doc__,
                                         parsing_opts.XTERM)

        opts = parser.parse_args(line.split())
        if opts is None:
            return

        if opts.xterm:

            info = self.stateless_client.get_connection_info()

            exe = './trex-console --top -t -q -s {0} -p {1} --async_port {2}'.format(info['server'], info['sync_port'], info['async_port'])
            cmd = ['xterm', '-geometry', '111x42', '-sl', '0', '-title', 'trex_tui', '-e', exe]
            self.terminal = subprocess.Popen(cmd)

            return


        with self.stateless_client.logger.supress():
            self.tui.show()
Example #4
0
    def do_tui (self, line):
        '''Shows a graphical console\n'''

        parser = parsing_opts.gen_parser(self,
                                         "tui",
                                         self.do_tui.__doc__,
                                         parsing_opts.XTERM)

        opts = parser.parse_args(line.split())
        if opts is None:
            return

        if opts.xterm:
            if not os.path.exists('/usr/bin/xterm'):
                print(format_text("XTERM does not exists on this machine", 'bold'))
                return

            info = self.stateless_client.get_connection_info()

            exe = './trex-console --top -t -q -s {0} -p {1} --async_port {2}'.format(info['server'], info['sync_port'], info['async_port'])
            cmd = ['/usr/bin/xterm', '-geometry', '111x49', '-sl', '0', '-title', 'trex_tui', '-e', exe]

            # detach child
            self.terminal = subprocess.Popen(cmd, preexec_fn = os.setpgrp)

            return


        with self.stateless_client.logger.supress():
            self.tui.show()
Example #5
0
    def do_tui(self, line):
        '''Shows a graphical console\n'''
        parser = parsing_opts.gen_parser(self.stateless_client, "tui",
                                         self.do_tui.__doc__,
                                         parsing_opts.XTERM,
                                         parsing_opts.LOCKED)

        opts = parser.parse_args(line.split())

        if not opts:
            return opts
        if opts.xterm:
            if not os.path.exists('/usr/bin/xterm'):
                print(
                    format_text("XTERM does not exists on this machine",
                                'bold'))
                return

            info = self.stateless_client.get_connection_info()

            exe = './trex-console --top -t -q -s {0} -p {1} --async_port {2}'.format(
                info['server'], info['sync_port'], info['async_port'])
            cmd = [
                '/usr/bin/xterm', '-geometry',
                '{0}x{1}'.format(self.tui.MIN_COLS, self.tui.MIN_ROWS), '-sl',
                '0', '-title', 'trex_tui', '-e', exe
            ]

            # detach child
            self.terminal = subprocess.Popen(cmd, preexec_fn=os.setpgrp)

            return

        try:
            with self.stateless_client.logger.supress():
                self.tui.show(self.stateless_client,
                              self.save_console_history,
                              locked=opts.locked)

        except self.tui.ScreenSizeException as e:
            print(format_text(str(e) + "\n", 'bold'))
Example #6
0
    def __init__ (self, client, cmd_lock):
        self.c          = client
        self.cmd_lock   = cmd_lock
        self.logger     = client.logger
        self.monitor    = None
        
        # install parsers
        
        self.parser = parsing_opts.gen_parser(self, "capture", self.parse_line_internal.__doc__)
        self.subparsers = self.parser.add_subparsers(title = "commands", dest="commands")

        self.install_record_parser()
        self.install_monitor_parser()
        
        # show
        self.show_parser = self.subparsers.add_parser('show', help = "show all active captures")
     
        # reset
        self.clear_parser = self.subparsers.add_parser('clear', help = "remove all active captures")
       
        # register handlers
        self.cmds = {'record': self.parse_record, 'monitor' : self.parse_monitor, 'clear': self.parse_clear, 'show' : self.parse_show} 
Example #7
0
    def do_events(self, line):
        '''shows events recieved from server\n'''

        x = parsing_opts.ArgumentPack(
            ['-c', '--clear'], {
                'action': "store_true",
                'default': False,
                'help': "clear the events log"
            })

        parser = parsing_opts.gen_parser(self, "events",
                                         self.do_events.__doc__, x)

        opts = parser.parse_args(line.split())
        if opts is None:
            return

        events = self.stateless_client.get_events()
        for ev in events:
            print ev

        if opts.clear:
            self.stateless_client.clear_events()
            print format_text("\n\nEvent log was cleared\n\n")
Example #8
0
    def do_events (self, line):
        '''shows events recieved from server\n'''

        x = parsing_opts.ArgumentPack(['-c','--clear'],
                                      {'action' : "store_true",
                                       'default': False,
                                       'help': "clear the events log"})

        parser = parsing_opts.gen_parser(self,
                                         "events",
                                         self.do_events.__doc__,
                                         x)

        opts = parser.parse_args(line.split())
        if opts is None:
            return

        events = self.stateless_client.get_events()
        for ev in events:
            print ev

        if opts.clear:
            self.stateless_client.clear_events()
            print format_text("\n\nEvent log was cleared\n\n")
Example #9
0
    def _load_plugin(self, name):
        plugin = self._get_plugins().get(name)
        if not plugin:
            self.err('Plugin with name "%s" not found.' % name)

        file_name, module_name = plugin
        import_path = 'console.plugins.%s' % module_name

        try:
            m = imp.load_source(import_path, file_name)
        except BaseException as e:
            self.err('Exception during import of %s: %s' % (import_path, e))

        plugin_classes = {}
        for var_name, var in vars(m).items():
            try:
                if var is not ConsolePlugin and issubclass(var, ConsolePlugin):
                    plugin_classes[var_name] = var
            except:
                continue

        if not plugin_classes:
            self.err('Could not find plugins (check inheritance from ConsolePlugin) in file: %s' % file_name)
        if len(plugin_classes) > 1:
            self.err('There are several plugins withing namespace of file %s: %s' % (file_name, list(plugin_classes.keys())))

        try:
            plugin_class = list(plugin_classes.values())[0]
            plugin_class._args = {}
            plugin_class.trex_client = self.stateless_client
            plugin_obj = plugin_class()
        except BaseException as e:
            self.err('Could not initialize the plugin, error: %s' % e)

        try:
            plugin_obj.plugin_load()
        except BaseException as e:
            self.err('Could not run plugin_load() of plugin, error: %s' % e)

        try:
            parser = parsing_opts.gen_parser(self.stateless_client, name, None)
            subparsers = parser.add_subparsers(title = 'commands', dest = 'subparser_command')

            for attr in dir(plugin_obj):
                if attr.startswith('do_'):
                    func = getattr(plugin_obj, attr)
                    if not (hasattr(func, '__code__') and hasattr(func, '__func__')): # check quacking
                        continue
                    descr = func.__doc__
                    if not descr:
                        self.err('Function %s does not have docstring' % attr)

                    arg_count = func.__code__.co_argcount
                    args = func.__code__.co_varnames[:arg_count]
                    if args[0] == 'self':
                        args = args[1:]
                    if not func.__code__.__doc__:
                        return

                    s = subparsers.add_parser(attr[3:], description = descr, help = descr)
                    for arg in args:
                        if arg not in plugin_obj._args:
                            self.err('Argument %s in function %s should be added by add_argument()' % (arg, attr))
                        s.add_argument(*plugin_obj._args[arg]['a'], **plugin_obj._args[arg]['k'])

            self.plugins_subparsers.add_parser(
                name,
                parents = [parser],
                help = plugin_obj.plugin_description(),
                add_help = False)
        except BaseException as e:
            import traceback
            traceback.print_exc()
            self.err('Could not create parser of plugin, error: %s' % e)

        self.loaded_plugins[name] = plugin_obj