rpc: Break rpc client into individual python files

The top level client is unchanged. This is primarily just
moving code around. The client.py file is the only location
with new code, which converts the old jsonrpc_call function
into a class.

Change-Id: I5fb7cd48f77f6affa3d9439128009bf63148acda
Signed-off-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-on: https://review.gerrithub.io/364316
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>

scripts/rpc/__init__.py

@@ -0,0 +1,15 @@
+import app
+import bdev
+import client
+import iscsi
+import log
+import lvol
+import nbd
+import net
+import nvmf
+import pmem
+import vhost
+
+
+def get_rpc_methods(args):
+    print_dict(args.client.call('get_rpc_methods'))

scripts/rpc/app.py

@@ -0,0 +1,14 @@
+from client import print_dict, print_array, int_arg
+
+
+def kill_instance(args):
+    params = {'sig_name': args.sig_name}
+    args.client.call('kill_instance', params, verbose=args.verbose)
+
+def context_switch_monitor(args):
+    params = {}
+    if args.enable:
+        params['enabled'] = True
+    if args.disable:
+        params['enabled'] = False
+    print_dict(args.client.call('context_switch_monitor', params))

scripts/rpc/bdev.py

@@ -0,0 +1,99 @@
+from client import print_dict, print_array, int_arg
+
+
+def construct_malloc_bdev(args):
+    num_blocks = (args.total_size * 1024 * 1024) / args.block_size
+    params = {'num_blocks': num_blocks, 'block_size': args.block_size}
+    if args.name:
+        params['name'] = args.name
+    print_array(args.client.call(
+        'construct_malloc_bdev', params, verbose=args.verbose))
+
+
+def construct_null_bdev(args):
+    num_blocks = (args.total_size * 1024 * 1024) / args.block_size
+    params = {'name': args.name, 'num_blocks': num_blocks,
+              'block_size': args.block_size}
+    print_array(args.client.call(
+        'construct_null_bdev', params, verbose=args.verbose))
+
+
+def construct_aio_bdev(args):
+    params = {'name': args.name,
+              'filename': args.filename}
+
+    if args.block_size:
+        params['block_size'] = args.block_size
+
+    print_array(args.client.call(
+        'construct_aio_bdev', params, verbose=args.verbose))
+
+
+def construct_nvme_bdev(args):
+    params = {'name': args.name,
+              'trtype': args.trtype,
+              'traddr': args.traddr}
+
+    if args.adrfam:
+        params['adrfam'] = args.adrfam
+
+    if args.trsvcid:
+        params['trsvcid'] = args.trsvcid
+
+    if args.subnqn:
+        params['subnqn'] = args.subnqn
+
+    args.client.call('construct_nvme_bdev', params, verbose=args.verbose)
+
+
+def construct_rbd_bdev(args):
+    params = {
+        'pool_name': args.pool_name,
+        'rbd_name': args.rbd_name,
+        'block_size': args.block_size,
+    }
+    print_array(args.client.call(
+        'construct_rbd_bdev', params, verbose=args.verbose))
+
+
+def construct_error_bdev(args):
+    params = {'base_name': args.base_name}
+    args.client.call('construct_error_bdev', params, verbose=args.verbose)
+
+
+def construct_pmem_bdev(args):
+    params = {
+        'pmem_file': args.pmem_file,
+        'name': args.name
+    }
+    print_array(args.client.call('construct_pmem_bdev', params))
+
+
+def get_bdevs(args):
+    params = {}
+    if args.name:
+        params['name'] = args.name
+    print_dict(args.client.call('get_bdevs', params))
+
+
+def delete_bdev(args):
+    params = {'name': args.bdev_name}
+    args.client.call('delete_bdev', params, verbose=args.verbose)
+
+
+def bdev_inject_error(args):
+    params = {
+        'name': args.name,
+        'io_type': args.io_type,
+        'error_type': args.error_type,
+        'num': args.num,
+    }
+
+    args.client.call('bdev_inject_error', params, verbose=args.verbose)
+
+def apply_firmware(args):
+    params = {
+        'filename': args.filename,
+        'bdev_name': args.bdev_name,
+    }
+    print_dict(args.client.call('apply_nvme_firmware', params))

