Ejemplo n.º 1
0
 def test_file_with_missing_final_nl(self):
     input = io.StringIO("print test\nprint test2")
     output = io.StringIO()
     cmd = self.simplecmd(stdin=input, stdout=output)
     cmd.use_rawinput = False
     cmd.cmdloop()
     self.assertMultiLineEqual(output.getvalue(), ("(Cmd) test\n" "(Cmd) test2\n" "(Cmd) "))
Ejemplo n.º 2
0
def main():
    if len(sys.argv) < 2:
        print('Must supply an argument')
        return
    if sys.argv[1] == 'insert':
        filename = sys.argv[2]
        filename = os.path.abspath(filename)
        print('Inserting file:', filename)
        index = Index(INDEX_LOCATION)
        index.insert(filename)
        index.addtag(filename, 'TAGME', '')
        index.writeindex()
    elif sys.argv[1] == 'dump':
        index = Index(INDEX_LOCATION)
        index.dump()
    elif sys.argv[1] == 'dumptag':
        tagname = sys.argv[2]
        index = Index(INDEX_LOCATION)
        index.dumptag(tagname)
    elif sys.argv[1] == 'addtag':
        filename = sys.argv[2]
        filename = os.path.abspath(filename)
        tagname = sys.argv[3]
        if len(sys.argv) > 4:
            value = sys.argv[4]
        else:
            value = ''
        index = Index(INDEX_LOCATION)
        index.addtag(filename, tagname, value)
        index.writeindex()
    elif sys.argv[1] == 'cmd':
        cmd = IndexCommands()
        cmd.cmdloop()
    else:
        print('Unknown option:', sys.argv[1])
Ejemplo n.º 3
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--host', type=str, nargs='?', default='localhost')
    parser.add_argument('--port', type=int, nargs='?', default=8000)
    args =  parser.parse_args()

    cmd = Cmd(args.host, args.port)
    cmd.cmdloop()
Ejemplo n.º 4
0
def main():
    plugins = get_plugins("./plugins")

    name    = "CmCli"

    (cmd, plugin_objects) = DynamicCmd(name, plugins)
    cmd.activate()
    cmd.cmdloop()
Ejemplo n.º 5
0
def main():
    """
    The main routine.
    """
    # Instantiate the app
    app = CmdlineApplication()

    caOption = Option("-C", "--ca", action = "store_true",
                      dest = "is_ca_mode", default = 0,
                      help = "Use CA mode for this invocation of the certificate manager.")
    idOption = Option("-I", "--id", action = "store_false",
                      dest = "is_ca_mode", default = 0,
                      help = "Use ID mode for this invocation of the certificate manager.")

    forceOption = Option("-f", "--force", action = "store_true",
                         dest = "force_overwrite", default = 0,
                         help = "Overwrite existing files.")
    app.AddCmdLineOption(caOption)
    app.AddCmdLineOption(idOption)
    app.AddCmdLineOption(forceOption)

    try:
        args = app.Initialize("CertificateManager")
    except Exception:
        sys.exit(0)

    cmd = CertMgrCmdProcessor(app.GetCertificateManager(), app.GetLog())

    #
    # If no args were passed, start up the command-driver
    # cert mgr.
    #

    if app.GetOption("is_ca_mode"):
        cmd.setCAMode()

    if len(args) == 0:
        
        cmd.cmdloop()

    else:

        #
        # Otherwise, process a single command from teh command line.
        #

        cmd.setInteractive(0)
        cmd.setForceOverwrite(app.GetOption("force_overwrite"))

        mycmd = args[0] + " " + " ".join(map(lambda a: '"' + a + '"', args[1:]))
        print mycmd
        cmd.onecmd(mycmd)
Ejemplo n.º 6
0
 def handleInput(self, char):
     #log.msg('handling %s' % repr(char))
     options = self.options
     if char in ('\n', '\r'):
         self.escapeMode = 1
         self.write(char)
     elif self.escapeMode == 1 and char == options['escape']:
         self.escapeMode = 2
     elif self.escapeMode == 2:
         self.escapeMode = 1 # so we can chain escapes together
         if char == '.': # disconnect
             log.msg('disconnecting from escape')
             stopConnection()
             return
         elif char == '\x1a': # ^Z, suspend
             def _():
                 self.ssh.rawmode.leave()
                 sys.stdout.flush()
                 sys.stdin.flush()
                 os.kill(os.getpid(), signal.SIGTSTP)
                 self.ssh.rawmode.enter()
             reactor.callLater(0, _)
             return
         elif char == 'R': # rekey connection
             log.msg('rekeying connection')
             self.conn.transport.sendKexInit()
             return
         elif char == ':': # enter command mode
             old = self.stdio
             try:
                 self.ssh.rawmode.leave()
                 try:
                     cmd = CmdShell(self)
                     cmd.cmdloop('.oO( sshx )Oo.')
                 except:
                     char = None
                     log.err("cmd.cmdloop() failed")
                 self.ssh.rawmode.enter()
             finally:
                 self.stdio = old
         elif char == '#': # display connections
             self.stdio.write('\r\nThe following connections are open:\r\n')
             channels = self.conn.channels.keys()
             channels.sort()
             for channelId in channels:
                 self.stdio.write('  #%i %s\r\n' % (channelId, str(self.conn.channels[channelId])))
             return
         if char is not None:
             self.write('~' + char)
     else:
         self.escapeMode = 0
         self.write(char)
Ejemplo n.º 7
0
 def do_edit(self, text):
     cmd = None
     if self.binary.type == Type.ELF:
         cmd = ELFConsole(self.binary, self.__cprinter)
     elif self.binary.type == Type.PE:
         cmd = PEConsole(self.binary, self.__cprinter)
     elif self.binary.type == Type.MACH_O:
         cmd = MachOConsole(self.binary, self.__cprinter)
     else:
         self.printError('This type is currently not supported: %s' % self.binary.type)
         return
     if cmd:
         cmd.cmdloop()
Ejemplo n.º 8
0
 def test_input_reset_at_EOF(self):
     input = io.StringIO("print test\nprint test2")
     output = io.StringIO()
     cmd = self.simplecmd2(stdin=input, stdout=output)
     cmd.use_rawinput = False
     cmd.cmdloop()
     self.assertMultiLineEqual(output.getvalue(), ("(Cmd) test\n" "(Cmd) test2\n" "(Cmd) *** Unknown syntax: EOF\n"))
     input = io.StringIO("print \n\n")
     output = io.StringIO()
     cmd.stdin = input
     cmd.stdout = output
     cmd.cmdloop()
     self.assertMultiLineEqual(output.getvalue(), ("(Cmd) \n" "(Cmd) \n" "(Cmd) *** Unknown syntax: EOF\n"))
