Refactored vm commands + better error messages

from cccli.printer import Printer, color

from cccli.command import TqlCommand

class Command_start(TqlCommand):

    '''Start a stopped vm'''

class VMCommand(TqlCommand):

    """Base class for commands related to VMs."""

    TQL_APPEND = ""

    ERROR_MSG = "No VM selected by TQL"

    def __init__(self, cli, argv0):

        TqlCommand.__init__(self, cli, argv0)

        self.tql_filter += "&r=vm&status=stopped"

        self.tql_filter += self.TQL_APPEND

    @property

    def cmd_name(self):

        # all VM commands have Command_ prefix

        return self.__class__.__name__[len("Command_"):]

    def _do_rpc_call(self):

            self.rpccall(self.cmd_name, self.args[0])

    def __call__(self, argv):

        # arg parse

        self.parse_args(argv)

        if len(self.args) != 1:

            raise cmdBadArgument()

        # rpc call

        self.rpccall("start", self.args[0])

    def remote_functions(self):

        return set(("start",))

        try:

            self._do_rpc_call()

        except cmdError:

            # We catch and re throw the same error to provide with a more

            # contextual error message

            if self.ERROR_MSG is None:

                raise

            else:

                raise cmdError(self.ERROR_MSG)

    def remote_functions(self):

        return {self.cmd_name}

class Command_stop(TqlCommand):

    '''Stop a running vm'''

    def __init__(self, cli, argv0):

        TqlCommand.__init__(self, cli, argv0)

        self.tql_filter += "&r=vm&status=running"

class Command_start(VMCommand):

    '''Start a stopped vm'''

    def __call__(self, argv):

        # arg parse

        self.parse_args(argv)

        if len(self.args) != 1:

            raise cmdBadArgument()

        # rpc call

        self.rpccall("stop", self.args[0])

    TQL_APPEND = "&r=vm&status=stopped"

    ERROR_MSG = VMCommand.ERROR_MSG + ", are your VMs stopped ?"

    def remote_functions(self):

        return set(("stop",))

class Command_stop(VMCommand):

    '''Stop a running vm'''

class Command_destroy(TqlCommand):

    '''Force a vm to stop'''

    TQL_APPEND = "&r=vm&status=running"

    ERROR_MSG = VMCommand.ERROR_MSG + ", are your VMs running ?"

    def __init__(self, cli, argv0):

        TqlCommand.__init__(self, cli, argv0)

        self.tql_filter += "&r=vm&status!=stopped"

    def __call__(self, argv):

        # arg parse

        self.parse_args(argv)

        if len(self.args) != 1:

            raise cmdBadArgument()

        # rpc call

        self.rpccall("destroy", self.args[0])

class Command_destroy(VMCommand):

    '''Force a vm to stop'''

    def remote_functions(self):

        return set(("destroy",))

    TQL_APPEND = "&r=vm&status!=stopped"

    ERROR_MSG = VMCommand.ERROR_MSG + ", are your VMs running ?"

class Command_pause(TqlCommand):

class Command_pause(VMCommand):

    '''Pause a running vm'''

    def __init__(self, cli, argv0):

        TqlCommand.__init__(self, cli, argv0)

        self.tql_filter += "&r=vm&status=running"

    def __call__(self, argv):

        # arg parse

        self.parse_args(argv)

        if len(self.args) != 1:

            raise cmdBadArgument()

        # rpc call

        self.rpccall("pause", self.args[0])

    def remote_functions(self):

        return set(("pause",))

    TQL_APPEND = "&r=vm&status=running"

    ERROR_MSG = VMCommand.ERROR_MSG + ", are your VMs running ?"

class Command_resume(TqlCommand):

class Command_resume(VMCommand):

    '''Resume a paused vm'''

    def __init__(self, cli, argv0):

        TqlCommand.__init__(self, cli, argv0)

        self.tql_filter += "&r=vm&status=paused"

    TQL_APPEND = "&r=vm&status=paused"

    ERROR_MSG = VMCommand.ERROR_MSG + ", are your VMs paused ?"

    def __call__(self, argv):

        # arg parse

        self.parse_args(argv)

        if len(self.args) != 1:

            raise cmdBadArgument()

        # rpc call

        self.rpccall("resume", self.args[0])

    def remote_functions(self):

        return set(("resume",))

class Command_disablevirtiocache(TqlCommand):

class Command_disablevirtiocache(VMCommand):

    '''Set virtio cache to none on VMs disk devices'''

    def __init__(self, cli, argv0):

        TqlCommand.__init__(self, cli, argv0)

        self.tql_filter += "&r=vm&status=stopped"

    def __call__(self, argv):

        # arg parse

        self.parse_args(argv)

        if len(self.args) != 1:

            raise cmdBadArgument()

        # rpc call

        self.rpccall("disablevirtiocache", self.args[0])

    TQL_APPEND = "&r=vm&status=stopped"

    ERROR_MSG = VMCommand.ERROR_MSG + ", are your VMs stopped ?"

    def remote_functions(self):

        return set(("disablevirtiocache",))

class Command_autostart(TqlCommand):

class Command_autostart(VMCommand):

    '''Set autostart flag on VMs'''

    def __init__(self, cli, argv0):

        TqlCommand.__init__(self, cli, argv0)

        self.tql_filter += "&r=vm"

    TQL_APPEND = "&r=vm"

    def __init__(self, *args, **kwargs):

        VMCommand.__init__(self, *args, **kwargs)

        self.add_option("-D", action="store_false", dest="flag", help="Disable"

                        " autostart")

        self.add_option("-e", default=True, action="store_true", dest="flag",

                       help="Enable autostart")

    def __call__(self, argv):

        # arg parse

        self.parse_args(argv)

        if len(self.args) != 1:

            raise cmdBadArgument()

        # rpc call

    def _do_rpc_call(self):

        self.rpccall("autostart", self.args[0], self.options.flag)

    def remote_functions(self):

        return set(("autostart",))

class Command_undefine(TqlCommand):

class Command_undefine(VMCommand):

    '''Undefine a stopped vm'''

    def __init__(self, cli, argv0):

        TqlCommand.__init__(self, cli, argv0)

        self.tql_filter += "&r=vm&status=stopped"

    TQL_APPEND = "&r=vm&status=stopped"

    ERROR_MSG = VMCommand.ERROR_MSG + ", are you VMs stopped ?"

    def __init__(self, *args, **kwargs):

        VMCommand.__init__(self, *args, **kwargs)

        self.add_option("-k", "--keep-storage", action="store_false", dest="clean", default=True,

                        help="Don't remove vm storage")

    def __call__(self, argv):

        # arg parse

        self.parse_args(argv)

        if len(self.args) != 1:

            raise cmdBadArgument()

        # rpc call

    def _do_rpc_call(self):

        self.rpccall("undefine", self.args[0], self.options.clean)

    def remote_functions(self):

        return set(("undefine",))

class Command_clone(TqlCommand):

    '''Clone vm'''