[ceph.git] / ceph / src / spdk / test / lvol / rpc_commands_lib.py

import json
import sys
from uuid import UUID
from subprocess import check_output, CalledProcessError


class Spdk_Rpc(object):
    def __init__(self, rpc_py):
        self.rpc_py = rpc_py

    def __getattr__(self, name):
        def call(*args):
            cmd = "{} {} {}".format(sys.executable, self.rpc_py, name)
            for arg in args:
                cmd += " {}".format(arg)
            try:
                output = check_output(cmd, shell=True)
                return output.decode('ascii').rstrip('\n'), 0
            except CalledProcessError as e:
                print("ERROR: RPC Command {cmd} "
                      "execution failed:". format(cmd=cmd))
                print("Failed command output:")
                print(e.output)
                return e.output.decode('ascii'), e.returncode
        return call


class Commands_Rpc(object):
    def __init__(self, rpc_py):
        self.rpc = Spdk_Rpc(rpc_py)

    def check_get_bdevs_methods(self, uuid_bdev, bdev_size_mb, bdev_alias=""):
        print("INFO: Check RPC COMMAND get_bdevs")
        output = self.rpc.get_bdevs()[0]
        json_value = json.loads(output)
        for i in range(len(json_value)):
            uuid_json = json_value[i]['name']
            aliases = json_value[i]['aliases']

            if uuid_bdev in [uuid_json]:
                print("Info: UUID:{uuid} is found in RPC Command: "
                      "gets_bdevs response".format(uuid=uuid_bdev))
                # Check if human-friendly alias is as expected
                if bdev_alias and aliases:
                    if bdev_alias not in aliases:
                        print("ERROR: Expected bdev alias not found")
                        print("Expected: {name}".format(name=bdev_alias))
                        print("Actual: {aliases}".format(aliases=aliases))
                        return 1
                # num_block and block_size have values in bytes
                num_blocks = json_value[i]['num_blocks']
                block_size = json_value[i]['block_size']
                if num_blocks * block_size == bdev_size_mb * 1024 * 1024:
                    print("Info: Response get_bdevs command is "
                          "correct. Params: uuid_bdevs: {uuid}, bdev_size "
                          "{size}".format(uuid=uuid_bdev,
                                          size=bdev_size_mb))
                    return 0
        print("INFO: UUID:{uuid} or bdev_size:{bdev_size_mb} not found in "
              "RPC COMMAND get_bdevs: "
              "{json_value}".format(uuid=uuid_bdev, bdev_size_mb=bdev_size_mb,
                                    json_value=json_value))
        return 1

    def check_get_lvol_stores(self, base_name, uuid, cluster_size=None, lvs_name=""):
        print("INFO: RPC COMMAND get_lvol_stores")
        json_value = self.get_lvol_stores()
        if json_value:
            for i in range(len(json_value)):
                json_uuid = json_value[i]['uuid']
                json_cluster = json_value[i]['cluster_size']
                json_base_name = json_value[i]['base_bdev']
                json_name = json_value[i]['name']

                if base_name in json_base_name \
                        and uuid in json_uuid:
                    print("INFO: base_name:{base_name} is found in RPC "
                          "Command: get_lvol_stores "
                          "response".format(base_name=base_name))
                    print("INFO: UUID:{uuid} is found in RPC Command: "
                          "get_lvol_stores response".format(uuid=uuid))
                    if cluster_size:
                        if str(cluster_size) in str(json_cluster):
                            print("Info: Cluster size :{cluster_size} is found in RPC "
                                  "Command: get_lvol_stores "
                                  "response".format(cluster_size=cluster_size))
                        else:
                            print("ERROR: Wrong cluster size in lvol store")
                            print("Expected:".format(cluster_size))
                            print("Actual:".format(json_cluster))
                            return 1

                    # Also check name if param is provided:
                    if lvs_name:
                        if lvs_name not in json_name:
                            print("ERROR: Lvol store human-friendly name does not match")
                            print("Expected: {lvs_name}".format(lvs_name=lvs_name))
                            print("Actual: {name}".format(name=json_name))
                            return 1
                    return 0
            print("FAILED: UUID: lvol store {uuid} on base_bdev: "
                  "{base_name} not found in get_lvol_stores()".format(uuid=uuid,
                                                                      base_name=base_name))
            return 1
        else:
            print("INFO: Lvol store not exist")
            return 2
        return 0

    def construct_malloc_bdev(self, total_size, block_size):
        print("INFO: RPC COMMAND construct_malloc_bdev")
        output = self.rpc.construct_malloc_bdev(total_size, block_size)[0]
        return output.rstrip('\n')

    def construct_lvol_store(self, base_name, lvs_name, cluster_size=None, clear_method=None):
        print("INFO: RPC COMMAND construct_lvol_store")
        if cluster_size:
            output = self.rpc.construct_lvol_store(base_name,
                                                   lvs_name,
                                                   "-c {cluster_sz}".format(cluster_sz=cluster_size))[0]
        elif clear_method:
            output = self.rpc.construct_lvol_store(base_name,
                                                   lvs_name,
                                                   "--clear-method {clear_m}".format(clear_m=clear_method))[0]
        else:
            output = self.rpc.construct_lvol_store(base_name, lvs_name)[0]
        return output.rstrip('\n')

    def construct_lvol_bdev(self, uuid, lbd_name, size, thin=False):
        print("INFO: RPC COMMAND construct_lvol_bdev")
        try:
            uuid_obj = UUID(uuid)
            name_opt = "-u"
        except ValueError:
            name_opt = "-l"
        thin_provisioned = ""
        if thin:
            thin_provisioned = "-t"
        output = self.rpc.construct_lvol_bdev(name_opt, uuid, lbd_name, size, thin_provisioned)[0]
        return output.rstrip('\n')

    def destroy_lvol_store(self, uuid):
        print("INFO: RPC COMMAND destroy_lvol_store")
        try:
            uuid_obj = UUID(uuid)
            name_opt = "-u"
        except ValueError:
            name_opt = "-l"
        output, rc = self.rpc.destroy_lvol_store(name_opt, uuid)
        return rc

    def delete_malloc_bdev(self, base_name):
        print("INFO: RPC COMMAND delete_malloc_bdev")
        output, rc = self.rpc.delete_malloc_bdev(base_name)
        return rc

    def destroy_lvol_bdev(self, bdev_name):
        print("INFO: RPC COMMAND destroy_lvol_bdev")
        output, rc = self.rpc.destroy_lvol_bdev(bdev_name)
        return rc

    def resize_lvol_bdev(self, uuid, new_size):
        print("INFO: RPC COMMAND resize_lvol_bdev")
        output, rc = self.rpc.resize_lvol_bdev(uuid, new_size)
        return rc

    def set_read_only_lvol_bdev(self, uuid):
        print("INFO: RPC COMMAND set_read_only_lvol_bdev")
        output, rc = self.rpc.set_read_only_lvol_bdev(uuid)
        return rc

    def start_nbd_disk(self, bdev_name, nbd_name):
        print("INFO: RPC COMMAND start_nbd_disk")
        output, rc = self.rpc.start_nbd_disk(bdev_name, nbd_name)
        return rc

    def stop_nbd_disk(self, nbd_name):
        print("INFO: RPC COMMAND stop_nbd_disk")
        output, rc = self.rpc.stop_nbd_disk(nbd_name)
        return rc

    def get_lvol_stores(self, name=None):
        print("INFO: RPC COMMAND get_lvol_stores")
        if name:
            output = json.loads(self.rpc.get_lvol_stores("-l", name)[0])
        else:
            output = json.loads(self.rpc.get_lvol_stores()[0])
        return output

    def get_lvol_bdevs(self):
        print("INFO: RPC COMMAND get_bdevs; lvol bdevs only")
        output = []
        rpc_output = json.loads(self.rpc.get_bdevs()[0])
        for bdev in rpc_output:
            if bdev["product_name"] == "Logical Volume":
                output.append(bdev)
        return output

    def get_lvol_bdev_with_name(self, name):
        print("INFO: RPC COMMAND get_bdevs; lvol bdevs only")
        rpc_output = json.loads(self.rpc.get_bdevs("-b", name)[0])
        if len(rpc_output) > 0:
            return rpc_output[0]

        return None

    def rename_lvol_store(self, old_name, new_name):
        print("INFO: Renaming lvol store from {old} to {new}".format(old=old_name, new=new_name))
        output, rc = self.rpc.rename_lvol_store(old_name, new_name)
        return rc

    def rename_lvol_bdev(self, old_name, new_name):
        print("INFO: Renaming lvol bdev from {old} to {new}".format(old=old_name, new=new_name))
        output, rc = self.rpc.rename_lvol_bdev(old_name, new_name)
        return rc

    def snapshot_lvol_bdev(self, bdev_name, snapshot_name):
        print("INFO: RPC COMMAND snapshot_lvol_bdev")
        output, rc = self.rpc.snapshot_lvol_bdev(bdev_name, snapshot_name)
        return rc

    def clone_lvol_bdev(self, snapshot_name, clone_name):
        print("INFO: RPC COMMAND clone_lvol_bdev")
        output, rc = self.rpc.clone_lvol_bdev(snapshot_name, clone_name)
        return rc

    def inflate_lvol_bdev(self, clone_name):
        print("INFO: RPC COMMAND inflate_lvol_bdev")
        output, rc = self.rpc.inflate_lvol_bdev(clone_name)
        return rc

    def decouple_parent_lvol_bdev(self, clone_name):
        print("INFO: RPC COMMAND decouple_parent_lvol_bdev")
        output, rc = self.rpc.decouple_parent_lvol_bdev(clone_name)
        return rc

    def construct_aio_bdev(self, aio_path, aio_name, aio_bs=""):
        print("INFO: RPC COMMAND construct_aio_bdev")
        output, rc = self.rpc.construct_aio_bdev(aio_path, aio_name, aio_bs)
        return rc

    def delete_aio_bdev(self, aio_name):
        print("INFO: RPC COMMAND delete_aio_bdev")
        output, rc = self.rpc.delete_aio_bdev(aio_name)
        return rc