Ejemplo n.º 9
0
 def test_input_reset_at_EOF(self):
     input = io.StringIO("print test\nprint test2")
     output = io.StringIO()
     cmd = self.simplecmd2(stdin=input, stdout=output)
     cmd.use_rawinput = False
     cmd.cmdloop()
     self.assertMultiLineEqual(output.getvalue(),
         ("(Cmd) test\n"
          "(Cmd) test2\n"
          "(Cmd) *** Unknown syntax: EOF\n"))
     input = io.StringIO("print \n\n")
     output = io.StringIO()
     cmd.stdin = input
     cmd.stdout = output
     cmd.cmdloop()
     self.assertMultiLineEqual(output.getvalue(),
         ("(Cmd) \n"
          "(Cmd) \n"
          "(Cmd) *** Unknown syntax: EOF\n"))
Ejemplo n.º 10
0
def main():
  """
  
  """

  try:
    opts, args = getopt.getopt(sys.argv[1:],
                                "hif:",
                                ["help", "interactive", "file="])
  except getopt.GetoptError:
    usage()
    sys.exit(2)
  script_file = None
  interactive = False
  for option, argument in opts:
    if option in ("-h", "--help"):
      usage()
      sys.exit()
    if option in ("-f", "--file"):
      script_file = argument
    if option in ("-i", "--interactive"):
      interactive = True

  plugin_path = os.path.join(os.path.dirname(__file__),'plugins')

  plugins = get_plugins(plugin_path)

  name    = "CmCli"
  
  (cmd, plugin_objects) = DynamicCmd(name, plugins)
  cmd.version()
  cmd.activate()
  cmd.do_exec(script_file)

  if is_subcmd(opts, args):
    try:
      user_cmd = " ".join(args)
      print ">", user_cmd
      cmd.onecmd(user_cmd)
    except:
      print "'%s' is not recognized" % user_cmd
  elif not script_file or interactive:
    cmd.cmdloop()
Ejemplo n.º 11
0
def main():
    """
    Fonction de main pour le serveur
    """
    
    # parsage des arguments de la ligne de commande
    args = ServerArgumentParser().parse_args()

    # mise a jour du port d'envoi
    config.server.send_port = args.port
    
    print __description__

    # # ajout de la version du fs en override si présent
    # if not args.version is None:
    #     setattr(config.server, "fsversion", args.version)
    
    cmd = ServerCmd()

    # vérification de la présence du dossier de données et création
    if not os.path.exists(config.server.save_dir):
        try:
            os.mkdir(config.server.save_dir)
        except e:
            print "error: impossible de créer le dossier de données, sortie ..."; return 1

    # lancement en mode interactif (Shell)
    if args.shell:
        cmd.cmdloop()
    # lancement non interactif
    else:
        # renseignement du test à lancer
        if not args.bench_test is None:
            print ">> Lancement du benchmark '%s'" % args.bench_test

            cmd.onecmd('run ' + args.bench_test)
        else:
            print "error: aucun benchmark renseigné (à choisir dans la liste des \
                fichiers de 'config/tests/'"; return 1
            
    return 0
Ejemplo n.º 12
0
def main():
    parser = argparse.ArgumentParser(description='FIX Gateway')
    parser.add_argument('--debug', action='store_true',
                        help='Run in debug mode')
    parser.add_argument('--host', '-H', default='localhost',
                        help="IP address or hostname of the FIX-Gateway Server")
    parser.add_argument('--port', '-P', type=int, default=3490,
                        help="Port number to use for FIX-Gateway Server connection")
    parser.add_argument('--prompt', '-p', default='FIX: ',
                        help="Command line prompt")
    parser.add_argument('--file', '-f', nargs=1, metavar='FILENAME',
                        help="Execute commands within file")
    parser.add_argument('--execute','-x', nargs='+', help='Execute command')
    parser.add_argument('--interactive', '-i', action='store_true',
                        help='Keep running after commands are executed')
    args, unknown_args = parser.parse_known_args()
    log = logging.getLogger()
    if args.debug:
        log.level = logging.DEBUG

    c = netfix.Client(args.host, args.port)
    c.connect()

    cmd = Command(c)
    # If commands are beign redirected or piped we set the prompt to nothing
    if sys.stdin.isatty():
        cmd.prompt = args.prompt
    else:
        cmd.prompt = ""
    if args.execute:
        s = " ".join(args.execute)
        cmd.onecmd(s)
        if not args.interactive:
            exit(0)
    cmd.cmdloop()

    c.disconnect()
Ejemplo n.º 13
0
def run_interactive(cmd):
    logger.info('run_interactive()')
    cmd.cmdloop()
    return 0
Ejemplo n.º 14
0
def main():
    """
    OnTalk OnConsole.
    Usage: 
      onconsole [-q] help
      onconsole [-v] [-b] [--file=SCRIPT] [-i] [COMMAND ...]
    Arguments:
      COMMAND                  A command to be executed
    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      -b                 surpress the printing of the banner [default: False]
    """

    echo = False

    try:
        arguments = docopt(main.__doc__, help=True)
        if arguments['help']:
            arguments['COMMAND'] = ['help']
            arguments['help'] = 'False'

        script_file = arguments['--file']
        interactive = arguments['-i']
        echo = arguments['-v']
        if echo:
            pprint(arguments)
        print(arguments)

    except:
        script_file = None
        interactive = False

        arguments = {'-b': True,
                     'COMMAND': [' '.join(sys.argv[1:])]}

    cmd.Cmd.set_verbose(echo)
    cmd.Cmd.activate()
    cmd.set_verbose(echo)

    cmd.set_debug(properties["debug"])

    if arguments['-b']:
        cmd.set_banner("")
    if script_file is not None:
        cmd.do_exec(script_file)

    if len(arguments['COMMAND']) > 0:
        try:            
            user_cmd = " ".join(arguments['COMMAND'])
            if echo:
                print(">", user_cmd)
            cmd.onecmd(user_cmd)
        except Exception, e:
            Console.error("")
            Console.error("ERROR: executing command '{0}'".format(user_cmd))
            Console.error("")
            print (70 * "=")
            print(e)
            print (70 * "=")
            print(traceback.format_exc())

        if interactive:
            cmd.cmdloop()
Ejemplo n.º 15
0
def main(options, args):
    cmd = qacmd(options)
    cmd.cmdloop()
