ctladm

#!/usr/bin/python3

import argparse
from xml.dom import minidom
from collections import defaultdict
import subprocess
import os
import sys
import logging
from pathlib import Path
from time import sleep


SYSFS_SCST_ROOT = "/sys/kernel/scst_tgt"
SYSFS_SCST_DEVICES = "{}/devices".format(SYSFS_SCST_ROOT)
SYSFS_SCST_LUNS = "/sys/kernel/scst_tgt/targets/copy_manager/"
"copy_manager_tgt/luns"
SYSFS_SCST_ISCSI_TGTS = "{}/targets/iscsi".format(SYSFS_SCST_ROOT)
SYSFS_SCST_LUN0_DEV = "ini_groups/allowed_ini/luns/0/device"
SYSFS_SCST_LUNS_MGMT = "ini_groups/allowed_ini/luns/mgmt"
SYSFS_SCST_DEV_MGMT = "/sys/kernel/scst_tgt/handlers/vdisk_blockio/mgmt"


def safe_cast(val, to_type, default=None):
    try:
        return to_type(val)
    except (ValueError, TypeError):
        return default


def get_iscsi_wwn(link):
    a = link.find("iqn", 0)
    if a > -1:
        b = link.find("/", a+1)
        if b > 0:
            return link[a:b]
        else:
            return link[a:]
    else:
        return None


def scst_get_devices():
    if os.path.exists(SYSFS_SCST_DEVICES):
        devices = [device for device in os.listdir(SYSFS_SCST_DEVICES)
                   if os.path.isdir(os.path.join(SYSFS_SCST_DEVICES, device))]
        return devices
    else:
        logging.error("%s does not exists", SYSFS_SCST_DEVICES)
        return None


def scst_get_iscsi_targets():
    if os.path.exists(SYSFS_SCST_ISCSI_TGTS):
        targets = [target for target in os.listdir(SYSFS_SCST_ISCSI_TGTS)
                   if os.path.isdir(os.path.join(SYSFS_SCST_ISCSI_TGTS, target))]
        return targets
    else:
        logging.error("%s does not exists", SYSFS_SCST_ISCSI_TGTS)
        return None


def scst_get_target_sessions(target):
    sessions_path = os.path.join(SYSFS_SCST_ISCSI_TGTS, target, "sessions")
    if os.path.exists(sessions_path):
        sessions = [session for session in os.listdir(sessions_path)
                    if os.path.isdir(os.path.join(sessions_path, session))]
        return sessions
    else:
        logging.error("%s does not exists", sessions_path)
        return None


def scst_get_portal_addr(target):
    portal_path = os.path.join(SYSFS_SCST_ISCSI_TGTS, target, "allowed_portal")
    try:
        portal_file = open(portal_path, 'r')
        portal_value = portal_file.read().split("\n")[0]
        portal_file.close()
    except Exception:
        # allowed_portal is not defined
        portal_value = "0.0.0.0"
        pass
    return portal_value


def scst_get_device_params(device):
    result = defaultdict(lambda: "")
    device_path = os.path.join(SYSFS_SCST_DEVICES, device)
    params = [param for param in os.listdir(device_path)
              if not os.path.isdir(os.path.join(device_path, param))]
    for param in params:
        try:
            param_file = open(os.path.join(device_path, param), 'r')
            param_value = param_file.read().replace("\n", "").replace("[key]", "")
            param_file.close()
            result[param] = param_value
        except Exception:
            # Probably we just don't have enough permission to read sysfs file
            # logging.warning("Cannot read %s", os.path.join(device_path, param))
            pass
    return result


def scst_set_device_params(device, params):
    device_path = os.path.join(SYSFS_SCST_DEVICES, device)
    for k, v in params.items():
        param_file = open(os.path.join(device_path, k), 'w')
        try:
            param_file.write(v)
        except Exception as e:
            print("Error: {} writing {} to {}".format(e, k, device))
            logging.error("Error: %s writing %s to %s", e, k, device)
        finally:
            param_file.close()


