cloudmonkey.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

try:
    import argcomplete
    import argparse
    import atexit
    import cmd
    import csv
    import copy
    import json
    import logging
    import os
    import shlex
    import sys
    import time
    import types
    import jmespath

    from cachemaker import loadcache, savecache, monkeycache, splitverbsubject
    from config import __version__, __description__, __projecturl__
    from config import display_types
    from config import read_config, write_config, config_file, default_profile
    from dicttoxml import dicttoxml
    from optparse import OptionParser
    from prettytable import PrettyTable
    from printer import monkeyprint
    from requester import monkeyrequest
    from requester import login
    from requester import logout
    from urlparse import urlparse
    from xml.dom.minidom import parseString
except ImportError, e:
    print("Import error in %s : %s" % (__name__, e))
    import sys
    sys.exit()

try:
    from precache import apicache
except ImportError:
    apicache = {'count': 0, 'verbs': [], 'asyncapis': []}

normal_readline = True
# Fix terminal env before importing readline
# Without it, char ESC[?1034h gets printed in output
# There is not TERM variable in some environment such as Docker.
if 'TERM' not in os.environ or os.environ['TERM'].startswith('xterm'):
    os.environ['TERM'] = 'vt100'
try:
    import readline
except ImportError, e:
    print("Module readline not found, autocompletions will fail", e)
else:
    import rlcompleter
    readline_doc = getattr(readline, '__doc__', '')
    if readline_doc is not None and 'libedit' in readline_doc:
        readline.parse_and_bind("bind ^I rl_complete")
        readline.parse_and_bind("bind ^R em-inc-search-prev")
        normal_readline = False
    else:
        readline.parse_and_bind("tab: complete")

log_fmt = '%(asctime)s - %(filename)s:%(lineno)s - [%(levelname)s] %(message)s'
logger = logging.getLogger(__name__)