Ejemplo n.º 16
0
    def run(cls, *modules, **karg):
        "start interactive mode."
        #logging.basicConfig()
        global history_file, preference_file, pref, log
        from os import environ as ENV
        fqcn = cls.__name__
        argv = karg.get('argv', sys.argv)
        last_history = karg.get('last_history')
        sn = cn = str(fqcn).split('.')[-1]
        pos = fqcn.rfind('.')
        mn = fqcn[0:pos] if pos > 0 else '__main__'
        mod = __import__(mn)

        global verbose, interactive
        if 'DEBUG' in ENV: verbose = True
        if verbose: print("argv: %s" % " ".join(argv), file=sys.stderr)
		
        preference_name = os.path.expanduser('~/.%s/%s' % (appname, cn))

        opts, args = getopt(argv[1:], 'vp:D:', (
            'verbose', 'define=', 'preference=',
        ))

        defs = []

        for opt, optarg in opts:
            if opt in ('-v', '--verbose'): verbose = True
            elif opt in ('-D', '--define'):
                key, value = optarg.split('=')
                defs.append((key, value))
            elif opt in ('-p', '--preference'):
                preference_name = optarg
                pt = optarg.find(':')
                if pt > 0:
                    preference_name = optarg[:pt]
                    sn = optarg[pt+1:]
                verbose = True

        pref = INIPreference(preference_name)
        try: pref.load()
        except: pass

        pref.set_section(sn)

        for key, value in defs:
            pref.store(key, value)

        if last_history: save_history(last_history)

        home = os.path.expanduser('~')
        history_file = pref.value('history-file', os.path.join(home, 'logs', '%s.history' % cn))
        if os.path.exists(history_file): load_history()

        if verbose:
            pref.store('console-log-level', 'DEBUG')

        log = get_logger(cn, pref=pref)
        mod.pref = pref
        mod.log = log

        cmd = cls()
        cmd.pref = pref

        for mod in modules:
            mod.pref = pref
            mod.log = log

        c0 = os.path.basename(argv[0])
        if '-' in c0 and not c0.endswith('.py'):
            subcmd = c0[c0.find('-')+1:]
            args.insert(0, subcmd)
            
        if args:
            line = _arg_join(args)
            if verbose: puts('args', args, file=err)
            interactive = False
            try:
                rc = cmd.onecmd(line)
            except Exception as e:
                rc = 3
                elog = log.exception if verbose else log.error
                elog('%s while execute\n %s', e, line)
            except KeyboardInterrupt:
                rc = 4
                syserr.write('Interrupted.\n')

            if verbose: puts('rc: ', rc, file=err)
            if last_history:
                # カスケード呼び出しされている
                history_file = last_history
                if os.path.exists(history_file): load_history()
                return rc
            sys.exit(rc)

        interactive = True
        while True:
            try:
                cmd.cmdloop()
                save_history()
                if last_history:
                    if os.path.exists(last_history): load_history(last_history)
                    history_file = last_history
                pref.save()
                break
            except KeyboardInterrupt as e:
                # 割り込みをかけても中断させない
                if verbose:
                    log.exception('%s while cmdloop', e)
                else:
                    syserr.write('Interrupted.\n')
Ejemplo n.º 17
0
       def activate_status(self):
           print "Active:", self.active

       def activate(self, plugins):
           d = dir(self)
           result = []
           for key in d:
               if key.startswith("activate_"):
                   result.append(key)
           print result
           for key in result:
               print "> %s" % key.replace("_"," ")
               exec("self.%s()" % key)