def scst_get_luns():
    result = {}
    targets = scst_get_iscsi_targets()
    for target in targets:
        lun0_path = os.path.join(SYSFS_SCST_ISCSI_TGTS, target,
                                 SYSFS_SCST_LUN0_DEV)
        lun0_device = str(Path(lun0_path).resolve())
        try:
            lun0_filename_file = open(os.path.join(lun0_device, "filename"))
            lun0_filename = lun0_filename_file.read().split("\n")[0]
            lun0_filename_file.close()
            rel_id_path = os.path.join(SYSFS_SCST_ISCSI_TGTS, target,
                                       "rel_tgt_id")
            rel_id_file = open(rel_id_path, 'r')
            rel_id_value = rel_id_file.read().split("\n")[0]
            rel_id_file.close()
            result[lun0_filename] = rel_id_value
        except FileNotFoundError as e:
            logging.error('Error getting LUN info %s Error: %s', lun0_path, e)
            pass
    return result


def scst_get_lun_wwn(lun):
    targets = scst_get_iscsi_targets()
    wwns = {}
    for target in targets:
        rel_id_path = os.path.join(SYSFS_SCST_ISCSI_TGTS, target,
                                   "rel_tgt_id")
        rel_id_file = open(rel_id_path, 'r')
        rel_id_value = rel_id_file.read().split("\n")[0]
        rel_id_file.close()
        wwns[rel_id_value] = target
    try:
        return wwns[lun]
    except KeyError:
        return None


def scst_get_dev_wwn(dev):
    wwns = []
    path_exports = "{}/{}/exported".format(SYSFS_SCST_DEVICES, dev)
    exports = os.listdir(path_exports)
    if len(exports) > 0:
        for export in exports:
            path_export = "{}/{}/exported/{}".format(SYSFS_SCST_DEVICES, dev, export)
            if 'iscsi' in str(Path(path_export).resolve()):
                wwns.append(os.readlink(path_export).split("/")[5])
        if len(wwns) > 0:
            return wwns[0]
        else:
            return None
    else:
        return None


def scst_get_lun_device(lun):
    targets = scst_get_iscsi_targets()
    wwns = {}
    for target in targets:
        rel_id_path = os.path.join(SYSFS_SCST_ISCSI_TGTS, target,
                                   "rel_tgt_id")
        rel_id_file = open(rel_id_path, 'r')
        rel_id_value = rel_id_file.read().split("\n")[0]
        rel_id_file.close()
        wwns[rel_id_value] = target
    if lun in wwns.keys():
        target = wwns[lun]
        lun0_device_path = os.path.join(SYSFS_SCST_ISCSI_TGTS, target,
                                        SYSFS_SCST_LUN0_DEV)
        lun0_device = str(Path(lun0_device_path).resolve())
        lun0_device_name = lun0_device[lun0_device.rfind("/")+1:]
        return lun0_device_name
    else:
        return None


def scst_delete_device(device):
    mgmt_file = open(SYSFS_SCST_DEV_MGMT, "w")
    mgmt_file.write("del_device {}".format(device))
    mgmt_file.close()
    sleep(1)


def scst_add_device(filename):
    if check_zvol(filename):
        logging.info("ZVol %s is OK", filename)
        mgmt_file = open(SYSFS_SCST_DEV_MGMT, "w")
        device_name = filename[filename.rfind("/")+1:]
        command = "add_device {} filename={}; nv_cache=1; rotational=0".format(device_name, filename)
        try:
            mgmt_file.write(command)
        except OSError as e:
            print("OS error: {}".format(e))
            logging.error("OS error: %s", e)
        finally:
            mgmt_file.close()

        device_params = {
            "t10_vend_id": "FREE_TT"
        }
        scst_set_device_params(device_name, device_params)
        return True
    else:
        logging.error("ZVol %s does not exists!", filename)
        return False


def exec_shell_command(command):
    proc = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE,
                            stderr=subprocess.STDOUT)
    stdout, stderr = proc.communicate()
    return stdout.split('\n')