Commit	Line	Data
11fdf7f2 TL	1	import json
	2	import sys
	3	from uuid import UUID
	4	from subprocess import check_output, CalledProcessError
	5
	6
	7	class Spdk_Rpc(object):
	8	def __init__(self, rpc_py):
	9	self.rpc_py = rpc_py
	10
	11	def __getattr__(self, name):
	12	def call(*args):
	13	cmd = "{} {} {}".format(sys.executable, self.rpc_py, name)
	14	for arg in args:
	15	cmd += " {}".format(arg)
	16	try:
	17	output = check_output(cmd, shell=True)
	18	return output.decode('ascii').rstrip('\n'), 0
	19	except CalledProcessError as e:
	20	print("ERROR: RPC Command {cmd} "
	21	"execution failed:". format(cmd=cmd))
	22	print("Failed command output:")
	23	print(e.output)
	24	return e.output.decode('ascii'), e.returncode
	25	return call
	26
	27
	28	class Commands_Rpc(object):
	29	def __init__(self, rpc_py):
	30	self.rpc = Spdk_Rpc(rpc_py)
	31
	32	def check_get_bdevs_methods(self, uuid_bdev, bdev_size_mb, bdev_alias=""):
	33	print("INFO: Check RPC COMMAND get_bdevs")
	34	output = self.rpc.get_bdevs()[0]
	35	json_value = json.loads(output)
	36	for i in range(len(json_value)):
	37	uuid_json = json_value[i]['name']
	38	aliases = json_value[i]['aliases']
	39
	40	if uuid_bdev in [uuid_json]:
	41	print("Info: UUID:{uuid} is found in RPC Command: "
	42	"gets_bdevs response".format(uuid=uuid_bdev))
	43	# Check if human-friendly alias is as expected
	44	if bdev_alias and aliases:
	45	if bdev_alias not in aliases:
	46	print("ERROR: Expected bdev alias not found")
	47	print("Expected: {name}".format(name=bdev_alias))
	48	print("Actual: {aliases}".format(aliases=aliases))
	49	return 1
	50	# num_block and block_size have values in bytes
	51	num_blocks = json_value[i]['num_blocks']
	52	block_size = json_value[i]['block_size']
	53	if num_blocks * block_size == bdev_size_mb * 1024 * 1024:
	54	print("Info: Response get_bdevs command is "
	55	"correct. Params: uuid_bdevs: {uuid}, bdev_size "
	56	"{size}".format(uuid=uuid_bdev,
	57	size=bdev_size_mb))
	58	return 0
	59	print("INFO: UUID:{uuid} or bdev_size:{bdev_size_mb} not found in "
	60	"RPC COMMAND get_bdevs: "
	61	"{json_value}".format(uuid=uuid_bdev, bdev_size_mb=bdev_size_mb,
	62	json_value=json_value))
	63	return 1
	64