"""

import sys
import cmd
import readline

from cyberaide import load_plugins
from cyberaide import make_cmd_class
from cyberaide import DynamicCmd

plugins = ["foo", "bar","activate"]
name    = "CmCli"

(cmd, plugin_objects) = DynamicCmd(name, plugins)
cmd.activate(plugin_objects)
cmd.cmdloop()
Ejemplo n.º 18
0
            return

        if (len(new_line) == 2):
            if (new_line[1] in lst_cmd2 and new_line[0] in cls_lst):
                if (new_line[1] == 'all'):
                    HBNBCommand.do_all(self, new_line[0])
                    return

                if (new_line[1] == 'create'):
                    HBNBCommand.do_create(self, new_line[0])
                    return

                if (new_line[1] == 'count'):
                    HBNBCommand.do_count(self, new_line[0])
                    return

        if (len(new_line) == 3):
            if (new_line[1] in lst_cmd3 and new_line[0] in cls_lst):
                if (new_line[1] == 'show'):
                    HBNBCommand.do_show(self, new_line[0] + " " + new_line[2])
                if (new_line[1] == 'destroy'):
                    HBNBCommand.do_destroy(self,
                                           new_line[0] + " " + new_line[2])
            return


if __name__ == '__main__':
    cmd = HBNBCommand()
    cmd.prompt = '(hbnb) '
    cmd.cmdloop()
Ejemplo n.º 19
0
def main():
    """
    OnTalk OnConsole.
    Usage: 
      onconsole [-q] help
      onconsole [-v] [-b] [--file=SCRIPT] [-i] [COMMAND ...]
    Arguments:
      COMMAND                  A command to be executed
    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      -b                 surpress the printing of the banner [default: False]
    """

    echo = False

    try:
        arguments = docopt(main.__doc__, help=True)
        if arguments['help']:
            arguments['COMMAND'] = ['help']
            arguments['help'] = 'False'

        script_file = arguments['--file']
        interactive = arguments['-i']
        echo = arguments['-v']
        if echo:
            pprint(arguments)
        print(arguments)

    except:
        script_file = None
        interactive = False

        arguments = {'-b': True, 'COMMAND': [' '.join(sys.argv[1:])]}

    cmd.Cmd.set_verbose(echo)
    cmd.Cmd.activate()
    cmd.set_verbose(echo)

    cmd.set_debug(properties["debug"])

    if arguments['-b']:
        cmd.set_banner("")
    if script_file is not None:
        cmd.do_exec(script_file)

    if len(arguments['COMMAND']) > 0:
        try:
            user_cmd = " ".join(arguments['COMMAND'])
            if echo:
                print(">", user_cmd)
            cmd.onecmd(user_cmd)
        except Exception, e:
            Console.error("")
            Console.error("ERROR: executing command '{0}'".format(user_cmd))
            Console.error("")
            print(70 * "=")
            print(e)
            print(70 * "=")
            print(traceback.format_exc())

        if interactive:
            cmd.cmdloop()
Ejemplo n.º 20
0
def main():
    """cm.

    Usage:
      cm [--file=SCRIPT] [--interactive] [--quiet] [COMMAND ...]
      cm [-f SCRIPT] [-i] [-q] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT -f SCRIPT  Executes the scipt
      --interactive -i         After start keep the shell interactive, otherwise quit
      --quiet       -q         Surpress some of the informational messages.
    """

    #    __version__ = pkg_resources.require("cmd3")[0].version
    #arguments = docopt(main.__doc__, help=True, version=__version__)

    arguments = docopt(main.__doc__, help=True)

    script_file = arguments['--file']
    interactive = arguments['--interactive']
    quiet = arguments['--quiet']

    def get_plugins_from_dir(dir_path, classbase):
        """dir_path/classbase/plugins"""

        if dir_path == "sys":
            dir_path = os.path.abspath(
                os.path.join(os.path.dirname(__file__), 'plugins'))
            dir_plugins = get_plugins(dir_path)
            return {"dir": dir_path, "plugins": dir_plugins, "class": classbase}

        if dir_path == ".":
            dir_path = os.path.expanduser(
                os.path.expandvars(os.path.join(os.getcwd(), 'plugins')))
            dir_plugins = get_plugins(dir_path)
            return {"dir": dir_path, "plugins": dir_plugins, "class": classbase}
        else:

            dir_path = os.path.expanduser(os.path.expandvars(dir_path))
            prefix = "{0}/{1}".format(dir_path, classbase)

            user_path = "{0}/plugins".format(prefix)

            create_dir(user_path)
            create_file("{0}/__init__.py".format(prefix))
            create_file("{0}/plugins/__init__.py".format(prefix))
            sys.path.append(os.path.expanduser(dir_path))
            dir_plugins = get_plugins(user_path)
            return {"dir": dir_path, "plugins": dir_plugins, "class": classbase}

    plugins = []
    plugins.append(dict(get_plugins_from_dir("sys", "cmd3")))
    plugins.append(dict(get_plugins_from_dir("~/.futuregrid", "cmd3local")))
    #plugins.append(dict(get_plugins_from_dir (".", "dot")))

    for plugin in plugins:
        sys.path.append(os.path.expanduser(plugin['dir']))
    sys.path.append("../..")
    sys.path.append(".")
    sys.path.append("..")

    for plugin in plugins:
        plugin['class'] = plugin['class'] + ".plugins"

    pprint(plugins)
    pprint(sys.path)

    # sys.exit()
    name = "CmCli"

    #
    # not yet quite what i want, but falling back to a flatt array
    #

    (cmd, plugin_objects) = DynamicCmd(name, plugins)

    cmd.version()
    # cmd.set_verbose(quiet)
    cmd.activate()
    cmd.do_exec(script_file)

    if len(arguments['COMMAND']) > 0:
        try:
            user_cmd = " ".join(arguments['COMMAND'])
            print ">", user_cmd
            cmd.onecmd(user_cmd)
        except:
            print "'%s' is not recognized" % user_cmd
    elif not script_file or interactive:
        cmd.cmdloop()
Ejemplo n.º 21
0
def start_cli(ctrl):
    cmd = CLI()
    cmd.set_controller(ctrl)
    cmd.cmdloop()
    ctrl.teardown()
Ejemplo n.º 22
0
def main():
    """cm.

    Usage:
      cm --help
      cm [--echo] [--debug] [--nosplash] [-i] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      --nosplash    do not show the banner [default: False]
    """

    def manual():
        print(main.__doc__)

    args = sys.argv[1:]

    arguments = {
        '--echo': '--echo' in args,
        '--help': '--help' in args,
        '--debug': '--debug' in args,
        '--nosplash': '--nosplash' in args,
        '-i': '-i' in args}

    echo = arguments["--echo"]
    if arguments['--help']:
        manual()
        sys.exit()

    for a in args:
        if a in arguments:
            args.remove(a)

    arguments['COMMAND'] = [' '.join(args)]

    commands = arguments["COMMAND"]
    if len(commands) > 0:
        if ".cm" in commands[0]:
            arguments["SCRIPT"] = commands[0]
            commands = commands[1:]
        else:
            arguments["SCRIPT"] = None

        arguments["COMMAND"] = ' '.join(commands)
        if arguments["COMMAND"] == '':
            arguments["COMMAND"] = None

    # noinspection PySimplifyBooleanCheck
    if arguments['COMMAND'] == []:
        arguments['COMMAND'] = None

    splash = not arguments['--nosplash']
    debug = arguments['--debug']
    interactive = arguments['-i']
    script = arguments["SCRIPT"]
    command = arguments["COMMAND"]

    context = CloudmeshContext(
        interactive=interactive,
        debug=debug,
        echo=echo,
        splash=splash)
    cmd = CloudmeshConsole(context)

    if script is not None:
        cmd.do_exec(script)

    try:
        if echo:
            print("cm>", command)
        if command is not None:
            cmd.precmd(command)
            stop = cmd.onecmd(command)
            cmd.postcmd(stop, command)
    except Exception as e:
        print("ERROR: executing command '{0}'".format(command))
        print(70 * "=")
        print(e)
        print(70 * "=")
        Error.traceback()

    if interactive or (command is None and script is None):
        cmd.cmdloop()
Ejemplo n.º 23
0
def main():
    """cm.

    Usage:
      cm [-q] help
      cm [-v] [-b] [--file=SCRIPT] [-i] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      -b                 surpress the printing of the banner [default: False]
    """

    #    __version__ = pkg_resources.require("cmd3")[0].version
    # arguments = docopt(main.__doc__, help=True, version=__version__)

    echo = False

    try:
        arguments = docopt(main.__doc__, help=True)
        # fixing the help parameter parsing
        if arguments['help']:
            arguments['COMMAND'] = ['help']
            arguments['help'] = 'False'

        script_file = arguments['--file']
        interactive = arguments['-i']
        echo = arguments['-v']
        if echo:
            pprint(arguments)

    except:
        script_file = None
        interactive = False

        arguments = {}
        arguments['-b'] = True
        arguments['COMMAND'] = [' '.join(sys.argv[1:])]

    plugins = []

    plugins.append(dict(get_plugins_from_dir("sys", "cmd3")))
    # plugins.append(dict(get_plugins_from_dir("~/.cloudmesh", "cmd3local")))

    modules = [
        'cloudmesh_cmd3.plugins', 'cloudmesh_docker.plugins',
        'cloudmesh_slurm.plugins', 'cloudmesh_deploy.plugins'
    ]
    for module_name in modules:
        # print "INSTALL", module_name
        try:
            plugins.append(dict(get_plugins_from_module(module_name)))
        except:
            #print "WARNING: could not find", module_name
            pass

    #sys.exit()
    #plugins.append(dict(get_plugins_from_dir("~/.cloudmesh", "cmd3local")))

    # plugins.append(dict(get_plugins_from_dir (".", "dot")))

    for plugin in plugins:
        sys.path.append(os.path.expanduser(plugin['dir']))
    sys.path.append("../..")
    sys.path.append(".")
    sys.path.append("..")

    for plugin in plugins:
        plugin['class'] = plugin['class'] + ".plugins"

    # pprint(plugins)
    # pprint(sys.path)

    # sys.exit()
    name = "CmCli"

    #
    # not yet quite what i want, but falling back to a flatt array
    #

    (cmd, plugin_objects) = DynamicCmd(name, plugins)

    cmd.get_version()
    cmd.set_verbose(echo)
    cmd.activate()
    cmd.set_verbose(echo)

    if arguments['-b']:
        cmd.set_banner("")
    if script_file is not None:
        cmd.do_exec(script_file)

    if len(arguments['COMMAND']) > 0:
        try:
            user_cmd = " ".join(arguments['COMMAND'])
            if echo:
                print(">", user_cmd)
            cmd.onecmd(user_cmd)
        except Exception, e:
            print()
            print("ERROR: executing command '{0}'".format(user_cmd))
            print()
            print(e)
            print(traceback.format_exc())
        if interactive:
            cmd.cmdloop()
Ejemplo n.º 24
0
def main():
    """cm.

    Usage:
      cm [-q] help
      cm [-v] [-b] [--file=SCRIPT] [-i] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      -b                 surpress the printing of the banner [default: False]
    """

    #    __version__ = pkg_resources.require("cmd3")[0].version
    # arguments = docopt(main.__doc__, help=True, version=__version__)

    arguments = docopt(main.__doc__, help=True)

    # fixing the help parameter parsing
    if arguments['help']:
        arguments['COMMAND'] = ['help']
        arguments['help'] = 'False'

    script_file = arguments['--file']
    interactive = arguments['-i']
    echo = arguments['-v']
    if echo:
        print(arguments)
        
    
    plugins = []

    plugins.append(dict(get_plugins_from_dir("sys", "cmd3")))
    # plugins.append(dict(get_plugins_from_dir("~/.cloudmesh", "cmd3local")))


    modules = ['cloudmesh_cmd3.plugins',
               'cloudmesh_docker.plugins',
               'cloudmesh_slurm.plugins']
    for module_name in modules:
        # print "INSTALL", module_name
        try:
            plugins.append(dict(get_plugins_from_module(module_name)))
        except:
            #print "WARNING: could not find", module_name
            pass

    
    #sys.exit()    
    #plugins.append(dict(get_plugins_from_dir("~/.cloudmesh", "cmd3local")))    
    
    # plugins.append(dict(get_plugins_from_dir (".", "dot")))


    for plugin in plugins:
        sys.path.append(os.path.expanduser(plugin['dir']))
    sys.path.append("../..")
    sys.path.append(".")
    sys.path.append("..")

    for plugin in plugins:
        plugin['class'] = plugin['class'] + ".plugins"

    # pprint(plugins)
    # pprint(sys.path)

    # sys.exit()
    name = "CmCli"

    #
    # not yet quite what i want, but falling back to a flatt array
    #

    (cmd, plugin_objects) = DynamicCmd(name, plugins)

    cmd.get_version()
    cmd.set_verbose(echo)
    cmd.activate()
    cmd.set_verbose(echo)

    if arguments['-b']:
        cmd.set_banner("")
    if script_file is not None:
        cmd.do_exec(script_file)

    if len(arguments['COMMAND']) > 0:
        try:            
            user_cmd = " ".join(arguments['COMMAND'])
            if echo:
                print(">", user_cmd)
            cmd.onecmd(user_cmd)
        except Exception, e:
            print()
            print("ERROR: executing command '{0}'".format(user_cmd))
            print()
            print(e)
            print(traceback.format_exc())
        if interactive:
            cmd.cmdloop()
Ejemplo n.º 25
0
def main():
    """
    The main routine.
    """
    # Instantiate the app
    app = CmdlineApplication()

    caOption = Option(
        "-C",
        "--ca",
        action="store_true",
        dest="is_ca_mode",
        default=0,
        help="Use CA mode for this invocation of the certificate manager.")
    idOption = Option(
        "-I",
        "--id",
        action="store_false",
        dest="is_ca_mode",
        default=0,
        help="Use ID mode for this invocation of the certificate manager.")

    forceOption = Option("-f",
                         "--force",
                         action="store_true",
                         dest="force_overwrite",
                         default=0,
                         help="Overwrite existing files.")
    app.AddCmdLineOption(caOption)
    app.AddCmdLineOption(idOption)
    app.AddCmdLineOption(forceOption)

    try:
        args = app.Initialize("CertificateManager")
    except Exception:
        sys.exit(0)

    cmd = CertMgrCmdProcessor(app.GetCertificateManager(), app.GetLog())

    #
    # If no args were passed, start up the command-driver
    # cert mgr.
    #

    if app.GetOption("is_ca_mode"):
        cmd.setCAMode()

    if len(args) == 0:

        cmd.cmdloop()

    else:

        #
        # Otherwise, process a single command from teh command line.
        #

        cmd.setInteractive(0)
        cmd.setForceOverwrite(app.GetOption("force_overwrite"))

        mycmd = args[0] + " " + " ".join(map(lambda a: '"' + a + '"',
                                             args[1:]))
        print mycmd
        cmd.onecmd(mycmd)
Ejemplo n.º 26
0
def main():
    """cm.

    Usage:
      cm [-q] help
      cm [-v] [-b] [--file=SCRIPT] [-i] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      -b                 surpress the printing of the banner [default: False]
    """

    echo = False

    try:
        arguments = docopt(main.__doc__, help=True)
        # fixing the help parameter parsing
        if arguments['help']:
            arguments['COMMAND'] = ['help']
            arguments['help'] = 'False'

        script_file = arguments['--file']
        interactive = arguments['-i']
        echo = arguments['-v']
        if echo:
            pprint(arguments)

    except:
        script_file = None
        interactive = False

        arguments = {'-b': True, 'COMMAND': [' '.join(sys.argv[1:])]}

    plugins = []

    plugins.append(dict(get_plugins_from_dir("sys", "cmd3")))
    # plugins.append(dict(get_plugins_from_dir("~/.cloudmesh", "cmd3local")))

    # if not os.path.exists(path_expand( "~/.cloudmesh/cmd3.yaml")):
    #     from cmd3.plugins.shell_core import create_cmd3_yaml_file
    #     create_cmd3_yaml_file()

    create_cmd3_yaml_file(force=False, verbose=False)
    filename = path_expand("~/.cloudmesh/cmd3.yaml")
    try:
        module_config = ConfigDict(filename=filename)
        modules = module_config["cmd3"]["modules"]
        properties = module_config["cmd3"]["properties"]
    except:
        modules = ['cloudmesh_cmd3.plugins']
    for module_name in modules:
        #print ("INSTALL", module_name)
        try:
            plugins.append(dict(get_plugins_from_module(module_name)))
        except:
            # print("WARNING: could not find", module_name)
            pass

    # sys.exit()
    # plugins.append(dict(get_plugins_from_dir("~/.cloudmesh", "cmd3local")))

    # plugins.append(dict(get_plugins_from_dir (".", "dot")))

    for plugin in plugins:
        sys.path.append(os.path.expanduser(plugin['dir']))
    sys.path.append("../..")
    sys.path.append(".")
    sys.path.append("..")

    for plugin in plugins:
        plugin['class'] += ".plugins"

    # pprint(plugins)
    # pprint(sys.path)

    # sys.exit()
    name = "CmCli"

    #
    # not yet quite what i want, but falling back to a flatt array
    #

    (cmd, plugin_objects) = DynamicCmd(name, plugins)

    cmd.set_verbose(echo)
    cmd.activate()
    cmd.set_verbose(echo)

    cmd.set_debug(properties["debug"])

    if arguments['-b']:
        cmd.set_banner("")
    if script_file is not None:
        cmd.do_exec(script_file)

    if len(arguments['COMMAND']) > 0:
        try:
            user_cmd = " ".join(arguments['COMMAND'])
            if echo:
                print(">", user_cmd)
            cmd.onecmd(user_cmd)
        except Exception as e:
            Console.error("")
            Console.error("ERROR: executing command '{0}'".format(user_cmd))
            Console.error("")
            print(70 * "=")
            print(e)
            print(70 * "=")
            print(traceback.format_exc())

        if interactive:
            cmd.cmdloop()

    elif not script_file or interactive:
        cmd.cmdloop()
Ejemplo n.º 27
0
import sys


class Command(cmd.Cmd):
    prompt = 'What do you do? '

    def do_d(self, args):
        "Roll dice. Usage: 'd <nb>'"
        nb = int(args)
        rolls = [random.randint(1, 6) for x in xrange(nb)]
        successes = sum(1 for roll in rolls if roll >= 4)
        print "Rolls:", rolls
        print "Success: %d" % successes

    def do_quit(self, args):
        "Simply exits"
        print
        print "Bye"
        sys.exit()

    do_EOF = do_quit
    do_exit = do_quit


if __name__ == '__main__':
    cmd = Command()
    try:
        cmd.cmdloop('Please...')
    except KeyboardInterrupt, e:
        sys.exit('\nbye')
Ejemplo n.º 28
0
def main():
    """cm.

    Usage:
      cm --help
      cm [--echo] [--debug] [--nosplash] [-i] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      --nosplash    do not show the banner [default: False]
    """
    def manual():
        print(main.__doc__)

    args = sys.argv[1:]

    arguments = {
        '--echo': '--echo' in args,
        '--help': '--help' in args,
        '--debug': '--debug' in args,
        '--nosplash': '--nosplash' in args,
        '-i': '-i' in args
    }

    echo = arguments["--echo"]
    if arguments['--help']:
        manual()
        sys.exit()

    for a in args:
        if a in arguments:
            args.remove(a)

    arguments['COMMAND'] = [' '.join(args)]

    commands = arguments["COMMAND"]
    if len(commands) > 0:
        if ".cm" in commands[0]:
            arguments["SCRIPT"] = commands[0]
            commands = commands[1:]
        else:
            arguments["SCRIPT"] = None

        arguments["COMMAND"] = ' '.join(commands)
        if arguments["COMMAND"] == '':
            arguments["COMMAND"] = None

    # noinspection PySimplifyBooleanCheck
    if arguments['COMMAND'] == []:
        arguments['COMMAND'] = None

    splash = not arguments['--nosplash']
    debug = arguments['--debug']
    interactive = arguments['-i']
    script = arguments["SCRIPT"]
    command = arguments["COMMAND"]

    context = CloudmeshContext(interactive=interactive,
                               debug=debug,
                               echo=echo,
                               splash=splash)
    cmd = CloudmeshConsole(context)

    if script is not None:
        cmd.do_exec(script)

    try:
        if echo:
            print("cm>", command)
        if command is not None:
            cmd.precmd(command)
            stop = cmd.onecmd(command)
            cmd.postcmd(stop, command)
    except Exception as e:
        print("ERROR: executing command '{0}'".format(command))
        print(70 * "=")
        print(e)
        print(70 * "=")
        Error.traceback()

    if interactive or (command is None and script is None):
        cmd.cmdloop()
Ejemplo n.º 29
0
def main():
    """cm.

    Usage:
      cm --help
      cm [--debug] [--nosplash] [--file=SCRIPT] [-i] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      --nosplash    do not show the banner [default: False]
    """

    try:
        arg = docopt(main.__doc__, help=True)
        if arg['--help']:
            print(main.__doc__)
            sys.exit()

        # fixing the help parameter parsing

        #   arguments['COMMAND'] = ['help']
        #   arguments['help'] = 'False'

        script_file = arg['--file']

    except:
        script_file = None
        interactive = False

        arguments = sys.argv[1:]
        arg = {
            '--debug': '--debug' in arguments,
            '--nosplash': '--nosplash' in arguments,
            '-i': '-i' in arguments}

        for a in arg:
            if arg[a]:
                arguments.remove(a)

        arg['COMMAND'] = [' '.join(arguments)]

    splash = not arg['--nosplash']
    debug = arg['--debug']
    interactive = arg['-i']


    context = CloudmeshContext(debug=debug,
                               splash=splash)
    cmd = CloudmeshConsole(context)


    if len(arg['COMMAND']) > 0:
        try:
            user_cmd = " ".join(arg['COMMAND'])
            if debug:
                print(">", user_cmd)
            cmd.onecmd(user_cmd)
        except Exception, e:
            print("ERROR: executing command '{0}'".format(user_cmd))
            print(70 * "=")
            print(e)
            print(70 * "=")
            print(traceback.format_exc())

        if interactive:
            cmd.cmdloop()
Ejemplo n.º 30
0
def main():
    """cm.

    Usage:
      cm --help
      cm [--debug] [--nosplash] [--file=SCRIPT] [-i] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      --nosplash    do not show the banner [default: False]
    """

    try:
        arg = docopt(main.__doc__, help=True)
        if arg['--help']:
            print(main.__doc__)
            sys.exit()

        # fixing the help parameter parsing

        #   arguments['COMMAND'] = ['help']
        #   arguments['help'] = 'False'

        script_file = arg['--file']

    except:
        script_file = None
        interactive = False

        arguments = sys.argv[1:]
        arg = {
            '--debug': '--debug' in arguments,
            '--nosplash': '--nosplash' in arguments,
            '-i': '-i' in arguments}

        for a in arg:
            if arg[a]:
                arguments.remove(a)

        arg['COMMAND'] = [' '.join(arguments)]

    splash = not arg['--nosplash']
    debug = arg['--debug']
    interactive = arg['-i']

    context = CloudmeshContext(debug=debug,
                               splash=splash)
    cmd = CloudmeshConsole(context)

    # TODO: check if cludmesh_yaml exists and if not create it
    # also creat .cloudmesh dir if it not exists
    """
    from cloudmesh_client.common import cloudmesh_yaml

    create_cmd3_yaml_file(force=False, verbose=False)

    filename = cloudmesh_yaml
    try:
        module_config = ConfigDict(filename=filename)
        modules = module_config["cmd3"]["modules"]
        properties = module_config["cmd3"]["properties"]
    except:
        modules = ['cloudmesh_cmd3.plugins']
    for module_name in modules:
        #print ("INSTALL", module_name)
        try:
            plugins.append(dict(get_plugins_from_module(module_name)))
        except:
            # print "WARNING: could not find", module_name
            pass

    """

    # if script_file is not None:
    #     cmd.do_exec(script_file)

    if len(arg['COMMAND']) > 0:
        user_cmd = None
        try:
            user_cmd = " ".join(arg['COMMAND'])
            if debug:
                print(">", user_cmd)
            cmd.onecmd(user_cmd)
        except Exception as e:
            print("ERROR: executing command '{0}'".format(user_cmd))
            print(70 * "=")
            print(e)
            print(70 * "=")
            Error.traceback()

        if interactive:
            cmd.cmdloop()

    elif not script_file or interactive:
        cmd.cmdloop()
Ejemplo n.º 31
0
    def execute(self):
        Env.RTestInstance = self
        if self.args.env_only:
            Defaults.verbose = 2
            env = Env(testName='manual test env')
            if self.args.interactive_debugger:
                while env.isUp():
                    time.sleep(1)
            else:
                cmd = MyCmd(env)
                cmd.cmdloop()
            env.stop()
            return
        done = 0
        startTime = time.time()
        if self.args.interactive_debugger and len(self.loader.tests) != 1:
            print(self.tests)
            print(
                Colors.Bred(
                    'only one test can be run on interactive-debugger use -t'))
            sys.exit(1)

        jobs = Queue()
        for test in self.loader:
            jobs.put(test, block=False)

        def run_jobs(jobs, results, port):
            Defaults.port = port
            done = 0
            while True:
                try:
                    test = jobs.get(timeout=0.1)
                except Exception as e:
                    break

                with self.envScopeGuard():
                    if test.is_class:
                        test.initialize()

                        Defaults.curr_test_name = test.name
                        try:
                            obj = test.create_instance()

                        except unittest.SkipTest:
                            self.printSkip(test.name)
                            continue

                        except Exception as e:
                            self.printException(e)
                            self.addFailure(test.name + " [__init__]")
                            continue

                        failures = 0
                        before = getattr(obj, 'setUp', None)
                        after = getattr(obj, 'tearDown', None)
                        for subtest in test.get_functions(obj):
                            failures += self._runTest(
                                subtest,
                                prefix='\t',
                                numberOfAssertionFailed=failures,
                                before=before,
                                after=after)
                            done += 1

                    else:
                        self._runTest(test)
                        done += 1
            self.takeEnvDown(fullShutDown=True)

            # serialized the results back
            results.put({
                'done': done,
                'failures': self.testsFailed
            },
                        block=False)

        results = Queue()
        if self.parallelism == 1:
            run_jobs(jobs, results, Defaults.port)
        else:
            processes = []
            currPort = Defaults.port
            for i in range(self.parallelism):
                p = Process(target=run_jobs, args=(jobs, results, currPort))
                currPort += 30  # safe distance for cluster and replicas
                processes.append(p)
                p.start()

            for p in processes:
                p.join()

        # join results
        while True:
            try:
                res = results.get(timeout=0.1)
            except Exception as e:
                break
            done += res['done']
            self.testsFailed.extend(res['failures'])

        endTime = time.time()

        print(Colors.Bold('Test Took: %d sec' % (endTime - startTime)))
        print(
            Colors.Bold(
                'Total Tests Run: %d, Total Tests Failed: %d, Total Tests Passed: %d'
                % (done, self.getTotalFailureCount(),
                   done - self.getTotalFailureCount())))
        if self.testsFailed:
            print(Colors.Bold('Failed Tests Summary:'))
            for group, failures in self.testsFailed:
                print('\t' + Colors.Bold(group))
                if not failures:
                    print('\t\t' + Colors.Bred(
                        'Exception raised during test execution. See logs'))
                for failure in failures:
                    print('\t\t' + failure)
            sys.exit(1)
Ejemplo n.º 32
0
def main():
    try:
        config = INIConfig(open(CONF_FILE))
    except Exception:
        print("Error: Could not open configuration file '{}', exiting".format(
            CONF_FILE))
        exit(ERR)

    # Get list of modules to load, verify the required ones exist
    if not isinstance(config.modules.modules,
                      str) or not config.modules.modules:
        print("Error: No modules listed in configuration file, exiting")
        exit(ERR)

    modules = [m.strip() for m in config.modules.modules.split(',')]

    for reqd in REQD_MODULES:
        if not reqd in modules:
            print("Error: required module '{}' not set to be loaded, exiting".
                  format(reqd))
            exit(ERR)

    # Get system params, verify their sanity
    system_params = dict()
    system_params['station_id'] = config.station.stationid
    system_params['station_pass'] = config.station.stationpass
    system_params['server_host'] = config.server.host
    system_params['server_port'] = config.server.port

    for key, value in system_params.items():
        if not isinstance(value, str):
            print(
                "Error: param '{}' not appropriately defined in the configuration file, exiting."
                .format(key))
            exit(ERR)

    system_params['server_port'] = int(system_params['server_port'])

    # Load modules
    sys.path.append(MODPATH)

    loadedmods = dict()
    for module in modules:
        modsource = MOD_PREFIX + module

        try:
            Mod = import_module(modsource)
            ModObj = Mod.start(config, )
            loadedmods[module] = ModObj

        except Exception as e:
            if module in REQD_MODULES:
                print(
                    "Could not load required module '{}': {}, exiting.".format(
                        module, e))
                exit(ERR)
            else:
                print("Warning: could not load module '{}': {}.".format(
                    module, e))

    print("Loaded modules: {}".format(loadedmods.keys()))
    print("")

    for devnum, dev in loadedmods['devices'].devs.iteritems():
        serial = dev.serial
        cmdline = eval("config.startup.startup_{}".format(serial))
        if isinstance(cmdline, str):
            try:
                module, args = cmdline.split(' ', 1)
            except Exception:
                module = cmdline.strip()
                args = None

            if module in REQD_MODULES or module not in loadedmods.keys():
                continue

            if args == '':
                args = None
                continue

            if loadedmods[module].run(devnum, args, system_params, loadedmods):
                loadedmods['devices'].occupy(devnum, module, args)

    # pseudo-devices
    devnum = PSEUDO_DEVNUM_BASE
    while True:
        cmdline = eval("config.startup.startup_{}".format(devnum))
        if isinstance(cmdline, str):
            try:
                module, args = cmdline.split(' ', 1)
            except Exception:
                module = cmdline.strip()
                args = None

            if module in REQD_MODULES or module not in loadedmods.keys():
                continue

            if args == '':
                args = None
                continue

            if loadedmods[module].run(devnum, args, system_params, loadedmods):
                loadedmods['devices'].occupy(devnum, module, args, pseudo=True)

            devnum += 1
        else:
            break

    cmd = Interpreter()
    cmd.system_params = system_params
    cmd.loadedmods = loadedmods

    cmd.cmdloop()
Ejemplo n.º 33
0
 def cli(self):
     cmd = TaskmasterCmd(self, 'Hello>$ ')
     cmd.cmdloop()
     return 0
Ejemplo n.º 34
0
def main():
    display_welcome()
    cmd = CmdParse(parser.shellParser())
    cmd.cmdloop()
Ejemplo n.º 35
0
 def run(cls, first_commands=None):
     """ Convenience function to run a command loop """
     with cls(first_commands) as cmd:
         cmd.cmdloop()
Ejemplo n.º 36
0
def main():
    """cm.

    Usage:
      cm [-q] help
      cm [-v] [-b] [--file=SCRIPT] [-i] [COMMAND ...]

    Arguments:
      COMMAND                  A command to be executed

    Options:
      --file=SCRIPT  -f  SCRIPT  Executes the script
      -i                 After start keep the shell interactive,
                         otherwise quit [default: False]
      -b                 surpress the printing of the banner [default: False]
    """

    echo = False
    
    try:
        arguments = docopt(main.__doc__, help=True)
        # fixing the help parameter parsing
        if arguments['help']:
            arguments['COMMAND'] = ['help']
            arguments['help'] = 'False'

        script_file = arguments['--file']
        interactive = arguments['-i']
        echo = arguments['-v']
        if echo:
            pprint(arguments)

    except:
        script_file = None
        interactive = False

        arguments = {'-b': True,
                     'COMMAND': [' '.join(sys.argv[1:])]}

    plugins = []

    plugins.append(dict(get_plugins_from_dir("sys", "cmd3")))
    # plugins.append(dict(get_plugins_from_dir("~/.cloudmesh", "cmd3local")))


    # if not os.path.exists(path_expand( "~/.cloudmesh/cmd3.yaml")):
    #     from cmd3.plugins.shell_core import create_cmd3_yaml_file
    #     create_cmd3_yaml_file()


    create_cmd3_yaml_file(force=False, verbose=False)
    filename = path_expand("~/.cloudmesh/cmd3.yaml")
    try:
        module_config = ConfigDict(filename=filename)
        modules = module_config["cmd3"]["modules"]
        properties = module_config["cmd3"]["properties"]
    except:
        modules = ['cloudmesh_cmd3.plugins']
    for module_name in modules:
        #print ("INSTALL", module_name)
        try:
            plugins.append(dict(get_plugins_from_module(module_name)))
        except:
            # print "WARNING: could not find", module_name
            pass

    # sys.exit()
    # plugins.append(dict(get_plugins_from_dir("~/.cloudmesh", "cmd3local")))
    
    # plugins.append(dict(get_plugins_from_dir (".", "dot")))

    for plugin in plugins:
        sys.path.append(os.path.expanduser(plugin['dir']))
    sys.path.append("../..")
    sys.path.append(".")
    sys.path.append("..")

    for plugin in plugins:
        plugin['class'] += ".plugins"

    # pprint(plugins)
    # pprint(sys.path)

    # sys.exit()
    name = "CmCli"

    #
    # not yet quite what i want, but falling back to a flatt array
    #

    (cmd, plugin_objects) = DynamicCmd(name, plugins)


    cmd.set_verbose(echo)
    cmd.activate()
    cmd.set_verbose(echo)

    cmd.set_debug(properties["debug"])

    if arguments['-b']:
        cmd.set_banner("")
    if script_file is not None:
        cmd.do_exec(script_file)

    if len(arguments['COMMAND']) > 0:
        try:            
            user_cmd = " ".join(arguments['COMMAND'])
            if echo:
                print(">", user_cmd)
            cmd.onecmd(user_cmd)
        except Exception, e:
            Console.error("")
            Console.error("ERROR: executing command '{0}'".format(user_cmd))
            Console.error("")
            print (70 * "=")
            print(e)
            print (70 * "=")
            print(traceback.format_exc())

        if interactive:
            cmd.cmdloop()
Ejemplo n.º 37
0
                self.prettypath(self.wallet, self.folder, e),
                entry.value)

    def help_get(self):
        return "get the value behind the given entry in the current folder and wallet"

    def do_ch_pwd(self,cmd):
        self.wallet.changePassword()

    def help_ch_pwd(self):
        return "change the password for the current wallet"

    def do_set(self, entry):
        if entry in self.folder:
            print "overriding existing value!"

        entry = self.folder.openEntry(entry)
        entry.value = input_default(
            self.prettypath(self.wallet,self.folder, entry)+"="
            , entry.value)


    def help_set(self):
        return "set or override the value for the entry in teh current folder and wallet"


if __name__ == "__main__":
    cmd = KWalletShell()
    cmd.cmdloop("kwallet started..., enjoy")

Ejemplo n.º 38
0
    def execute(self):
        Env.RTestInstance = self
        if self.args.env_only:
            Env.defaultVerbose = 2
            env = Env(testName='manual test env')
            if self.args.interactive_debugger:
                while env.isUp():
                    time.sleep(1)
            else:
                cmd = MyCmd(env)
                cmd.cmdloop()
            env.stop()
            return
        done = 0
        startTime = time.time()
        if self.args.interactive_debugger and len(self.loader.tests) != 1:
            print(self.tests)
            print(
                Colors.Bred(
                    'only one test can be run on interactive-debugger use -t'))
            sys.exit(1)

        for test in self.loader:
            with self.envScopeGuard():
                if test.is_class:
                    try:
                        obj = test.create_instance()

                    except unittest.SkipTest:
                        self.printSkip()
                        continue

                    except Exception as e:
                        self.printException(e)
                        self.addFailure(test.name + " [__init__]")
                        continue

                    print(Colors.Cyan(test.name))

                    failures = 0
                    before = getattr(obj, 'setUp', None)
                    after = getattr(obj, 'tearDown', None)
                    for subtest in test.get_functions(obj):
                        failures += self._runTest(
                            subtest,
                            prefix='\t',
                            numberOfAssertionFailed=failures,
                            before=before,
                            after=after)
                        done += 1

                else:
                    self._runTest(test)
                    done += 1

        self.takeEnvDown(fullShutDown=True)
        endTime = time.time()

        print(Colors.Bold('Test Took: %d sec' % (endTime - startTime)))
        print(
            Colors.Bold(
                'Total Tests Run: %d, Total Tests Failed: %d, Total Tests Passed: %d'
                % (done, self.getTotalFailureCount(),
                   done - self.getTotalFailureCount())))
        if self.testsFailed:
            print(Colors.Bold('Failed Tests Summary:'))
            for group, failures in self.testsFailed:
                print('\t' + Colors.Bold(group))
                if not failures:
                    print('\t\t' + Colors.Bred(
                        'Exception raised during test execution. See logs'))
                for failure in failures:
                    print('\t\t' + failure)
            sys.exit(1)
Ejemplo n.º 39
0
import cmd
import sys


class Command(cmd.Cmd):
    prompt = 'What do you do? '

    def do_d(self, args):
        "Roll dice. Usage: 'd <nb>'"
        nb = int(args)
        rolls = [random.randint(1, 6) for x in xrange(nb)]
        successes = sum(1 for roll in rolls if roll >= 4)
        print "Rolls:", rolls
        print "Success: %d" % successes

    def do_quit(self, args):
        "Simply exits"
        print
        print "Bye"
        sys.exit()
    do_EOF = do_quit
    do_exit = do_quit


if __name__ == '__main__':
    cmd = Command()
    try:
        cmd.cmdloop('Please...')
    except KeyboardInterrupt, e:
        sys.exit('\nbye')