scripts/rpc/client.py

@@ -0,0 +1,81 @@
+import json
+import socket
+
+try:
+    from shlex import quote
+except ImportError:
+    from pipes import quote
+
+
+def print_dict(d):
+    print json.dumps(d, indent=2)
+
+
+def print_array(a):
+    print " ".join((quote(v) for v in a))
+
+
+def int_arg(arg):
+    return int(arg, 0)
+
+
+class JSONRPCClient(object):
+    def __init__(self, addr, port=None):
+        if addr.startswith('/'):
+            self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            self.sock.connect(addr)
+        else:
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.sock.connect((addr, port))
+
+    def __del__(self):
+        self.sock.close()
+
+    def call(self, method, params={}, verbose=False):
+        req = {}
+        req['jsonrpc'] = '2.0'
+        req['method'] = method
+        req['id'] = 1
+        if (params):
+            req['params'] = params
+        reqstr = json.dumps(req)
+
+        if verbose:
+            print("request:")
+            print(json.dumps(req, indent=2))
+
+        self.sock.sendall(reqstr)
+        buf = ''
+        closed = False
+        response = {}
+        while not closed:
+            newdata = self.sock.recv(4096)
+            if (newdata == b''):
+                closed = True
+            buf += newdata
+            try:
+                response = json.loads(buf)
+            except ValueError:
+                continue  # incomplete response; keep buffering
+            break
+
+        if not response:
+            if method == "kill_instance":
+                exit(0)
+            print "Connection closed with partial response:"
+            print buf
+            exit(1)
+
+        if 'error' in response:
+            print "Got JSON-RPC error response"
+            print "request:"
+            print_dict(json.loads(reqstr))
+            print "response:"
+            print_dict(response['error'])
+            exit(1)
+
+        if verbose:
+            print("response:")
+            print(json.dumps(response, indent=2))
+
+        return response['result']

scripts/rpc/iscsi.py