class CloudMonkeyShell(cmd.Cmd, object):
    intro = ("☁ Apache CloudStack 🐵 (legacy) cloudmonkey " + __version__ + ".\n" +
             "Please switch to latest Go-based version https://github.com/apache/cloudstack-cloudmonkey/releases.\n" +
             "For usage see https://github.com/apache/cloudstack-cloudmonkey/wiki.\n" +
             "Type help or ? to list commands.\n")
    ruler = "="
    config_options = []
    profile_names = []
    verbs = []
    interpreterMode = False
    error_on_last_command = False
    param_cache = {}
    prompt = "🐵 > "
    protocol = "http"
    host = "localhost"
    port = "8080"
    path = "/client/api"
    hook_count = 0

    def __init__(self, pname, cfile):
        self.default_apis = self.completenames('')
        self.program_name = pname
        self.config_file = cfile
        self.config_options = read_config(self.get_attr, self.set_attr,
                                          self.config_file)
        self.loadcache()
        self.init_credential_store()
        logging.basicConfig(filename=self.log_file,
                            level=logging.DEBUG, format=log_fmt)
        logger.debug("Loaded config fields:\n%s" % map(lambda x: "%s=%s" %
                                                       (x, getattr(self, x)),
                                                       self.config_options))
        cmd.Cmd.__init__(self)

        try:
            if os.path.exists(self.history_file):
                readline.read_history_file(self.history_file)
        except IOError, e:
            logger.debug(u"Error: Unable to read history. " + unicode(e))
        atexit.register(readline.write_history_file, self.history_file)

    def init_credential_store(self):
        self.credentials = {'apikey': self.apikey, 'secretkey': self.secretkey,
                            'domain': self.domain, 'username': self.username,
                            'password': self.password,
                            'signatureversion': self.signatureversion}
        parsed_url = urlparse(self.url)
        self.protocol = "http" if not parsed_url.scheme else parsed_url.scheme
        self.host = parsed_url.netloc
        self.port = "8080" if not parsed_url.port else parsed_url.port
        self.path = parsed_url.path
        self.set_prompt()

    def get_prompt(self):
        return self.prompt.split(") ")[-1]

    def set_prompt(self):
        self.prompt = "(%s) %s" % (self.profile, self.get_prompt())

    def get_attr(self, field):
        return getattr(self, field)

    def set_attr(self, field, value):
        return setattr(self, field, value)

    def emptyline(self):
        pass

    def cmdloop(self, intro=None):
        self.interpreterMode = True
        print(self.intro)
        print "Using management server profile:", self.profile, "\n"
        while True:
            try:
                super(CloudMonkeyShell, self).cmdloop(intro="")
            except KeyboardInterrupt:
                print("^C")

    def precmd(self, line):
        self.hook_count -= 1
        if self.hook_count <= 0:
            self.hook_count = 0
            readline.set_startup_hook()
        return line

    def loadcache(self):
        if os.path.exists(self.cache_file):
            self.apicache = loadcache(self.cache_file)
        else:
            self.apicache = apicache
        if 'verbs' in self.apicache:
            self.verbs = self.apicache['verbs']

        for verb in self.verbs:
            handler_name = "do_" + str(verb)
            handler_doc = str("%ss resources" % verb.capitalize())

            if hasattr(self, handler_name) and getattr(self, handler_name).__doc__ == handler_doc:
                continue

            def add_grammar(verb):
                default_handler = None
                if self.default_apis.__contains__(verb):
                    default_handler = getattr(self, handler_name)

                def grammar_closure(self, args):
                    if not args:
                        if default_handler:
                            default_handler(args)
                        return
                    args = args.decode("utf-8")
                    if self.pipe_runner(u"{0} {1}".format(verb, args)):
                        return
                    if ' --help' in args or ' -h' in args:
                        self.do_help("%s %s" % (verb, args))
                        return
                    try:
                        args_partition = args.partition(" ")
                        cmd = self.apicache[verb][args_partition[0]]['name']
                        args = args_partition[2]
                    except KeyError, e:
                        if default_handler:
                            default_handler(args)
                        else:
                            self.monkeyprint("Error: invalid %s api arg " % verb,
                                         str(e))
                        return
                    self.default(u"{0} {1}".format(cmd, args))
                return grammar_closure

            grammar_handler = add_grammar(verb)
            grammar_handler.__doc__ = handler_doc
            grammar_handler.__name__ = handler_name
            setattr(self.__class__, grammar_handler.__name__, grammar_handler)

    def monkeyprint(self, *args):
        output = u""
        try:
            for arg in args:
                if isinstance(type(arg), types.NoneType) or not arg:
                    continue
                if not (isinstance(arg, str) or isinstance(arg, unicode)):
                    arg = unicode(arg)
                output += arg
        except Exception, e:
            print(str(e))

        output = output.encode("utf-8")
        if self.color == 'true':
            monkeyprint(output)
        else:
            if output.startswith("Error"):
                sys.stderr.write(output + "\n")
                sys.stderr.flush()
            else:
                print output

    def print_result(self, result, result_filter=[], result_query=''):
        if not result or len(result) == 0:
            return

        filtered_result = copy.deepcopy(result)
        if result_filter and isinstance(result_filter, list) \
                and len(result_filter) > 0:
            tfilter = {}  # temp var to hold a dict of the filters
            tresult = filtered_result  # dupe the result to filter
            if result_filter:
                for res in result_filter:
                    tfilter[res] = 1
                for okey, oval in result.iteritems():
                    if isinstance(oval, dict):
                        for tkey in oval:
                            if tkey not in tfilter:
                                try:
                                    del(tresult[okey][oval][tkey])
                                except:
                                    pass
                    elif isinstance(oval, list):
                        for x in range(len(oval)):
                            if isinstance(oval[x], dict):
                                for tkey in oval[x]:
                                    if tkey not in tfilter:
                                        try:
                                            del(tresult[okey][x][tkey])
                                        except:
                                            pass
                            else:
                                try:
                                    del(tresult[okey][x])
                                except:
                                    pass
            filtered_result = tresult

        def print_result_json(result):
            self.monkeyprint(json.dumps(result,
                                        sort_keys=True,
                                        indent=2,
                                        ensure_ascii=False,
                                        separators=(',', ': ')))

        def print_result_jmespath(result, result_query):
            try:
                expression = jmespath.compile(result_query)
            except Exception as e:
                raise ValueError("Bad value for --query: %s \n\n %s" % (result_query, str(e)))
            
            try:
                self.monkeyprint(json.dumps(expression.search(result),
                                                    sort_keys=True,
                                                    indent=2,
                                                    ensure_ascii=False,
                                                    separators=(',', ': ')))
            except Exception as e:
                raise ValueError("Bad formatted JSON for JMESPATH: %s \n\n %s" % (result, str(e)))

        def print_result_xml(result):
            custom_root = "CloudStack-%s" % self.profile.replace(" ", "_")
            xml = dicttoxml(result, attr_type=False, custom_root=custom_root)
            self.monkeyprint(parseString(xml).toprettyxml())

        def print_result_csv(result):
            if "count" in result:
                result.pop("count")

            if len(result.keys()) == 1:
                item = result[result.keys()[0]]
                if isinstance(item, list):
                    result = item
                elif isinstance(item, dict):
                    result = [item]

            if isinstance(result, list) and len(result) > 0:
                if isinstance(result[0], dict):
                    keys = result[0].keys()
                    writer = csv.DictWriter(sys.stdout, keys)
                    print ','.join(keys)
                    for item in result:
                        row = {}
                        for k in keys:
                            if k not in item:
                                row[k] = None
                            else:
                                if type(item[k]) is unicode:
                                    row[k] = item[k].encode('utf8')
                                else:
                                    row[k] = item[k]
                        writer.writerow(row)
            elif isinstance(result, dict):
                keys = result.keys()
                writer = csv.DictWriter(sys.stdout, keys)
                print ','.join(keys)
                writer.writerow(result)

        def print_result_tabular(result):
            def print_table(printer, toprow):
                if printer:
                    self.monkeyprint(printer.get_string())
                return PrettyTable(toprow)
            printer = None
            toprow = []
            if not result:
                return
            toprow = set(reduce(lambda x, y: x + y, map(lambda x: x.keys(),
                         filter(lambda x: isinstance(x, dict), result))))
            printer = print_table(printer, toprow)
            for node in result:
                if not node:
                    continue
                for key in toprow:
                    if key not in node:
                        node[key] = ''
                row = map(lambda x: node[x], toprow)
                if printer and row:
                    printer.add_row(row)
            print_table(printer, toprow)

        def print_result_as_dict(result):
            for key in sorted(result.keys(), key=lambda x:
                              x not in ['id', 'count', 'name'] and x):
                if isinstance(result[key], list):
                    self.monkeyprint(key + ":")
                    print_result_as_list(result[key])
                elif isinstance(result[key], dict):
                    self.monkeyprint(key + ":")
                    print_result_as_dict(result[key])
                else:
                    value = unicode(result[key])
                    self.monkeyprint(key, " = ", value)

        def print_result_as_list(result):
            for idx, node in enumerate(result):
                if isinstance(node, dict):
                    if self.display == 'table':
                        print_result_tabular(result)
                        break
                    print_result_as_dict(node)
                elif isinstance(node, list):
                    print_result_as_list(node)
                else:
                    self.monkeyprint(filtered_result)
                if result and node and (idx+1) < len(result):
                    self.monkeyprint(self.ruler * 80)

        if self.display == "json":
            print_result_json(filtered_result)
            return

        if self.display == "jmespath":
            print_result_jmespath(filtered_result, result_query)
            return

        if self.display == "xml":
            print_result_xml(filtered_result)
            return

        if self.display == "csv":
            print_result_csv(filtered_result)
            return

        if isinstance(filtered_result, dict):
            print_result_as_dict(filtered_result)
        elif isinstance(filtered_result, list):
            print_result_as_list(filtered_result)
        else:
            self.monkeyprint(filtered_result)

    def make_request(self, command, args={}, isasync=False):
        self.error_on_last_command = False
        response, error = monkeyrequest(command, args, isasync,
                                        self.asyncblock, logger,
                                        self.url, self.credentials,
                                        self.timeout, self.expires,
                                        self.verifysslcert == 'true',
                                        self.signatureversion)
        if error:
            self.monkeyprint(u"Error {0}".format(error))
            self.error_on_last_command = True
        return response

    def update_param_cache(self, api, result={}):
        if not api:
            return
        logger.debug("Updating param cache for %s API" % api)
        responsekey = filter(lambda x: 'response' in x, result.keys())[0]
        result = result[responsekey]
        options = []
        uuids = []
        for key in result.keys():
            if isinstance(result[key], list):
                for element in result[key]:
                    if 'id' in element.keys():
                        uuid = unicode(element['id'])
                        name = ""
                        keyspace = ["name", "displayname",
                                    "username", "description"]
                        for name_key in keyspace:
                            if name_key in element.keys():
                                name = element[name_key]
                                break
                        options.append((uuid, name,))
                        uuids.append(uuid)
        self.param_cache[api] = {}
        self.param_cache[api]["ts"] = int(time.time())
        self.param_cache[api]["options"] = sorted(options)
        return sorted(uuids)

    def default(self, args):
        try:
            args = args.strip()
            args.decode("utf-8")
        except UnicodeError, ignore:
            args = args.encode("utf-8")

        if self.pipe_runner(args):
            return

        apiname = args.partition(' ')[0]
        verb, subject = splitverbsubject(apiname)

        lexp = shlex.shlex(args)
        lexp.whitespace = " "
        lexp.whitespace_split = True
        lexp.posix = True
        args = []
        while True:
            try:
                next_val = lexp.next()
                if not next_val:
                    break
                next_val = next_val.decode("utf-8")
                args.append(next_val.replace(u'\x00', u''))
            except ValueError, err:
                self.monkeyprint("Command parsing error: ", err)
                return

        args_dict = dict(map(lambda x: [x.partition("=")[0],
                                        x.partition("=")[2]],
                             args[1:])[x] for x in range(len(args) - 1))

        field_query = []
        if 'query' in args_dict:
            field_query = args_dict.pop('query')
        
        field_filter = []
        if 'filter' in args_dict:
            field_filter = filter(lambda x: x.strip() != '',
                                  args_dict.pop('filter').split(','))
            field_filter = list(set(field_filter))

        missing = []
        if verb in self.apicache and subject in self.apicache[verb]:
            missing = filter(lambda x: x not in [key.split('[')[0].lower()
                                                 for key in args_dict],
                             self.apicache[verb][subject]['requiredparams'])

        if len(missing) > 0:
            self.monkeyprint("Missing arguments: ", ' '.join(missing))
            return

        isasync = False
        if 'asyncapis' in self.apicache:
            if apiname.decode("utf-8") in self.apicache["asyncapis"]:
                isasync = True

        result = self.make_request(apiname, args_dict, isasync)

        if not result or not isinstance(result, dict):
            if isinstance(result, unicode):
                result = result.decode("utf-8")
            logger.debug("Invalid command result: %s" % result)
            return

        try:
            responsekeys = filter(lambda x: 'response' in x, result.keys())
            for responsekey in responsekeys:
                self.print_result(result[responsekey], field_filter, field_query)
            if apiname.startswith("list") and "id" not in args_dict:
                self.update_param_cache(apiname, result)
        except Exception as e:
            self.monkeyprint("Error on parsing and printing ", e)

    def completedefault(self, text, line, begidx, endidx):
        partitions = line[:endidx].partition(" ")
        verb = partitions[0].strip()
        rline = partitions[2].lstrip().partition(" ")
        subject = rline[0]
        separator = rline[1]
        params = rline[2].lstrip()

        if verb not in self.verbs:
            return []

        autocompletions = []
        search_string = ""

        if separator != " ":   # Complete verb subjects
            autocompletions = map(lambda x: x + " ",
                                  self.apicache[verb].keys())
            search_string = subject
        else:                  # Complete subject params
            autocompletions = map(lambda x: x + "=",
                                  map(lambda x: x['name'],
                                      self.apicache[verb][subject]['params']))
            search_string = text
            if self.paramcompletion == 'true':
                param = line[:endidx].split(" ")[-1]
                idx = param.find("=")
                value = param[idx + 1:]
                param = param[:idx]
                if param == "filter":
                    response_params = self.apicache[verb][subject]["response"]
                    used = filter(lambda x: x.strip() != "",
                                  value.split(",")[:-1])
                    unused = map(lambda x: x['name'] + ",", filter(lambda x:
                                 "name" in x and x["name"] not in used,
                                 response_params))
                    last_value = value.split(",")[-1]
                    if last_value:
                        unused = filter(lambda x: x.startswith(last_value),
                                        unused)
                    suffix = ",".join(used)
                    if suffix:
                        suffix += ","
                    global normal_readline
                    if normal_readline:
                        return filter(lambda x: x.startswith(last_value),
                                      map(lambda x: x, unused))
                    else:  # OSX fix
                        return filter(lambda x: x.startswith(value),
                                      map(lambda x: suffix + x, unused))
                elif len(value) < 36 and idx != -1:
                    api = None
                    logger.debug("[Paramcompl] For %s %s %s=" % (verb, subject,
                                                                 param))
                    if "id" in param:
                        logger.debug("[Paramcompl] Using 'list' heuristics")
                        if param == "id" or param == "ids":
                            entity = subject
                        else:
                            entity = param.replace("id", "")
                        apis = []
                        for resource in self.apicache["list"]:
                            if resource.startswith(entity):
                                api = self.apicache["list"][resource]['name']
                                if (entity + "s") == resource.lower():
                                    break
                                apis.append(api)
                                api = None
                        if len(apis) > 0 and not api:
                            logger.debug("[Paramcompl] APIs: %s" % apis)
                            api = min(apis, key=len)
                        logger.debug("[Paramcompl] Possible API: %s" % api)
                    if not api:
                        logger.debug("[Paramcompl] Using relative approx")
                        params = self.apicache[verb][subject]['params']
                        arg = filter(lambda x: x['name'] == param, params)[0]
                        if "type" in arg and arg["type"] == "boolean":
                            return filter(lambda x: x.startswith(value),
                                          ["true ", "false "])
                        related = arg['related']
                        apis = filter(lambda x: 'list' in x, related)
                        logger.debug("[Paramcompl] Related APIs: %s" % apis)
                        if len(apis) > 0:
                            api = apis[0]
                        else:
                            if param == "account":
                                api = "listAccounts"
                            else:
                                return
                    uuids = []
                    cache_burst_ts = int(time.time()) - 900
                    logger.debug("Trying paramcompletion using API: %s" % api)
                    if api in self.param_cache.keys() and \
                        len(self.param_cache[api]["options"]) > 0 and \
                            self.param_cache[api]["ts"] > cache_burst_ts:
                        for option in self.param_cache[api]["options"]:
                            uuid = option[0]
                            if uuid.startswith(value):
                                uuids.append(uuid)
                    else:
                        api_args = {'listall': 'true', 'templatefilter': 'all'}
                        response = self.make_request(api, args=api_args)
                        if not response:
                            return
                        uuids = self.update_param_cache(api, response)
                    if len(uuids) > 1:
                        print
                        options = sorted(self.param_cache[api]["options"],
                                         key=lambda x: x[1])
                        for option in options:
                            uuid = option[0]
                            name = option[1]
                            if uuid.startswith(value):
                                print uuid, name
                    autocompletions = map(lambda x: x + " ", uuids)
                    search_string = value

        if subject != "" and line.split(" ")[-1].find('=') == -1:
            autocompletions.append("filter=")
        return [s for s in autocompletions if s.startswith(search_string)]

    def do_sync(self, args):
        """
        Asks cloudmonkey to discovery and sync apis available on user specified
        CloudStack host server which has the API discovery plugin, on failure
        it rollbacks last datastore or api precached datastore.
        """
        response = self.make_request("listApis")
        if not response:
            monkeyprint("Failed to sync apis, please check your config?")
            monkeyprint("Note: `sync` requires api discovery service enabled" +
                        " on the CloudStack management server")
            return
        self.apicache = monkeycache(response)
        savecache(self.apicache, self.cache_file)
        monkeyprint("%s APIs discovered and cached" % self.apicache["count"])
        self.loadcache()

    def do_api(self, args):
        """
        Make raw api calls. Syntax: api <apiName> <args>=<values>.

        Example:
        api listAccount listall=true
        """
        if len(args) > 0:
            return self.default(args)
        else:
            self.monkeyprint("Please use a valid syntax")

    def do_set(self, args):
        """
        Set config for cloudmonkey. For example, options can be:
        url, auth, log_file, history_file
        You may also edit your ~/.cloudmonkey_config instead of using set.

        Example:
        set url http://localhost:8080/client/api
        set prompt 🐵 cloudmonkey>
        set log_file /var/log/cloudmonkey.log
        """
        args = args.strip().partition(" ")
        key, value = (args[0].strip(), args[2].strip())
        if not key:
            return
        allowed_blank_keys = ["username", "password", "apikey", "secretkey",
                              "domain"]
        if key not in allowed_blank_keys and not value:
            print "Blank value of %s is not allowed" % key
            return

        self.prompt = self.get_prompt()
        setattr(self, key, value)
        if key in ['host', 'port', 'path', 'protocol']:
            key = 'url'
            self.url = "%s://%s:%s%s" % (self.protocol, self.host,
                                         self.port, self.path)
            print "This option has been deprecated, please set 'url' instead"
            print "This server url will be used:", self.url
        write_config(self.get_attr, self.config_file)
        read_config(self.get_attr, self.set_attr, self.config_file)
        self.init_credential_store()
        if key.strip() == 'profile' and self.interpreterMode:
            print "\nLoaded server profile '%s' with options:" % value
            for option in default_profile.keys():
                value = self.get_attr(option)
                if option in ["password", "apikey", "secretkey"] and value:
                    value = value[:2] + "XXX" + value[4:6] + "YYY...(hidden)"
                print "    %s = %s" % (option, value)
            print

    def complete_set(self, text, line, begidx, endidx):
        mline = line.partition(" ")[2].lstrip().partition(" ")
        option = mline[0].strip()
        separator = mline[1]
        value = mline[2].lstrip()
        if separator == "":
            return [s for s in self.config_options if s.startswith(option)] + self.completedefault(text, line, begidx, endidx)
        elif option == "profile":
            return [s for s in self.profile_names if s.startswith(value)]
        elif option == "display":
            return [s for s in display_types
                    if s.startswith(value)]
        elif option in ["asyncblock", "color", "paramcompletion",
                        "verifysslcert"]:
            return [s for s in ["true", "false"] if s.startswith(value)]
        elif "set" in self.apicache["verbs"]:
            return self.completedefault(text, line, begidx, endidx)

        return []

    def do_login(self, args):
        """
        Login using stored credentials. Starts a session to be reused for
        subsequent api calls
        """
        try:
            session, sessionkey = login(self.url, self.username, self.password)
            self.credentials['session'] = session
            self.credentials['sessionkey'] = sessionkey
        except Exception, e:
            self.monkeyprint("Error: Login failed to the server: ", unicode(e))

    def do_logout(self, args):
        """
        Logout of session started with login with username and password
        """
        try:
            logout(self.url, self.credentials.get('session'))
        except Exception, e:
            pass
        self.credentials['session'] = None
        self.credentials['sessionkey'] = None

    def pipe_runner(self, args):
        if args.find(" |") > -1:
            pname = self.program_name
            if '.py' in pname:
                pname = "python " + pname
            if isinstance(args, str):
                self.do_shell("{0} {1}".format(pname, args))
            else:
                self.do_shell(u"{0} {1}".format(pname, args))
            return True
        return False

    def do_shell(self, args):
        """
        Execute shell commands using shell <command> or !<command>

        Example:
        !ls
        shell ls
        !for((i=0; i<10; i++)); do cloudmonkey create user account=admin \
            email=test@test.tt firstname=user$i lastname=user$i \
            password=password username=user$i; done
        """
        if args.isdigit():
            self.do_history("!" + args)
            return
        if isinstance(args, str):
            os.system(args)
        else:
            os.system(args.encode("utf-8"))

    def do_history(self, args):
        """
        Prints cloudmonkey history
        """
        if self.pipe_runner("history " + args):
            return
        startIdx = 1
        endIdx = readline.get_current_history_length()
        numLen = len(str(endIdx))
        historyArg = args.split(' ')[0]
        if historyArg.isdigit():
            startIdx = endIdx - long(historyArg)
            if startIdx < 1:
                startIdx = 1
        elif historyArg == "clear" or historyArg == "c":
            readline.clear_history()
            print "CloudMonkey history cleared"
            return
        elif len(historyArg) > 1 and historyArg[0] == "!" and historyArg[1:].isdigit():
            command = readline.get_history_item(long(historyArg[1:]))
            readline.set_startup_hook(lambda: readline.insert_text(command))
            self.hook_count = 1
            return
        for idx in xrange(startIdx, endIdx):
            self.monkeyprint("%s %s" % (str(idx).rjust(numLen),
                                        readline.get_history_item(idx)))

    def do_help(self, args):
        """
        Show help docs for various topics

        Example:
        help list
        help list users
        ?list
        ?list users
        """
        fields = args.partition(" ")
        if fields[2] == "":
            cmd.Cmd.do_help(self, args)
        else:
            verb = fields[0]
            subject = fields[2].partition(" ")[0]
            if subject in self.apicache[verb]:
                api = self.apicache[verb][subject]
                helpdoc = "(%s) %s" % (api['name'], api['description'])
                if api['isasync']:
                    helpdoc += "\nThis API is asynchronous."
                required = api['requiredparams']
                if len(required) > 0:
                    helpdoc += "\nRequired params are %s" % ' '.join(required)
                helpdoc += "\nParameters\n" + "=" * 10
                for param in api['params']:
                    helpdoc += "\n%s = (%s) %s" % (
                               param['name'], param['type'],
                               param['description'])
                self.monkeyprint(helpdoc)
            else:
                self.monkeyprint("Error: no such api (%s) on %s" %
                                 (subject, verb))

    def complete_help(self, text, line, begidx, endidx):
        fields = line.partition(" ")
        subfields = fields[2].partition(" ")

        if subfields[1] != " ":
            return cmd.Cmd.complete_help(self, text, line, begidx, endidx)
        else:
            line = fields[2]
            text = subfields[2]
            return self.completedefault(text, line, begidx, endidx)

    def do_EOF(self, args):
        """
        Quit on Ctrl+d or EOF
        """
        self.do_logout(None)
        sys.exit()

    def do_exit(self, args):
        """
        Quit CloudMonkey CLI
        """
        return self.do_quit(args)

    def do_quit(self, args):
        """
        Quit CloudMonkey CLI
        """
        self.monkeyprint("Bye!")
        return self.do_EOF(args)


