nvmetcli

#!/usr/bin/python

'''
Frontend to access to the NVMe target configfs hierarchy

Copyright (c) 2016 by HGST, a Western Digital Company.

Licensed 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.
'''

from __future__ import print_function

import os
import sys
import configshell_fb as configshell
import nvmet.nvme as nvme


class UINode(configshell.node.ConfigNode):
    def __init__(self, name, parent=None, cfnode=None, shell=None):
        configshell.node.ConfigNode.__init__(self, name, parent, shell)
        self.cfnode = cfnode
        if self.cfnode:
            if self.cfnode.attr_groups:
                for group in self.cfnode.attr_groups:
                    self._init_group(group)
        self.refresh()

    def _init_group(self, group):
        setattr(self.__class__, "ui_getgroup_%s" % group,
                lambda self, attr:
                    self.cfnode.get_attr(group, attr))
        setattr(self.__class__, "ui_setgroup_%s" % group,
                lambda self, attr, value:
                    self.cfnode.set_attr(group, attr, value))

        attrs = self.cfnode.list_attrs(group)
        attrs_ro = self.cfnode.list_attrs(group, writable=False)
        for attr in attrs:
            writable = attr not in attrs_ro

            name = "ui_desc_%s" % group
            t, d = getattr(self.__class__, name, {}).get(attr, ('string', ''))
            self.define_config_group_param(group, attr, t, d, writable)

    def refresh(self):
        self._children = set([])

    def status(self):
        return "None"

    def ui_command_refresh(self):
        '''
        Refreshes and updates the objects tree from the current path.
        '''
        self.refresh()

    def ui_command_status(self):
        '''
        Displays the current node's status summary.

        SEE ALSO
        ========
        B{ls}
        '''
        self.shell.log.info("Status for %s: %s" % (self.path, self.status()))

    def ui_command_saveconfig(self, savefile=None):
        '''
        Saves the current configuration to a file so that it can be restored
        on next boot.
        '''
        node = self
        while node.parent is not None:
            node = node.parent
        node.cfnode.save_to_file(savefile)


class UIRootNode(UINode):
    def __init__(self, shell):
        UINode.__init__(self, '/', parent=None, cfnode=nvme.Root(),
                        shell=shell)

    def refresh(self):
        self._children = set([])
        UISubsystemsNode(self)

    def ui_command_restoreconfig(self, savefile=None, clear_existing=False):
        '''
        Restores configuration from a file.
        '''
        errors = self.cfnode.restore_from_file(savefile, clear_existing)
        self.refresh()

        if errors:
            raise configshell.ExecutionError(
                "Configuration restored, %d errors:\n%s" %
                (len(errors), "\n".join(errors)))


class UISubsystemsNode(UINode):
    def __init__(self, parent):
        UINode.__init__(self, 'subsystems', parent)

    def refresh(self):
        self._children = set([])
        for subsys in self.parent.cfnode.subsystems:
            UISubsystemNode(self, subsys)

    def ui_command_create(self, nqn=None):
        '''
        Creates a new target. If I{nqn} is ommited, then the new Subsystem
        will be created using a randomly generated NQN.

        SEE ALSO
        ========
        B{delete}
        '''
        subsystem = nvme.Subsystem(nqn, mode='create')
        UISubsystemNode(self, subsystem)

    def ui_command_delete(self, nqn):
        '''
        Recursively deletes the subsystem with the specified I{nqn}, and all
        objects hanging under it.

        SEE ALSO
        ========
        B{delete}
        '''
        subsystem = nvme.Subsystem(nqn, mode='lookup')
        subsystem.delete()
        self.refresh()


class UISubsystemNode(UINode):
    def __init__(self, parent, cfnode):
        UINode.__init__(self, cfnode.nqn, parent, cfnode)

    def refresh(self):
        self._children = set([])
        UINamespacesNode(self)


class UINamespacesNode(UINode):
    def __init__(self, parent):
        UINode.__init__(self, 'namespaces', parent)

    def refresh(self):
        self._children = set([])
        for ns in self.parent.cfnode.namespaces:
            UINamespaceNode(self, ns)

    def ui_command_create(self, nsid=None):
        '''
        Creates a new namespace. If I{nsid} is ommited, then the next
        available namespace id will be used.

        SEE ALSO
        ========
        B{delete}
        '''
        namespace = nvme.Namespace(self.parent.cfnode, nsid, mode='create')
        UINamespaceNode(self, namespace)

    def ui_command_delete(self, nsid):
        '''
        Recursively deletes the namespace with the specified I{nsid}, and all
        objects hanging under it.

        SEE ALSO
        ========
        B{delete}
        '''
        namespace = nvme.Namespace(self.parent.cfnode, nsid, mode='lookup')
        namespace.delete()
        self.refresh()


class UINamespaceNode(UINode):
    ui_desc_device = {
        'path': ('string', 'Backing device path.'),
        'nguid': ('string', 'Namspace Global Unique Identifier.'),
    }

    def __init__(self, parent, cfnode):
        UINode.__init__(self, str(cfnode.nsid), parent, cfnode)

    def status(self):
        if self.cfnode.get_enable():
            return "enabled"
        return "disabled"

    def ui_command_enable(self):
        '''
        Enables the current Namespace.

        SEE ALSO
        ========
        B{disable}
        '''
        if self.cfnode.get_enable():
            self.shell.log.info("The Namespace is already enabled.")
        else:
            try:
                self.cfnode.set_enable(1)
                self.shell.log.info("The Namespace has been enabled.")
            except Exception as e:
                raise configshell.ExecutionError(
                    "The Namespace could not be enabled.")

    def ui_command_disable(self):
        '''
        Disables the current Namespace.

        SEE ALSO
        ========
        B{enable}
        '''
        if not self.cfnode.get_enable():
            self.shell.log.info("The Namespace is already disabled.")
        else:
            try:
                self.cfnode.set_enable(0)
                self.shell.log.info("The Namespace has been disabled.")
            except Exception as e:
                raise configshell.ExecutionError(
                    "The Namespace could not be dsiabled.")


def usage():
    print("syntax: %s save [file_to_save_to]" % sys.argv[0])
    print("        %s restore [file_to_restore_from]" % sys.argv[0])
    print("        %s clear" % sys.argv[0])
    sys.exit(-1)


def save(to_file):
    nvme.Root().save_to_file(to_file)


def restore(from_file):
    try:
        errors = nvme.Root().restore_from_file(from_file)
    except IOError:
        # Not an error if the restore file is not present
        print("No saved config file at %s, ok, exiting" % from_file)
    sys.exit(0)

    for error in errors:
        print(error)


def clear(unused):
    nvme.Root().clear_existing()


funcs = dict(save=save, restore=restore, clear=clear)


def main():
    if os.geteuid() != 0:
        print("%s: must run as root." % sys.argv[0], file=sys.stderr)
        sys.exit(-1)

    if len(sys.argv) > 3:
        usage()

    if len(sys.argv) == 2 or len(sys.argv) == 3:
        if sys.argv[1] == "--help":
            usage()

        if sys.argv[1] not in funcs.keys():
            usage()

        if len(sys.argv) == 3:
            savefile = sys.argv[2]
        else:
            savefile = None

        funcs[sys.argv[1]](savefile)
        return

    try:
        shell = configshell.shell.ConfigShell('~/.nvmetcli')
        UIRootNode(shell)
    except Exception as msg:
        shell.log.error(str(msg))
        return

    while not shell._exit:
        try:
            shell.run_interactive()
        except Exception as msg:
            shell.log.error(str(msg))

if __name__ == "__main__":
    main()