@@ -0,0 +1,147 @@
+from client import print_dict, print_array, int_arg
+
+
+def get_luns(args):
+    print_dict(args.client.call('get_luns', verbose=args.verbose))
+
+
+def get_portal_groups(args):
+    print_dict(args.client.call('get_portal_groups', verbose=args.verbose))
+
+
+def get_initiator_groups(args):
+    print_dict(args.client.call('get_initiator_groups', verbose=args.verbose))
+
+
+def get_target_nodes(args):
+    print_dict(args.client.call('get_target_nodes', verbose=args.verbose))
+
+
+def construct_target_node(args):
+    bdev_name_id_dict = dict(u.split(":") for u in args.bdev_name_id_pairs.strip().split(" "))
+    bdev_names = bdev_name_id_dict.keys()
+    lun_ids = list(map(int, bdev_name_id_dict.values()))
+
+    pg_tags = []
+    ig_tags = []
+    for u in args.pg_ig_mappings.strip().split(" "):
+        pg, ig = u.split(":")
+        pg_tags.append(int(pg))
+        ig_tags.append(int(ig))
+
+    params = {
+        'name': args.name,
+        'alias_name': args.alias_name,
+        'pg_tags': pg_tags,
+        'ig_tags': ig_tags,
+        'bdev_names': bdev_names,
+        'lun_ids': lun_ids,
+        'queue_depth': args.queue_depth,
+        'chap_disabled': args.chap_disabled,
+        'chap_required': args.chap_required,
+        'chap_mutual': args.chap_mutual,
+        'chap_auth_group': args.chap_auth_group,
+    }
+
+    if args.header_digest:
+        params['header_digest'] = args.header_digest
+    if args.data_digest:
+        params['data_digest'] = args.data_digest
+    args.client.call('construct_target_node', params, verbose=args.verbose)
+
+
+def target_node_add_lun(args):
+    params = {
+        'name': args.name,
+        'bdev_name': args.bdev_name,
+    }
+    if args.lun_id:
+        params['lun_id'] = args.lun_id
+    args.client.call('target_node_add_lun', params)
+
+
+def delete_pg_ig_maps(args):
+    pg_tags = []
+    ig_tags = []
+    for u in args.pg_ig_mappings.strip().split(" "):
+        pg, ig = u.split(":")
+        pg_tags.append(int(pg))
+        ig_tags.append(int(ig))
+    params = {
+        'name': args.name,
+        'pg_tags': pg_tags,
+        'ig_tags': ig_tags,
+    }
+    args.client.call('delete_pg_ig_maps', params)
+
+
+def add_pg_ig_maps(args):
+    pg_tags = []
+    ig_tags = []
+    for u in args.pg_ig_mappings.strip().split(" "):
+        pg, ig = u.split(":")
+        pg_tags.append(int(pg))
+        ig_tags.append(int(ig))
+    params = {
+        'name': args.name,
+        'pg_tags': pg_tags,
+        'ig_tags': ig_tags,
+    }
+    args.client.call('add_pg_ig_maps', params)
+
+
+def add_portal_group(args):
+    # parse out portal list host1:port1 host2:port2
+    portals = []
+    for p in args.portal_list:
+        ip, separator, port_cpumask = p.rpartition(':')
+        split_port_cpumask = port_cpumask.split('@')
+        if len(split_port_cpumask) == 1:
+            port = port_cpumask
+            portals.append({'host': ip, 'port': port})
+        else:
+            port = split_port_cpumask[0]
+            cpumask = split_port_cpumask[1]
+            portals.append({'host': ip, 'port': port, 'cpumask': cpumask})
+
+    params = {'tag': args.tag, 'portals': portals}
+    args.client.call('add_portal_group', params, verbose=args.verbose)
+
+
+def add_initiator_group(args):
+    initiators = []
+    netmasks = []
+    for i in args.initiator_list.strip().split(' '):
+        initiators.append(i)
+    for n in args.netmask_list.strip().split(' '):
+        netmasks.append(n)
+
+    params = {'tag': args.tag, 'initiators': initiators, 'netmasks': netmasks}
+    args.client.call('add_initiator_group', params, verbose=args.verbose)
+
+
+def delete_target_node(args):
+    params = {'name': args.target_node_name}
+    args.client.call('delete_target_node', params, verbose=args.verbose)
+
+
+def delete_portal_group(args):
+    params = {'tag': args.tag}
+    args.client.call('delete_portal_group', params, verbose=args.verbose)
+
+
+def delete_initiator_group(args):
+    params = {'tag': args.tag}
+    args.client.call('delete_initiator_group', params, verbose=args.verbose)
+
+
+def get_iscsi_connections(args):
+    print_dict(args.client.call('get_iscsi_connections', verbose=args.verbose))
+
+
+def get_iscsi_global_params(args):
+    print_dict(args.client.call('get_iscsi_global_params'))
+
+
+def get_scsi_devices(args):
+    print_dict(args.client.call('get_scsi_devices', verbose=args.verbose))

scripts/rpc/log.py

@@ -0,0 +1,33 @@
+from client import print_dict, print_array, int_arg
+
+
+def set_trace_flag(args):
+    params = {'flag': args.flag}
+    args.client.call('set_trace_flag', params, verbose=args.verbose)
+
+
+def clear_trace_flag(args):
+    params = {'flag': args.flag}
+    args.client.call('clear_trace_flag', params, verbose=args.verbose)
+
+
+def get_trace_flags(args):
+    print_dict(args.client.call('get_trace_flags', verbose=args.verbose))
+
+
+def set_log_level(args):
+    params = {'level': args.level}
+    args.client.call('set_log_level', params)
+
+
+def get_log_level(args):
+    print_dict(args.client.call('get_log_level'))
+
+
+def set_log_print_level(args):
+    params = {'level': args.level}
+    args.client.call('set_log_print_level', params)
+
+
+def get_log_print_level(args):
+    print_dict(args.client.call('get_log_print_level'))

