From aceeb8cda3bc5bf83c71196da35e6318cdc93cf5 Mon Sep 17 00:00:00 2001 From: heluwei Date: Fri, 8 Jun 2018 02:57:42 +0800 Subject: [PATCH] scripts/rpc.py: pass named args to nvmf.py Modify the /scripts/rpc/nvmf.py methods so that the upper management apps can call these methods more conveniently. There is a example [0] about how the upper application calls these modified methods of the SPDK(/scripts/rpc/nvmf.py). [0]https://github.com/hellowaywewe/call_spdk Change-Id: Idb54643f3416f049f36e9564dc1401eaef66363b Signed-off-by: heluwei Reviewed-on: https://review.gerrithub.io/414296 Tested-by: SPDK Automated Test System Reviewed-by: Daniel Verkamp Reviewed-by: Jim Harris Reviewed-by: Ben Walker --- scripts/rpc.py | 94 ++++++++++++-- scripts/rpc/nvmf.py | 290 +++++++++++++++++++++++++++++++------------- 2 files changed, 288 insertions(+), 96 deletions(-) diff --git a/scripts/rpc.py b/scripts/rpc.py index 85136a373..a5f84bebc 100755 --- a/scripts/rpc.py +++ b/scripts/rpc.py @@ -821,7 +821,13 @@ if __name__ == "__main__": # NVMe-oF @call_cmd def set_nvmf_target_options(args): - rpc.nvmf.set_nvmf_target_options(args.client, args) + rpc.nvmf.set_nvmf_target_options(args.client, + max_queue_depth=args.max_queue_depth, + max_qpairs_per_ctrlr=args.max_qpairs_per_session, + in_capsule_data_size=args.in_capsule_data_size, + max_io_size=args.max_io_size, + max_subsystems=args.max_subsystems, + io_unit_size=args.io_unit_size) p = subparsers.add_parser('set_nvmf_target_options', help='Set NVMf target options') p.add_argument('-q', '--max-queue-depth', help='Max number of outstanding I/O per queue', type=int) @@ -834,7 +840,8 @@ if __name__ == "__main__": @call_cmd def set_nvmf_target_config(args): - rpc.nvmf.set_nvmf_target_config(args.client, args) + rpc.nvmf.set_nvmf_target_config(args.client, + acceptor_poll_rate=args.acceptor_poll_rate) p = subparsers.add_parser('set_nvmf_target_config', help='Set NVMf target config') p.add_argument('-r', '--acceptor-poll-rate', help='How often the acceptor polls for incoming connections', type=int) @@ -842,7 +849,7 @@ if __name__ == "__main__": @call_cmd def get_nvmf_subsystems(args): - print_dict(rpc.nvmf.get_nvmf_subsystems(args.client, args)) + print_dict(rpc.nvmf.get_nvmf_subsystems(args.client)) p = subparsers.add_parser('get_nvmf_subsystems', help='Display nvmf subsystems') @@ -850,7 +857,45 @@ if __name__ == "__main__": @call_cmd def construct_nvmf_subsystem(args): - rpc.nvmf.construct_nvmf_subsystem(args.client, args) + listen_addresses = None + hosts = None + namespaces = None + if args.listen: + listen_addresses = [ + dict( + u.split( + ":", + 1) for u in a.split(" ")) for a in args.listen.split(",")] + + if args.hosts: + hosts = [] + for u in args.hosts.strip().split(" "): + hosts.append(u) + + if args.namespaces: + namespaces = [] + for u in args.namespaces.strip().split(" "): + bdev_name = u + nsid = 0 + if ':' in u: + (bdev_name, nsid) = u.split(":") + + ns_params = {'bdev_name': bdev_name} + + nsid = int(nsid) + if nsid != 0: + ns_params['nsid'] = nsid + + namespaces.append(ns_params) + + rpc.nvmf.construct_nvmf_subsystem(args.client, + nqn=args.nqn, + listen_addresses=listen_addresses, + hosts=hosts, + allow_any_host=args.allow_any_host, + serial_number=args.serial_number, + namespaces=namespaces, + max_namespaces=args.max_namespaces) p = subparsers.add_parser('construct_nvmf_subsystem', help='Add a nvmf subsystem') p.add_argument('nqn', help='Target nqn(ASCII)') @@ -874,7 +919,8 @@ if __name__ == "__main__": @call_cmd def delete_nvmf_subsystem(args): - rpc.nvmf.delete_nvmf_subsystem(args.client, args) + rpc.nvmf.delete_nvmf_subsystem(args.client, + nqn=args.subsystem_nqn) p = subparsers.add_parser('delete_nvmf_subsystem', help='Delete a nvmf subsystem') @@ -884,7 +930,12 @@ if __name__ == "__main__": @call_cmd def nvmf_subsystem_add_listener(args): - rpc.nvmf.nvmf_subsystem_add_listener(args.client, args) + rpc.nvmf.nvmf_subsystem_add_listener(args.client, + nqn=args.nqn, + trtype=args.trtype, + traddr=args.traddr, + adrfam=args.adrfam, + trsvcid=args.trsvcid) p = subparsers.add_parser('nvmf_subsystem_add_listener', help='Add a listener to an NVMe-oF subsystem') p.add_argument('nqn', help='NVMe-oF subsystem NQN') @@ -896,7 +947,12 @@ if __name__ == "__main__": @call_cmd def nvmf_subsystem_remove_listener(args): - rpc.nvmf.nvmf_subsystem_remove_listener(args.client, args) + rpc.nvmf.nvmf_subsystem_remove_listener(args.client, + nqn=args.nqn, + trtype=args.trtype, + traddr=args.traddr, + adrfam=args.adrfam, + trsvcid=args.trsvcid) p = subparsers.add_parser('nvmf_subsystem_remove_listener', help='Remove a listener from an NVMe-oF subsystem') p.add_argument('nqn', help='NVMe-oF subsystem NQN') @@ -908,7 +964,13 @@ if __name__ == "__main__": @call_cmd def nvmf_subsystem_add_ns(args): - rpc.nvmf.nvmf_subsystem_add_ns(args.client, args) + rpc.nvmf.nvmf_subsystem_add_ns(args.client, + nqn=args.nqn, + bdev_name=args.bdev_name, + nsid=args.nsid, + nguid=args.nguid, + eui64=args.eui64, + uuid=args.uuid) p = subparsers.add_parser('nvmf_subsystem_add_ns', help='Add a namespace to an NVMe-oF subsystem') p.add_argument('nqn', help='NVMe-oF subsystem NQN') @@ -921,7 +983,9 @@ if __name__ == "__main__": @call_cmd def nvmf_subsystem_remove_ns(args): - rpc.nvmf.nvmf_subsystem_remove_ns(args.client, args) + rpc.nvmf.nvmf_subsystem_remove_ns(args.client, + nqn=args.nqn, + nsid=args.nsid) p = subparsers.add_parser('nvmf_subsystem_remove_ns', help='Remove a namespace to an NVMe-oF subsystem') p.add_argument('nqn', help='NVMe-oF subsystem NQN') @@ -930,7 +994,9 @@ if __name__ == "__main__": @call_cmd def nvmf_subsystem_add_host(args): - rpc.nvmf.nvmf_subsystem_add_host(args.client, args) + rpc.nvmf.nvmf_subsystem_add_host(args.client, + nqn=args.nqn, + host=args.host) p = subparsers.add_parser('nvmf_subsystem_add_host', help='Add a host to an NVMe-oF subsystem') p.add_argument('nqn', help='NVMe-oF subsystem NQN') @@ -939,7 +1005,9 @@ if __name__ == "__main__": @call_cmd def nvmf_subsystem_remove_host(args): - rpc.nvmf.nvmf_subsystem_remove_host(args.client, args) + rpc.nvmf.nvmf_subsystem_remove_host(args.client, + nqn=args.nqn, + host=args.host) p = subparsers.add_parser('nvmf_subsystem_remove_host', help='Remove a host from an NVMe-oF subsystem') p.add_argument('nqn', help='NVMe-oF subsystem NQN') @@ -948,7 +1016,9 @@ if __name__ == "__main__": @call_cmd def nvmf_subsystem_allow_any_host(args): - rpc.nvmf.nvmf_subsystem_allow_any_host(args.client, args) + rpc.nvmf.nvmf_subsystem_allow_any_host(args.client, + nqn=args.nqn, + disable=args.disable) p = subparsers.add_parser('nvmf_subsystem_allow_any_host', help='Allow any host to connect to the subsystem') p.add_argument('nqn', help='NVMe-oF subsystem NQN') diff --git a/scripts/rpc/nvmf.py b/scripts/rpc/nvmf.py index ba6ce45cf..fb523396c 100755 --- a/scripts/rpc/nvmf.py +++ b/scripts/rpc/nvmf.py @@ -1,153 +1,275 @@ -def set_nvmf_target_options(client, args): + + +def set_nvmf_target_options(client, + max_queue_depth=None, + max_qpairs_per_ctrlr=None, + in_capsule_data_size=None, + max_io_size=None, + max_subsystems=None, + io_unit_size=None): + """Set NVMe-oF target options. + + Args: + max_queue_depth: Max number of outstanding I/O per queue (optional) + max_qpairs_per_ctrlr: Max number of SQ and CQ per controller (optional) + in_capsule_data_size: Maximum in-capsule data size in bytes (optional) + max_io_size: Maximum I/O data size in bytes (optional) + max_subsystems: Maximum number of NVMe-oF subsystems (optional) + io_unit_size: I/O unit size in bytes (optional) + + Returns: + True or False + """ params = {} - if args.max_queue_depth: - params['max_queue_depth'] = args.max_queue_depth - if args.max_qpairs_per_session: - params['max_qpairs_per_session'] = args.max_qpairs_per_session - if args.in_capsule_data_size: - params['in_capsule_data_size'] = args.in_capsule_data_size - if args.max_io_size: - params['max_io_size'] = args.max_io_size - if args.max_subsystems: - params['max_subsystems'] = args.max_subsystems - if args.io_unit_size: - params['io_unit_size'] = args.io_unit_size + if max_queue_depth: + params['max_queue_depth'] = max_queue_depth + if max_qpairs_per_ctrlr: + params['max_qpairs_per_ctrlr'] = max_qpairs_per_ctrlr + if in_capsule_data_size: + params['in_capsule_data_size'] = in_capsule_data_size + if max_io_size: + params['max_io_size'] = max_io_size + if max_subsystems: + params['max_subsystems'] = max_subsystems + if io_unit_size: + params['io_unit_size'] = io_unit_size return client.call('set_nvmf_target_options', params) -def set_nvmf_target_config(client, args): +def set_nvmf_target_config(client, acceptor_poll_rate=None): + """Set NVMe-oF target subsystem configuration. + + Args: + acceptor_poll_rate: Acceptor poll period in microseconds (optional) + + Returns: + True or False + """ params = {} - if args.acceptor_poll_rate: - params['acceptor_poll_rate'] = args.acceptor_poll_rate + if acceptor_poll_rate: + params['acceptor_poll_rate'] = acceptor_poll_rate return client.call('set_nvmf_target_config', params) -def get_nvmf_subsystems(client, args): +def get_nvmf_subsystems(client): + """Get list of NVMe-oF subsystems. + + Returns: + List of NVMe-oF subsystem objects. + """ return client.call('get_nvmf_subsystems') -def construct_nvmf_subsystem(client, args): +def construct_nvmf_subsystem(client, + nqn, + serial_number, + listen_addresses=None, + hosts=None, + allow_any_host=False, + namespaces=None, + max_namespaces=0): + """Construct an NVMe over Fabrics target subsystem. + + Args: + nqn: Subsystem NQN. + serial_number: Serial number of virtual controller. + listen_addresses: Array of listen_address objects (optional). + hosts: Array of strings containing allowed host NQNs (optional). Default: No hosts allowed. + allow_any_host: Allow any host (True) or enforce allowed host whitelist (False). Default: False. + namespaces: Array of namespace objects (optional). Default: No namespaces. + max_namespaces: Maximum number of namespaces that can be attached to the subsystem (optional). Default: 0 (Unlimited). + + Returns: + True or False + """ params = { - 'nqn': args.nqn, - 'serial_number': args.serial_number, + 'nqn': nqn, + 'serial_number': serial_number, } - if args.max_namespaces: - params['max_namespaces'] = args.max_namespaces + if max_namespaces: + params['max_namespaces'] = max_namespaces - if args.listen: - params['listen_addresses'] = [dict(u.split(":", 1) for u in a.split(" ")) - for a in args.listen.split(",")] + if listen_addresses: + params['listen_addresses'] = listen_addresses - if args.hosts: - hosts = [] - for u in args.hosts.strip().split(" "): - hosts.append(u) + if hosts: params['hosts'] = hosts - if args.allow_any_host: + if allow_any_host: params['allow_any_host'] = True - if args.namespaces: - namespaces = [] - for u in args.namespaces.strip().split(" "): - bdev_name = u - nsid = 0 - if ':' in u: - (bdev_name, nsid) = u.split(":") - - ns_params = {'bdev_name': bdev_name} - - nsid = int(nsid) - if nsid != 0: - ns_params['nsid'] = nsid - - namespaces.append(ns_params) + if namespaces: params['namespaces'] = namespaces return client.call('construct_nvmf_subsystem', params) -def nvmf_subsystem_add_listener(client, args): - listen_address = {'trtype': args.trtype, - 'traddr': args.traddr, - 'trsvcid': args.trsvcid} +def nvmf_subsystem_add_listener(client, nqn, trtype, traddr, trsvcid, adrfam): + """Add a new listen address to an NVMe-oF subsystem. - if args.adrfam: - listen_address['adrfam'] = args.adrfam + Args: + nqn: Subsystem NQN. + trtype: Transport type ("RDMA"). + traddr: Transport address. + trsvcid: Transport service ID. + adrfam: Address family ("IPv4", "IPv6", "IB", or "FC"). - params = {'nqn': args.nqn, + Returns: + True or False + """ + listen_address = {'trtype': trtype, + 'traddr': traddr, + 'trsvcid': trsvcid} + + if adrfam: + listen_address['adrfam'] = adrfam + + params = {'nqn': nqn, 'listen_address': listen_address} return client.call('nvmf_subsystem_add_listener', params) -def nvmf_subsystem_remove_listener(client, args): - listen_address = {'trtype': args.trtype, - 'traddr': args.traddr, - 'trsvcid': args.trsvcid} +def nvmf_subsystem_remove_listener( + client, + nqn, + trtype, + traddr, + trsvcid, + adrfam): + """Remove existing listen address from an NVMe-oF subsystem. - if args.adrfam: - listen_address['adrfam'] = args.adrfam + Args: + nqn: Subsystem NQN. + trtype: Transport type ("RDMA"). + traddr: Transport address. + trsvcid: Transport service ID. + adrfam: Address family ("IPv4", "IPv6", "IB", or "FC"). - params = {'nqn': args.nqn, + Returns: + True or False + """ + listen_address = {'trtype': trtype, + 'traddr': traddr, + 'trsvcid': trsvcid} + + if adrfam: + listen_address['adrfam'] = adrfam + + params = {'nqn': nqn, 'listen_address': listen_address} return client.call('nvmf_subsystem_remove_listener', params) -def nvmf_subsystem_add_ns(client, args): - ns = {'bdev_name': args.bdev_name} +def nvmf_subsystem_add_ns(client, nqn, bdev_name, nsid=None, nguid=None, eui64=None, uuid=None): + """Add a namespace to a subsystem. - if args.nsid: - ns['nsid'] = args.nsid + Args: + nqn: Subsystem NQN. + bdev_name: Name of bdev to expose as a namespace. + nsid: Namespace ID (optional). + nguid: 16-byte namespace globally unique identifier in hexadecimal (optional). + eui64: 8-byte namespace EUI-64 in hexadecimal (e.g. "ABCDEF0123456789") (optional). + uuid: Namespace UUID (optional). - if args.nguid: - ns['nguid'] = args.nguid + Returns: + The namespace ID + """ + ns = {'bdev_name': bdev_name} - if args.eui64: - ns['eui64'] = args.eui64 + if nsid: + ns['nsid'] = nsid - if args.uuid: - ns['uuid'] = args.uuid + if nguid: + ns['nguid'] = nguid - params = {'nqn': args.nqn, + if eui64: + ns['eui64'] = eui64 + + if uuid: + ns['uuid'] = uuid + + params = {'nqn': nqn, 'namespace': ns} return client.call('nvmf_subsystem_add_ns', params) -def nvmf_subsystem_remove_ns(client, args): +def nvmf_subsystem_remove_ns(client, nqn, nsid): + """Remove a existing namespace from a subsystem. - params = {'nqn': args.nqn, - 'nsid': args.nsid} + Args: + nqn: Subsystem NQN. + nsid: Namespace ID. + + Returns: + True or False + """ + params = {'nqn': nqn, + 'nsid': nsid} return client.call('nvmf_subsystem_remove_ns', params) -def nvmf_subsystem_add_host(client, args): - params = {'nqn': args.nqn, - 'host': args.host} +def nvmf_subsystem_add_host(client, nqn, host): + """Add a host NQN to the whitelist of allowed hosts. + + Args: + nqn: Subsystem NQN. + host: Host NQN to add to the list of allowed host NQNs + + Returns: + True or False + """ + params = {'nqn': nqn, + 'host': host} return client.call('nvmf_subsystem_add_host', params) -def nvmf_subsystem_remove_host(client, args): - params = {'nqn': args.nqn, - 'host': args.host} +def nvmf_subsystem_remove_host(client, nqn, host): + """Remove a host NQN from the whitelist of allowed hosts. + + Args: + nqn: Subsystem NQN. + host: Host NQN to remove to the list of allowed host NQNs + + Returns: + True or False + """ + params = {'nqn': nqn, + 'host': host} return client.call('nvmf_subsystem_remove_host', params) -def nvmf_subsystem_allow_any_host(client, args): - params = {'nqn': args.nqn} - params['allow_any_host'] = False if args.disable else True +def nvmf_subsystem_allow_any_host(client, nqn, disable): + """Configure a subsystem to allow any host to connect or to enforce the host NQN whitelist. + + Args: + nqn: Subsystem NQN. + disable: Allow any host (true) or enforce allowed host whitelist (false). + + Returns: + True or False + """ + params = {'nqn': nqn, 'allow_any_host': False if disable else True} return client.call('nvmf_subsystem_allow_any_host', params) -def delete_nvmf_subsystem(client, args): - params = {'nqn': args.subsystem_nqn} +def delete_nvmf_subsystem(client, nqn): + """Delete an existing NVMe-oF subsystem. + + Args: + nqn: Subsystem NQN. + + Returns: + True or False + """ + params = {'nqn': nqn} return client.call('delete_nvmf_subsystem', params)