def get_devlist(xml_output=False):
    logging.debug("Command: devlist")
    devlist = []
    luns = scst_get_luns()

    for dev in scst_get_devices():
        dev_params = scst_get_device_params(dev)
        if dev_params['filename']:
            if dev_params['filename'] in luns.keys():
                wwn = scst_get_dev_wwn(dev)
                devlist.append(list(map(lambda x: str(x), [
                    luns[dev_params['filename']],
                    'block',
                    safe_cast(dev_params['size'], int, 0),
                    safe_cast(dev_params['blocksize'], int, 0),
                    dev_params['usn'],
                    dev,
                    dev_params['filename'],
                    wwn,
                    safe_cast(dev_params['threads_num'], int, 0)
                ])))

    if xml_output:
        xml_root = minidom.Document()

        # Used to strip declaration string later
        declaration = xml_root.toxml()

        xml = xml_root.createElement('ctllunlist')
        xml_root.appendChild(xml)
        for dev in devlist:
            lun = xml_root.createElement('lun')
            lun.setAttribute('id', dev[0])
            elem = xml_root.createElement('backend_type')
            text = xml_root.createTextNode(dev[1])
            elem.appendChild(text)
            lun.appendChild(elem)
            elem = xml_root.createElement('lun_type')
            text = xml_root.createTextNode('0')
            elem.appendChild(text)
            lun.appendChild(elem)
            elem = xml_root.createElement('size')
            text = xml_root.createTextNode(dev[2])
            elem.appendChild(text)
            lun.appendChild(elem)
            elem = xml_root.createElement('blocksize')
            text = xml_root.createTextNode(dev[3])
            elem.appendChild(text)
            lun.appendChild(elem)
            elem = xml_root.createElement('serial_number')
            text = xml_root.createTextNode(dev[4])
            elem.appendChild(text)
            lun.appendChild(elem)
            elem = xml_root.createElement('device_id')
            text = xml_root.createTextNode(dev[5])
            elem.appendChild(text)
            lun.appendChild(elem)
            elem = xml_root.createElement('num_threads')
            text = xml_root.createTextNode(dev[8])
            elem.appendChild(text)
            lun.appendChild(elem)
            elem = xml_root.createElement('file')
            text = xml_root.createTextNode(dev[6])
            elem.appendChild(text)
            lun.appendChild(elem)
            elem = xml_root.createElement('ctld_name')
            text = xml_root.createTextNode(','.join([dev[7], 'lun', '0']))
            elem.appendChild(text)
            lun.appendChild(elem)
            xml.appendChild(lun)
        xml_str = xml_root.toprettyxml(indent="\t")[(len(declaration)+1):]
        return xml_str
    else:
        return [dev[0:6] for dev in devlist]


def get_portlist(port=-1, verbose=False, xml_output=False):
    logging.debug("Command: portlist Verbose: %s XML: %s Port: %s", verbose, xml_output, port)
    if verbose:
        portlist = {}
        result = []
        luns = scst_get_luns()
        for k, v in luns.items():
            portlist[v] = {
                'Target': scst_get_dev_wwn(k.split("/")[-1]),
                'LUN 0': v
            }
        try:
            result.append('Target: {}'.format(portlist[str(port)]['Target']))
            result.append('LUN 0: {}'.format(portlist[str(port)]['LUN 0']))
        except KeyError:
            # no such port
            pass
        return result
    else:
        portlist = []
        luns = scst_get_luns()
        for dev in scst_get_devices():
            dev_params = scst_get_device_params(dev)
            if dev_params['filename']:
                if dev_params['filename'] in luns.keys():
                    wwn = scst_get_dev_wwn(dev)
                    portlist.append(list(map(lambda x: str(x), [
                        luns[dev_params['filename']],
                        "YES" if dev_params['active'] == '1' else "NO",
                        "iscsi",
                        "iscsi",
                        "{},t,0x0101".format(wwn),
                        wwn
                    ])))
        if xml_output:
            xml_root = minidom.Document()
            # Used to strip declaration string later
            declaration = xml_root.toxml()

            xml = xml_root.createElement('ctlportlist')
            xml_root.appendChild(xml)
            for port in portlist:
                targ_port = xml_root.createElement('targ_port')
                targ_port.setAttribute('id', port[0])
                elem = xml_root.createElement('lun')
                elem.setAttribute('id', '0')
                text = xml_root.createTextNode(port[0])
                elem.appendChild(text)
                targ_port.appendChild(elem)
                elem = xml_root.createElement('target')
                text = xml_root.createTextNode(port[5])
                elem.appendChild(text)
                targ_port.appendChild(elem)
                elem = xml_root.createElement('initiator')
                initiator = ""
                sessions = scst_get_target_sessions(port[5])
                if sessions:
                    initiator = sessions[0]
                text = xml_root.createTextNode(initiator)
                elem.appendChild(text)
                targ_port.appendChild(elem)
                xml.appendChild(targ_port)
            xml_str = xml_root.toprettyxml(indent="\t")[(len(declaration)+1):]
            return xml_str
        else:
            return [port[0:5] for port in portlist]