scripts/rpc/lvol.py

@@ -0,0 +1,47 @@
+from client import print_dict, print_array, int_arg
+
+
+def construct_lvol_store(args):
+    params = {'bdev_name': args.bdev_name, 'lvs_name': args.lvs_name}
+    if args.cluster_sz:
+        params['cluster_sz'] = args.cluster_sz
+    print_array(args.client.call('construct_lvol_store', params))
+
+
+def construct_lvol_bdev(args):
+    num_bytes = (args.size * 1024 * 1024)
+    params = {'lvol_name': args.lvol_name, 'size': num_bytes}
+    if (args.uuid and args.lvs_name) or (not args.uuid and not args.lvs_name):
+        print("You need to specify either uuid or name of lvolstore")
+    else:
+        if args.uuid:
+            params['uuid'] = args.uuid
+        if args.lvs_name:
+            params['lvs_name'] = args.lvs_name
+        print_array(args.client.call('construct_lvol_bdev', params))
+
+
+# Logical volume resize feature is disabled, as it is currently work in progress
+#
+# def resize_lvol_bdev(args):
+#     params = {
+#         'name': args.name,
+#         'size': args.size,
+#     }
+#     args.client.call('resize_lvol_bdev', params)
+
+
+def destroy_lvol_store(args):
+    params = {}
+    if (args.uuid and args.lvs_name) or (not args.uuid and not args.lvs_name):
+        print("You need to specify either uuid or name of lvolstore")
+    else:
+        if args.uuid:
+            params['uuid'] = args.uuid
+        if args.lvs_name:
+            params['lvs_name'] = args.lvs_name
+        args.client.call('destroy_lvol_store', params)
+
+
+def get_lvol_stores(args):
+    print_dict(args.client.call('get_lvol_stores'))

scripts/rpc/nbd.py

@@ -0,0 +1,21 @@
+from client import print_dict, print_array, int_arg
+
+
+def start_nbd_disk(args):
+    params = {
+        'bdev_name': args.bdev_name,
+        'nbd_device': args.nbd_device
+    }
+    args.client.call('start_nbd_disk', params)
+
+
+def stop_nbd_disk(args):
+    params = {'nbd_device': args.nbd_device}
+    args.client.call('stop_nbd_disk', params)
+
+
+def get_nbd_disks(args):
+    params = {}
+    if args.nbd_device:
+        params['nbd_device'] = args.nbd_device
+    print_dict(args.client.call('get_nbd_disks', params))

scripts/rpc/net.py

@@ -0,0 +1,15 @@
+from client import print_dict, print_array, int_arg
+
+
+def add_ip_address(args):
+    params = {'ifc_index': args.ifc_index, 'ip_address': args.ip_addr}
+    args.client.call('add_ip_address', params, verbose=args.verbose)
+
+
+def delete_ip_address(args):
+    params = {'ifc_index': args.ifc_index, 'ip_address': args.ip_addr}
+    args.client.call('delete_ip_address', params, verbose=args.verbose)
+
+
+def get_interfaces(args):
+    print_dict(args.client.call('get_interfaces', verbose=args.verbose))

scripts/rpc/nvmf.py

