rpc: Break rpc client into individual python files

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'))

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))

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))

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']