65	def check_get_lvol_stores(self, base_name, uuid, cluster_size=None, lvs_name=""):
66	print("INFO: RPC COMMAND get_lvol_stores")
67	json_value = self.get_lvol_stores()
68	if json_value:
69	for i in range(len(json_value)):
70	json_uuid = json_value[i]['uuid']
71	json_cluster = json_value[i]['cluster_size']
72	json_base_name = json_value[i]['base_bdev']
73	json_name = json_value[i]['name']
74
75	if base_name in json_base_name \
76	and uuid in json_uuid:
77	print("INFO: base_name:{base_name} is found in RPC "
78	"Command: get_lvol_stores "
79	"response".format(base_name=base_name))
80	print("INFO: UUID:{uuid} is found in RPC Command: "
81	"get_lvol_stores response".format(uuid=uuid))
82	if cluster_size:
83	if str(cluster_size) in str(json_cluster):
84	print("Info: Cluster size :{cluster_size} is found in RPC "
85	"Command: get_lvol_stores "
86	"response".format(cluster_size=cluster_size))
87	else:
88	print("ERROR: Wrong cluster size in lvol store")
89	print("Expected:".format(cluster_size))
90	print("Actual:".format(json_cluster))
91	return 1
92
93	# Also check name if param is provided:
94	if lvs_name:
95	if lvs_name not in json_name:
96	print("ERROR: Lvol store human-friendly name does not match")
97	print("Expected: {lvs_name}".format(lvs_name=lvs_name))
98	print("Actual: {name}".format(name=json_name))
99	return 1
100	return 0
101	print("FAILED: UUID: lvol store {uuid} on base_bdev: "
102	"{base_name} not found in get_lvol_stores()".format(uuid=uuid,
103	base_name=base_name))
104	return 1
105	else:
106	print("INFO: Lvol store not exist")
107	return 2
108	return 0
109
110	def construct_malloc_bdev(self, total_size, block_size):
111	print("INFO: RPC COMMAND construct_malloc_bdev")
112	output = self.rpc.construct_malloc_bdev(total_size, block_size)[0]
113	return output.rstrip('\n')
114
9f95a23c	115	def construct_lvol_store(self, base_name, lvs_name, cluster_size=None, clear_method=None):
11fdf7f2 TL	116	print("INFO: RPC COMMAND construct_lvol_store")
	117	if cluster_size:
	118	output = self.rpc.construct_lvol_store(base_name,
	119	lvs_name,
	120	"-c {cluster_sz}".format(cluster_sz=cluster_size))[0]