def get_islist():
    logging.debug("Command: islist")
    islist = []
    targets = scst_get_iscsi_targets()
    for target in targets:
        sessions = scst_get_target_sessions(target)
        portal = scst_get_portal_addr(target)
        for session in sessions:
            islist.append(list(map(lambda x: str(x), [1, portal,
                          session,
                          target]))
                          )
    return islist


def create_lun(options, deviceid, lun):
    opt_file = options[0].split('=')[1]
    opt_wwn = options[2].split('=')[1].split(',')[0]
    logging.debug(
        "Command: create File: %s WWN: %s Device ID: %s", opt_file, opt_wwn, deviceid)
    if scst_add_device(opt_file):
        mgmt_path = os.path.join(SYSFS_SCST_ISCSI_TGTS, opt_wwn,
                                 SYSFS_SCST_LUNS_MGMT)
        command = "add {} 0".format(deviceid)
        mgmt_file = open(mgmt_path, "w")
        try:
            mgmt_file.write(command)
        except Exception as e:
            logging.error("Cannot write to %s Error: ", e)
        finally:
            mgmt_file.close()
    else:
        logging.error("Cannot create LUN %s", deviceid)
        sys.exit(1)


def remove_lun(lun):
    device = scst_get_lun_device(lun)
    scst_delete_device(device)
    logging.debug("Command: remove LUN: %s", lun)


def print_result(result):
    if type(result) is str:
        print(result)
    else:
        for res in result:
            if type(res) is str:
                print(res)
            else:
                print('\t'.join(res))


def check_zvol(zvol):
    z = Path(zvol)
    return z.exists()


def main(args):
    logging.info("Running %s command", args.command)
    logging.info("Arguments: %s", vars(args))
    if args.command == 'devlist':
        print_result(get_devlist(args.x))
    if args.command == 'islist':
        print_result(get_islist())
    if args.command == 'portlist':
        print_result(get_portlist(args.p, args.v, args.x))
    if args.command == 'create':
        create_lun(args.o, args.d, args.l)
    if args.command == 'remove':
        remove_lun(args.l)


if __name__ == "__main__":
    logging.basicConfig(
        filename='/var/log/ctladm.log', format='%(asctime)s:%(process)d:%(levelname)s:%(message)s',
        level=logging.DEBUG)
    parser = argparse.ArgumentParser(
        description="Linux ctladm for PlayKey zfsapi (SCST)")
    subparsers = parser.add_subparsers(dest='command', help='sub-command help')

    parser_devlist = subparsers.add_parser('devlist', help='list devices')
    parser_devlist.add_argument('-x', action='store_true', help='XML Output')

    parser_islist = subparsers.add_parser('islist', help='list sessions')

    parser_portlist = subparsers.add_parser('portlist', help='list ports')
    parser_portlist.add_argument('-q', action='store_true', help='Omit header')
    parser_portlist.add_argument('-v', action='store_true', help='Verbose')
    parser_portlist.add_argument('-p', type=int, action='store', required=False, help='port number')
    parser_portlist.add_argument('-x', action='store_true', help='XML Output')

    parser_create = subparsers.add_parser('create', help='create port')
    parser_create.add_argument('-b', type=str, action='store', help='Device type')
    parser_create.add_argument('-o', type=str, action='append', help='Create options')
    parser_create.add_argument('-d', type=str, action='store', help='Device ID')
    parser_create.add_argument('-l', type=str, action='store', help='LUN')

    parser_remove = subparsers.add_parser('remove', help='remove port')
    parser_remove.add_argument('-b', type=str, action='store', help='Device type')
    parser_remove.add_argument('-l', type=str, action='store', help='LUN')

    logging.debug('Passed arguments: %s', ' '.join(sys.argv[1:]))
    args = parser.parse_args()
    main(args)