def main():
    parser = argparse.ArgumentParser(usage="cloudmonkey [options] [commands]",
                                     description=__description__,
                                     epilog="Try cloudmonkey [help|?]")

    parser.add_argument("-v", "--version", action="version",
                        default=argparse.SUPPRESS,
                        version="cloudmonkey %s" % __version__,
                        help="show CloudMonkey's version and exit")

    parser.add_argument("-c", "--config-file",
                        dest="configFile", default=config_file,
                        help="config file for cloudmonkey", metavar="FILE")

    parser.add_argument("-b", "--block-async", action="store_true",
                        help="block and poll result on async API calls")

    parser.add_argument("-n", "--noblock-async", action="store_true",
                        help="do not block on async API calls")

    parser.add_argument("-d", "--display-type",
                        dest="displayType", default=None,
                        help="output displays: json, xml, table or default",
                        choices=tuple(display_types))

    parser.add_argument("-p", "--profile",
                        dest="serverProfile", default=None,
                        help="server profile to load")

    parser.add_argument("commands", nargs=argparse.REMAINDER,
                        help="API commands")

    argcomplete.autocomplete(parser)
    args = parser.parse_args()

    shell = CloudMonkeyShell(sys.argv[0], args.configFile)

    if args.displayType and args.displayType in display_types:
        shell.set_attr("display", args.displayType)

    if args.noblock_async:
        shell.set_attr("asyncblock", "false")

    if args.block_async:
        shell.set_attr("asyncblock", "true")

    if args.serverProfile and args.serverProfile.strip() != '':
        shell.do_set("profile %s" % args.serverProfile)

    if len(args.commands) > 0:
        shell.set_attr("color", "false")
        commands = []
        for command in args.commands:
            split_command = command.split("=", 1)
            if len(split_command) > 1:
                key = split_command[0]
                value = split_command[1]
                if " " not in value or \
                   (value.startswith("\"") and value.endswith("\"")) or \
                   (value.startswith("\'") and value.endswith("\'")):
                    commands.append(command)
                else:
                    commands.append("%s=\"%s\"" % (key, value))
            else:
                commands.append(command)
        shell.onecmd(" ".join(commands))
        if shell.error_on_last_command:
            sys.exit(1)
    else:
        shell.cmdloop()

    try:
        sys.stdout.close()
    except:
        pass
    try:
        sys.stderr.close()
    except:
        pass


if __name__ == "__main__":
    main()