9f95a23c TL	121	elif clear_method:
	122	output = self.rpc.construct_lvol_store(base_name,
	123	lvs_name,
	124	"--clear-method {clear_m}".format(clear_m=clear_method))[0]
11fdf7f2 TL	125	else:
	126	output = self.rpc.construct_lvol_store(base_name, lvs_name)[0]
	127	return output.rstrip('\n')
	128
	129	def construct_lvol_bdev(self, uuid, lbd_name, size, thin=False):
	130	print("INFO: RPC COMMAND construct_lvol_bdev")
	131	try:
	132	uuid_obj = UUID(uuid)
	133	name_opt = "-u"
	134	except ValueError:
	135	name_opt = "-l"
	136	thin_provisioned = ""
	137	if thin:
	138	thin_provisioned = "-t"
	139	output = self.rpc.construct_lvol_bdev(name_opt, uuid, lbd_name, size, thin_provisioned)[0]
	140	return output.rstrip('\n')
	141
	142	def destroy_lvol_store(self, uuid):
	143	print("INFO: RPC COMMAND destroy_lvol_store")
	144	try:
	145	uuid_obj = UUID(uuid)
	146	name_opt = "-u"
	147	except ValueError:
	148	name_opt = "-l"
	149	output, rc = self.rpc.destroy_lvol_store(name_opt, uuid)
	150	return rc
	151