@@ -0,0 +1,49 @@
+from client import print_dict, print_array, int_arg
+
+
+def get_nvmf_subsystems(args):
+    print_dict(args.client.call('get_nvmf_subsystems', verbose=args.verbose))
+
+
+def construct_nvmf_subsystem(args):
+    listen_addresses = [dict(u.split(":") for u in a.split(" "))
+                        for a in args.listen.split(",")]
+
+    params = {
+        'nqn': args.nqn,
+        'listen_addresses': listen_addresses,
+        'serial_number': args.serial_number,
+    }
+
+    if args.hosts:
+        hosts = []
+        for u in args.hosts.strip().split(" "):
+            hosts.append(u)
+        params['hosts'] = hosts
+
+    if args.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)
+        params['namespaces'] = namespaces
+
+    args.client.call('construct_nvmf_subsystem', params, verbose=args.verbose)
+
+
+def delete_nvmf_subsystem(args):
+    params = {'nqn': args.subsystem_nqn}
+    args.client.call('delete_nvmf_subsystem', params, verbose=args.verbose)

scripts/rpc/pmem.py

@@ -0,0 +1,19 @@
+from client import print_dict, print_array, int_arg
+
+
+def create_pmem_pool(args):
+    num_blocks = (args.total_size * 1024 * 1024) / args.block_size
+    params = {'pmem_file': args.pmem_file,
+              'num_blocks': num_blocks,
+              'block_size': args.block_size}
+    args.client.call('create_pmem_pool', params)
+
+
+def pmem_pool_info(args):
+    params = {'pmem_file': args.pmem_file}
+    print_dict(args.client.call('pmem_pool_info', params))
+
+
+def delete_pmem_pool(args):
+    params = {'pmem_file': args.pmem_file}
+    args.client.call('delete_pmem_pool', params)

scripts/rpc/vhost.py

@@ -0,0 +1,81 @@
+from client import print_dict, print_array, int_arg
+
+def set_vhost_controller_coalescing(args):
+    params = {
+        'ctrlr': args.ctrlr,
+        'delay_base_us': args.delay_base_us,
+        'iops_threshold': args.iops_threshold,
+    }
+    args.client.call('set_vhost_controller_coalescing', params)
+
+def construct_vhost_scsi_controller(args):
+    params = {'ctrlr': args.ctrlr}
+
+    if args.cpumask:
+        params['cpumask'] = args.cpumask
+
+    args.client.call('construct_vhost_scsi_controller',
+                     params, verbose=args.verbose)
+
+
+def add_vhost_scsi_lun(args):
+    params = {
+        'ctrlr': args.ctrlr,
+        'bdev_name': args.bdev_name,
+        'scsi_target_num': args.scsi_target_num
+    }
+    args.client.call('add_vhost_scsi_lun', params, verbose=args.verbose)
+
+
+def remove_vhost_scsi_target(args):
+    params = {
+        'ctrlr': args.ctrlr,
+        'scsi_target_num': args.scsi_target_num
+    }
+    args.client.call('remove_vhost_scsi_target', params)
+
+
+def construct_vhost_blk_controller(args):
+    params = {
+        'ctrlr': args.ctrlr,
+        'dev_name': args.dev_name,
+    }
+    if args.cpumask:
+        params['cpumask'] = args.cpumask
+    if args.readonly:
+        params['readonly'] = args.readonly
+    args.client.call('construct_vhost_blk_controller', params)
+
+
+def get_vhost_controllers(args):
+    print_dict(args.client.call('get_vhost_controllers'))
+
+
+def remove_vhost_controller(args):
+    params = {'ctrlr': args.ctrlr}
+    args.client.call('remove_vhost_controller', params)
+
+
+def construct_virtio_user_scsi_bdev(args):
+    params = {
+        'path': args.path,
+        'name': args.name,
+    }
+    if args.vq_count:
+        params['vq_count'] = args.vq_count
+    if args.vq_size:
+        params['vq_size'] = args.vq_size
+    print_dict(args.client.call('construct_virtio_user_scsi_bdev', params))
+
+
+def construct_virtio_pci_scsi_bdev(args):
+    params = {
+        'pci_address': args.pci_address,
+        'name': args.name,
+    }
+    print_dict(args.client.call('construct_virtio_pci_scsi_bdev', params))
+
+
+def remove_virtio_scsi_bdev(args):
+    params = {'name': args.name}
+    args.client.call('remove_virtio_scsi_bdev', params)