11fdf7f2 TL	152	def delete_malloc_bdev(self, base_name):
	153	print("INFO: RPC COMMAND delete_malloc_bdev")
	154	output, rc = self.rpc.delete_malloc_bdev(base_name)
	155	return rc
	156
	157	def destroy_lvol_bdev(self, bdev_name):
	158	print("INFO: RPC COMMAND destroy_lvol_bdev")
	159	output, rc = self.rpc.destroy_lvol_bdev(bdev_name)
	160	return rc
	161
	162	def resize_lvol_bdev(self, uuid, new_size):
	163	print("INFO: RPC COMMAND resize_lvol_bdev")
	164	output, rc = self.rpc.resize_lvol_bdev(uuid, new_size)
	165	return rc
	166
9f95a23c TL	167	def set_read_only_lvol_bdev(self, uuid):
	168	print("INFO: RPC COMMAND set_read_only_lvol_bdev")
	169	output, rc = self.rpc.set_read_only_lvol_bdev(uuid)
	170	return rc
	171
11fdf7f2 TL	172	def start_nbd_disk(self, bdev_name, nbd_name):
	173	print("INFO: RPC COMMAND start_nbd_disk")
	174	output, rc = self.rpc.start_nbd_disk(bdev_name, nbd_name)
	175	return rc
	176
	177	def stop_nbd_disk(self, nbd_name):
	178	print("INFO: RPC COMMAND stop_nbd_disk")
	179	output, rc = self.rpc.stop_nbd_disk(nbd_name)
	180	return rc
	181
	182	def get_lvol_stores(self, name=None):
	183	print("INFO: RPC COMMAND get_lvol_stores")
	184	if name:
	185	output = json.loads(self.rpc.get_lvol_stores("-l", name)[0])
	186	else:
	187	output = json.loads(self.rpc.get_lvol_stores()[0])
	188	return output
	189
	190	def get_lvol_bdevs(self):
	191	print("INFO: RPC COMMAND get_bdevs; lvol bdevs only")
	192	output = []
	193	rpc_output = json.loads(self.rpc.get_bdevs()[0])
	194	for bdev in rpc_output:
	195	if bdev["product_name"] == "Logical Volume":
	196	output.append(bdev)
	197	return output
	198
	199	def get_lvol_bdev_with_name(self, name):
	200	print("INFO: RPC COMMAND get_bdevs; lvol bdevs only")
	201	rpc_output = json.loads(self.rpc.get_bdevs("-b", name)[0])
	202	if len(rpc_output) > 0:
	203	return rpc_output[0]
	204
	205	return None
	206
	207	def rename_lvol_store(self, old_name, new_name):
	208	print("INFO: Renaming lvol store from {old} to {new}".format(old=old_name, new=new_name))
	209	output, rc = self.rpc.rename_lvol_store(old_name, new_name)
	210	return rc
	211
	212	def rename_lvol_bdev(self, old_name, new_name):
	213	print("INFO: Renaming lvol bdev from {old} to {new}".format(old=old_name, new=new_name))
	214	output, rc = self.rpc.rename_lvol_bdev(old_name, new_name)
	215	return rc
	216
	217	def snapshot_lvol_bdev(self, bdev_name, snapshot_name):
	218	print("INFO: RPC COMMAND snapshot_lvol_bdev")
	219	output, rc = self.rpc.snapshot_lvol_bdev(bdev_name, snapshot_name)
	220	return rc
	221
	222	def clone_lvol_bdev(self, snapshot_name, clone_name):
	223	print("INFO: RPC COMMAND clone_lvol_bdev")
	224	output, rc = self.rpc.clone_lvol_bdev(snapshot_name, clone_name)
	225	return rc
	226
	227	def inflate_lvol_bdev(self, clone_name):
	228	print("INFO: RPC COMMAND inflate_lvol_bdev")
	229	output, rc = self.rpc.inflate_lvol_bdev(clone_name)
	230	return rc
	231
	232	def decouple_parent_lvol_bdev(self, clone_name):
	233	print("INFO: RPC COMMAND decouple_parent_lvol_bdev")
	234	output, rc = self.rpc.decouple_parent_lvol_bdev(clone_name)
	235	return rc
236
237	def construct_aio_bdev(self, aio_path, aio_name, aio_bs=""):
238	print("INFO: RPC COMMAND construct_aio_bdev")
239	output, rc = self.rpc.construct_aio_bdev(aio_path, aio_name, aio_bs)
240	return rc
241
242	def delete_aio_bdev(self, aio_name):
243	print("INFO: RPC COMMAND delete_aio_bdev")
244	output, rc = self.rpc.delete_aio_bdev(aio_name)
245	return rc