ceph/src/spdk/test/iscsi_tgt/rpc_config/rpc_config.py

   1 #!/usr/bin/env python3
   2
   3
   4 import os
   5 import os.path
   6 import re
   7 import sys
   8 import time
   9 import json
  10 import random
  11 from subprocess import check_call, call, check_output, Popen, PIPE, CalledProcessError
  12
  13 if (len(sys.argv) == 8):
  14     target_ip = sys.argv[2]
  15     initiator_ip = sys.argv[3]
  16     port = sys.argv[4]
  17     netmask = sys.argv[5]
  18     namespace = sys.argv[6]
  19     test_type = sys.argv[7]
  20
  21 ns_cmd = 'ip netns exec ' + namespace
  22 other_ip = '127.0.0.6'
  23 initiator_name = 'ANY'
  24 portal_tag = '1'
  25 initiator_tag = '1'
  26
  27 rpc_param = {
  28     'target_ip': target_ip,
  29     'initiator_ip': initiator_ip,
  30     'port': port,
  31     'initiator_name': initiator_name,
  32     'netmask': netmask,
  33     'lun_total': 3,
  34     'malloc_bdev_size': 64,
  35     'malloc_block_size': 512,
  36     'queue_depth': 64,
  37     'target_name': 'Target3',
  38     'alias_name': 'Target3_alias',
  39     'disable_chap': True,
  40     'mutual_chap': False,
  41     'require_chap': False,
  42     'chap_group': 0,
  43     'header_digest': False,
  44     'data_digest': False,
  45     'log_flag': 'rpc',
  46     'cpumask': 0x1
  47 }
  48
  49
  50 class RpcException(Exception):
  51
  52     def __init__(self, retval, msg):
  53         super(RpcException, self).__init__(msg)
  54         self.retval = retval
  55         self.message = msg
  56
  57
  58 class spdk_rpc(object):
  59
  60     def __init__(self, rpc_py):
  61         self.rpc_py = rpc_py
  62
  63     def __getattr__(self, name):
  64         def call(*args):
  65             cmd = "{} {}".format(self.rpc_py, name)
  66             for arg in args:
  67                 cmd += " {}".format(arg)
  68             return check_output(cmd, shell=True).decode("utf-8")
  69         return call
  70
  71
  72 def verify(expr, retcode, msg):
  73     if not expr:
  74         raise RpcException(retcode, msg)
  75
  76
  77 def verify_log_flag_rpc_methods(rpc_py, rpc_param):
  78     rpc = spdk_rpc(rpc_py)
  79     output = rpc.get_log_flags()
  80     jsonvalue = json.loads(output)
  81     verify(not jsonvalue[rpc_param['log_flag']], 1,
  82            "get_log_flags returned {}, expected false".format(jsonvalue))
  83     rpc.set_log_flag(rpc_param['log_flag'])
  84     output = rpc.get_log_flags()
  85     jsonvalue = json.loads(output)
  86     verify(jsonvalue[rpc_param['log_flag']], 1,
  87            "get_log_flags returned {}, expected true".format(jsonvalue))
  88     rpc.clear_log_flag(rpc_param['log_flag'])
  89     output = rpc.get_log_flags()
  90     jsonvalue = json.loads(output)
  91     verify(not jsonvalue[rpc_param['log_flag']], 1,
  92            "get_log_flags returned {}, expected false".format(jsonvalue))
  93
  94     print("verify_log_flag_rpc_methods passed")
  95
  96
  97 def verify_iscsi_connection_rpc_methods(rpc_py):
  98     rpc = spdk_rpc(rpc_py)
  99     output = rpc.get_iscsi_connections()
 100     jsonvalue = json.loads(output)
 101     verify(not jsonvalue, 1,
 102            "get_iscsi_connections returned {}, expected empty".format(jsonvalue))
 103
 104     rpc.construct_malloc_bdev(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size'])
 105     rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port'])))
 106     rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask'])
 107
 108     lun_mapping = "Malloc" + str(rpc_param['lun_total']) + ":0"
 109     net_mapping = portal_tag + ":" + initiator_tag
 110     rpc.construct_target_node(rpc_param['target_name'], rpc_param['alias_name'], lun_mapping, net_mapping, rpc_param['queue_depth'], '-d')
 111     check_output('iscsiadm -m discovery -t st -p {}'.format(rpc_param['target_ip']), shell=True)
 112     check_output('iscsiadm -m node --login', shell=True)
 113     name = json.loads(rpc.get_target_nodes())[0]['name']
 114     output = rpc.get_iscsi_connections()
 115     jsonvalues = json.loads(output)
 116     verify(jsonvalues[0]['target_node_name'] == rpc_param['target_name'], 1,
 117            "target node name vaule is {}, expected {}".format(jsonvalues[0]['target_node_name'], rpc_param['target_name']))
 118     verify(jsonvalues[0]['id'] == 0, 1,
 119            "device id value is {}, expected 0".format(jsonvalues[0]['id']))
 120     verify(jsonvalues[0]['initiator_addr'] == rpc_param['initiator_ip'], 1,
 121            "initiator address values is {}, expected {}".format(jsonvalues[0]['initiator_addr'], rpc_param['initiator_ip']))
 122     verify(jsonvalues[0]['target_addr'] == rpc_param['target_ip'], 1,
 123            "target address values is {}, expected {}".format(jsonvalues[0]['target_addr'], rpc_param['target_ip']))
 124
 125     check_output('iscsiadm -m node --logout', shell=True)
 126     check_output('iscsiadm -m node -o delete', shell=True)
 127     rpc.delete_initiator_group(initiator_tag)
 128     rpc.delete_portal_group(portal_tag)
 129     rpc.delete_target_node(name)
 130     output = rpc.get_iscsi_connections()
 131     jsonvalues = json.loads(output)
 132     verify(not jsonvalues, 1,
 133            "get_iscsi_connections returned {}, expected empty".format(jsonvalues))
 134
 135     print("verify_iscsi_connection_rpc_methods passed")
 136
 137
 138 def verify_scsi_devices_rpc_methods(rpc_py):
 139     rpc = spdk_rpc(rpc_py)
 140     output = rpc.get_scsi_devices()
 141     jsonvalue = json.loads(output)
 142     verify(not jsonvalue, 1,
 143            "get_scsi_devices returned {}, expected empty".format(jsonvalue))
 144
 145     rpc.construct_malloc_bdev(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size'])
 146     rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port'])))
 147     rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask'])
 148
 149     lun_mapping = "Malloc" + str(rpc_param['lun_total']) + ":0"
 150     net_mapping = portal_tag + ":" + initiator_tag
 151     rpc.construct_target_node(rpc_param['target_name'], rpc_param['alias_name'], lun_mapping, net_mapping, rpc_param['queue_depth'], '-d')
 152     check_output('iscsiadm -m discovery -t st -p {}'.format(rpc_param['target_ip']), shell=True)
 153     check_output('iscsiadm -m node --login', shell=True)
 154     name = json.loads(rpc.get_target_nodes())[0]['name']
 155     output = rpc.get_iscsi_global_params()
 156     jsonvalues = json.loads(output)
 157     nodebase = jsonvalues['node_base']
 158     output = rpc.get_scsi_devices()
 159     jsonvalues = json.loads(output)
 160     verify(jsonvalues[0]['device_name'] == nodebase + ":" + rpc_param['target_name'], 1,
 161            "device name vaule is {}, expected {}".format(jsonvalues[0]['device_name'], rpc_param['target_name']))
 162     verify(jsonvalues[0]['id'] == 0, 1,
 163            "device id value is {}, expected 0".format(jsonvalues[0]['id']))
 164
 165     check_output('iscsiadm -m node --logout', shell=True)
 166     check_output('iscsiadm -m node -o delete', shell=True)
 167     rpc.delete_initiator_group(initiator_tag)
 168     rpc.delete_portal_group(portal_tag)
 169     rpc.delete_target_node(name)
 170     output = rpc.get_scsi_devices()
 171     jsonvalues = json.loads(output)
 172     verify(not jsonvalues, 1,
 173            "get_scsi_devices returned {}, expected empty".format(jsonvalues))
 174
 175     print("verify_scsi_devices_rpc_methods passed")
 176
 177
 178 def create_malloc_bdevs_rpc_methods(rpc_py, rpc_param):
 179     rpc = spdk_rpc(rpc_py)
 180
 181     for i in range(1, rpc_param['lun_total'] + 1):
 182         rpc.construct_malloc_bdev(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size'])
 183
 184     print("create_malloc_bdevs_rpc_methods passed")
 185
 186
 187 def verify_portal_groups_rpc_methods(rpc_py, rpc_param):
 188     rpc = spdk_rpc(rpc_py)
 189     output = rpc.get_portal_groups()
 190     jsonvalues = json.loads(output)
 191     verify(not jsonvalues, 1,
 192            "get_portal_groups returned {} groups, expected empty".format(jsonvalues))
 193
 194     lo_ip = (target_ip, other_ip)
 195     nics = json.loads(rpc.get_interfaces())
 196     for x in nics:
 197         if x["ifc_index"] == 'lo':
 198             rpc.add_ip_address(x["ifc_index"], lo_ip[1])
 199     for idx, value in enumerate(lo_ip):
 200         # The portal group tag must start at 1
 201         tag = idx + 1
 202         rpc.add_portal_group(tag, "{}:{}@{}".format(value, rpc_param['port'], rpc_param['cpumask']))
 203         output = rpc.get_portal_groups()
 204         jsonvalues = json.loads(output)
 205         verify(len(jsonvalues) == tag, 1,
 206                "get_portal_groups returned {} groups, expected {}".format(len(jsonvalues), tag))
 207
 208     tag_list = []
 209     for idx, value in enumerate(jsonvalues):
 210         verify(value['portals'][0]['host'] == lo_ip[idx], 1,
 211                "host value is {}, expected {}".format(value['portals'][0]['host'], rpc_param['target_ip']))
 212         verify(value['portals'][0]['port'] == str(rpc_param['port']), 1,
 213                "port value is {}, expected {}".format(value['portals'][0]['port'], str(rpc_param['port'])))
 214         verify(value['portals'][0]['cpumask'] == format(rpc_param['cpumask'], '#x'), 1,
 215                "cpumask value is {}, expected {}".format(value['portals'][0]['cpumask'], format(rpc_param['cpumask'], '#x')))
 216         tag_list.append(value['tag'])
 217         verify(value['tag'] == idx + 1, 1,
 218                "tag value is {}, expected {}".format(value['tag'], idx + 1))
 219
 220     for idx, value in enumerate(tag_list):
 221         rpc.delete_portal_group(value)
 222         output = rpc.get_portal_groups()
 223         jsonvalues = json.loads(output)
 224         verify(len(jsonvalues) == (len(tag_list) - (idx + 1)), 1,
 225                "get_portal_group returned {} groups, expected {}".format(len(jsonvalues), (len(tag_list) - (idx + 1))))
 226         if not jsonvalues:
 227             break
 228
 229         for jidx, jvalue in enumerate(jsonvalues):
 230             verify(jvalue['portals'][0]['host'] == lo_ip[idx + jidx + 1], 1,
 231                    "host value is {}, expected {}".format(jvalue['portals'][0]['host'], lo_ip[idx + jidx + 1]))
 232             verify(jvalue['portals'][0]['port'] == str(rpc_param['port']), 1,
 233                    "port value is {}, expected {}".format(jvalue['portals'][0]['port'], str(rpc_param['port'])))
 234             verify(jvalue['portals'][0]['cpumask'] == format(rpc_param['cpumask'], '#x'), 1,
 235                    "cpumask value is {}, expected {}".format(jvalue['portals'][0]['cpumask'], format(rpc_param['cpumask'], '#x')))
 236             verify(jvalue['tag'] != value or jvalue['tag'] == tag_list[idx + jidx + 1], 1,
 237                    "tag value is {}, expected {} and not {}".format(jvalue['tag'], tag_list[idx + jidx + 1], value))
 238
 239     for x in nics:
 240         if x["ifc_index"] == 'lo':
 241             rpc.delete_ip_address(x["ifc_index"], lo_ip[1])
 242
 243     print("verify_portal_groups_rpc_methods passed")
 244
 245
 246 def verify_initiator_groups_rpc_methods(rpc_py, rpc_param):
 247     rpc = spdk_rpc(rpc_py)
 248     output = rpc.get_initiator_groups()
 249     jsonvalues = json.loads(output)
 250     verify(not jsonvalues, 1,
 251            "get_initiator_groups returned {}, expected empty".format(jsonvalues))
 252     for idx, value in enumerate(rpc_param['netmask']):
 253         # The initiator group tag must start at 1
 254         tag = idx + 1
 255         rpc.add_initiator_group(tag, rpc_param['initiator_name'], value)
 256         output = rpc.get_initiator_groups()
 257         jsonvalues = json.loads(output)
 258         verify(len(jsonvalues) == tag, 1,
 259                "get_initiator_groups returned {} groups, expected {}".format(len(jsonvalues), tag))
 260
 261     tag_list = []
 262     for idx, value in enumerate(jsonvalues):
 263         verify(value['initiators'][0] == rpc_param['initiator_name'], 1,
 264                "initiator value is {}, expected {}".format(value['initiators'][0], rpc_param['initiator_name']))
 265         tag_list.append(value['tag'])
 266         verify(value['tag'] == idx + 1, 1,
 267                "tag value is {}, expected {}".format(value['tag'], idx + 1))
 268         verify(value['netmasks'][0] == rpc_param['netmask'][idx], 1,
 269                "netmasks value is {}, expected {}".format(value['netmasks'][0], rpc_param['netmask'][idx]))
 270
 271     for idx, value in enumerate(rpc_param['netmask']):
 272         tag = idx + 1
 273         rpc.delete_initiators_from_initiator_group(tag, '-n', rpc_param['initiator_name'], '-m', value)
 274
 275     output = rpc.get_initiator_groups()
 276     jsonvalues = json.loads(output)
 277     verify(len(jsonvalues) == tag, 1,
 278            "get_initiator_groups returned {} groups, expected {}".format(len(jsonvalues), tag))
 279
 280     for idx, value in enumerate(jsonvalues):
 281         verify(value['tag'] == idx + 1, 1,
 282                "tag value is {}, expected {}".format(value['tag'], idx + 1))
 283         initiators = value.get('initiators')
 284         verify(len(initiators) == 0, 1,
 285                "length of initiator list is {}, expected 0".format(len(initiators)))
 286         netmasks = value.get('netmasks')
 287         verify(len(netmasks) == 0, 1,
 288                "length of netmask list is {}, expected 0".format(len(netmasks)))
 289
 290     for idx, value in enumerate(rpc_param['netmask']):
 291         tag = idx + 1
 292         rpc.add_initiators_to_initiator_group(tag, '-n', rpc_param['initiator_name'], '-m', value)
 293     output = rpc.get_initiator_groups()
 294     jsonvalues = json.loads(output)
 295     verify(len(jsonvalues) == tag, 1,
 296            "get_initiator_groups returned {} groups, expected {}".format(len(jsonvalues), tag))
 297
 298     tag_list = []
 299     for idx, value in enumerate(jsonvalues):
 300         verify(value['initiators'][0] == rpc_param['initiator_name'], 1,
 301                "initiator value is {}, expected {}".format(value['initiators'][0], rpc_param['initiator_name']))
 302         tag_list.append(value['tag'])
 303         verify(value['tag'] == idx + 1, 1,
 304                "tag value is {}, expected {}".format(value['tag'], idx + 1))
 305         verify(value['netmasks'][0] == rpc_param['netmask'][idx], 1,
 306                "netmasks value is {}, expected {}".format(value['netmasks'][0], rpc_param['netmask'][idx]))
 307
 308     for idx, value in enumerate(tag_list):
 309         rpc.delete_initiator_group(value)
 310         output = rpc.get_initiator_groups()
 311         jsonvalues = json.loads(output)
 312         verify(len(jsonvalues) == (len(tag_list) - (idx + 1)), 1,
 313                "get_initiator_groups returned {} groups, expected {}".format(len(jsonvalues), (len(tag_list) - (idx + 1))))
 314         if not jsonvalues:
 315             break
 316         for jidx, jvalue in enumerate(jsonvalues):
 317             verify(jvalue['initiators'][0] == rpc_param['initiator_name'], 1,
 318                    "initiator value is {}, expected {}".format(jvalue['initiators'][0], rpc_param['initiator_name']))
 319             verify(jvalue['tag'] != value or jvalue['tag'] == tag_list[idx + jidx + 1], 1,
 320                    "tag value is {}, expected {} and not {}".format(jvalue['tag'], tag_list[idx + jidx + 1], value))
 321             verify(jvalue['netmasks'][0] == rpc_param['netmask'][idx + jidx + 1], 1,
 322                    "netmasks value is {}, expected {}".format(jvalue['netmasks'][0], rpc_param['netmask'][idx + jidx + 1]))
 323
 324     print("verify_initiator_groups_rpc_method passed.")
 325
 326
 327 def verify_target_nodes_rpc_methods(rpc_py, rpc_param):
 328     rpc = spdk_rpc(rpc_py)
 329     output = rpc.get_iscsi_global_params()
 330     jsonvalues = json.loads(output)
 331     nodebase = jsonvalues['node_base']
 332     output = rpc.get_target_nodes()
 333     jsonvalues = json.loads(output)
 334     verify(not jsonvalues, 1,
 335            "get_target_nodes returned {}, expected empty".format(jsonvalues))
 336
 337     rpc.construct_malloc_bdev(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size'])
 338     rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port'])))
 339     rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask'])
 340
 341     lun_mapping = "Malloc" + str(rpc_param['lun_total']) + ":0"
 342     net_mapping = portal_tag + ":" + initiator_tag
 343     rpc.construct_target_node(rpc_param['target_name'], rpc_param['alias_name'], lun_mapping, net_mapping, rpc_param['queue_depth'], '-d')
 344     output = rpc.get_target_nodes()
 345     jsonvalues = json.loads(output)
 346     verify(len(jsonvalues) == 1, 1,
 347            "get_target_nodes returned {} nodes, expected 1".format(len(jsonvalues)))
 348     bdev_name = jsonvalues[0]['luns'][0]['bdev_name']
 349     verify(bdev_name == "Malloc" + str(rpc_param['lun_total']), 1,
 350            "bdev_name value is {}, expected Malloc{}".format(jsonvalues[0]['luns'][0]['bdev_name'], str(rpc_param['lun_total'])))
 351     name = jsonvalues[0]['name']
 352     verify(name == nodebase + ":" + rpc_param['target_name'], 1,
 353            "target name value is {}, expected {}".format(name, nodebase + ":" + rpc_param['target_name']))
 354     verify(jsonvalues[0]['alias_name'] == rpc_param['alias_name'], 1,
 355            "target alias_name value is {}, expected {}".format(jsonvalues[0]['alias_name'], rpc_param['alias_name']))
 356     verify(jsonvalues[0]['luns'][0]['lun_id'] == 0, 1,
 357            "lun id value is {}, expected 0".format(jsonvalues[0]['luns'][0]['lun_id']))
 358     verify(jsonvalues[0]['pg_ig_maps'][0]['ig_tag'] == int(initiator_tag), 1,
 359            "initiator group tag value is {}, expected {}".format(jsonvalues[0]['pg_ig_maps'][0]['ig_tag'], initiator_tag))
 360     verify(jsonvalues[0]['queue_depth'] == rpc_param['queue_depth'], 1,
 361            "queue depth value is {}, expected {}".format(jsonvalues[0]['queue_depth'], rpc_param['queue_depth']))
 362     verify(jsonvalues[0]['pg_ig_maps'][0]['pg_tag'] == int(portal_tag), 1,
 363            "portal group tag value is {}, expected {}".format(jsonvalues[0]['pg_ig_maps'][0]['pg_tag'], portal_tag))
 364     verify(jsonvalues[0]['disable_chap'] == rpc_param['disable_chap'], 1,
 365            "disable chap value is {}, expected {}".format(jsonvalues[0]['disable_chap'], rpc_param['disable_chap']))
 366     verify(jsonvalues[0]['mutual_chap'] == rpc_param['mutual_chap'], 1,
 367            "chap mutual value is {}, expected {}".format(jsonvalues[0]['mutual_chap'], rpc_param['mutual_chap']))
 368     verify(jsonvalues[0]['require_chap'] == rpc_param['require_chap'], 1,
 369            "chap required value is {}, expected {}".format(jsonvalues[0]['require_chap'], rpc_param['require_chap']))
 370     verify(jsonvalues[0]['chap_group'] == rpc_param['chap_group'], 1,
 371            "chap auth group value is {}, expected {}".format(jsonvalues[0]['chap_group'], rpc_param['chap_group']))
 372     verify(jsonvalues[0]['header_digest'] == rpc_param['header_digest'], 1,
 373            "header digest value is {}, expected {}".format(jsonvalues[0]['header_digest'], rpc_param['header_digest']))
 374     verify(jsonvalues[0]['data_digest'] == rpc_param['data_digest'], 1,
 375            "data digest value is {}, expected {}".format(jsonvalues[0]['data_digest'], rpc_param['data_digest']))
 376     lun_id = '1'
 377     rpc.target_node_add_lun(name, bdev_name, "-i", lun_id)
 378     output = rpc.get_target_nodes()
 379     jsonvalues = json.loads(output)
 380     verify(jsonvalues[0]['luns'][1]['bdev_name'] == "Malloc" + str(rpc_param['lun_total']), 1,
 381            "bdev_name value is {}, expected Malloc{}".format(jsonvalues[0]['luns'][0]['bdev_name'], str(rpc_param['lun_total'])))
 382     verify(jsonvalues[0]['luns'][1]['lun_id'] == 1, 1,
 383            "lun id value is {}, expected 1".format(jsonvalues[0]['luns'][1]['lun_id']))
 384
 385     rpc.delete_target_node(name)
 386     output = rpc.get_target_nodes()
 387     jsonvalues = json.loads(output)
 388     verify(not jsonvalues, 1,
 389            "get_target_nodes returned {}, expected empty".format(jsonvalues))
 390
 391     rpc.construct_target_node(rpc_param['target_name'], rpc_param['alias_name'], lun_mapping, net_mapping, rpc_param['queue_depth'], '-d')
 392
 393     rpc.delete_portal_group(portal_tag)
 394     rpc.delete_initiator_group(initiator_tag)
 395     rpc.delete_target_node(name)
 396     output = rpc.get_target_nodes()
 397     jsonvalues = json.loads(output)
 398     if not jsonvalues:
 399         print("This issue will be fixed later.")
 400
 401     print("verify_target_nodes_rpc_methods passed.")
 402
 403
 404 def verify_get_interfaces(rpc_py):
 405     rpc = spdk_rpc(rpc_py)
 406     nics = json.loads(rpc.get_interfaces())
 407     nics_names = set(x["name"] for x in nics)
 408     # parse ip link show to verify the get_interfaces result
 409     ip_show = ns_cmd + " ip link show"
 410     ifcfg_nics = set(re.findall(r'\S+:\s(\S+?)(?:@\S+){0,1}:\s<.*', check_output(ip_show.split()).decode()))
 411     verify(nics_names == ifcfg_nics, 1, "get_interfaces returned {}".format(nics))
 412     print("verify_get_interfaces passed.")
 413
 414
 415 def help_get_interface_ip_list(rpc_py, nic_name):
 416     rpc = spdk_rpc(rpc_py)
 417     nics = json.loads(rpc.get_interfaces())
 418     nic = list([x for x in nics if x["name"] == nic_name])
 419     verify(len(nic) != 0, 1,
 420            "Nic name: {} is not found in {}".format(nic_name, [x["name"] for x in nics]))
 421     return nic[0]["ip_addr"]
 422
 423
 424 def verify_add_delete_ip_address(rpc_py):
 425     rpc = spdk_rpc(rpc_py)
 426     nics = json.loads(rpc.get_interfaces())
 427     # add ip on up to first 2 nics
 428     for x in nics[:2]:
 429         faked_ip = "123.123.{}.{}".format(random.randint(1, 254), random.randint(1, 254))
 430         ping_cmd = ns_cmd + " ping -c 1 -W 1 " + faked_ip
 431         rpc.add_ip_address(x["ifc_index"], faked_ip)
 432         verify(faked_ip in help_get_interface_ip_list(rpc_py, x["name"]), 1,
 433                "add ip {} to nic {} failed.".format(faked_ip, x["name"]))
 434         try:
 435             check_call(ping_cmd.split())
 436         except BaseException:
 437             verify(False, 1,
 438                    "ping ip {} for {} was failed(adding was successful)".format
 439                    (faked_ip, x["name"]))
 440         rpc.delete_ip_address(x["ifc_index"], faked_ip)
 441         verify(faked_ip not in help_get_interface_ip_list(rpc_py, x["name"]), 1,
 442                "delete ip {} from nic {} failed.(adding and ping were successful)".format
 443                (faked_ip, x["name"]))
 444         # ping should be failed and throw an CalledProcessError exception
 445         try:
 446             check_call(ping_cmd.split())
 447         except CalledProcessError as _:
 448             pass
 449         except Exception as e:
 450             verify(False, 1,
 451                    "Unexpected exception was caught {}(adding/ping/delete were successful)".format
 452                    (str(e)))
 453         else:
 454             verify(False, 1,
 455                    "ip {} for {} could be pinged after delete ip(adding/ping/delete were successful)".format
 456                    (faked_ip, x["name"]))
 457     print("verify_add_delete_ip_address passed.")
 458
 459
 460 def verify_add_nvme_bdev_rpc_methods(rpc_py):
 461     rpc = spdk_rpc(rpc_py)
 462     test_pass = 0
 463     output = check_output(["lspci", "-mm", "-nn"])
 464     addrs = re.findall(r'^([0-9]{2}:[0-9]{2}.[0-9]) "Non-Volatile memory controller \[0108\]".*-p02', output.decode(), re.MULTILINE)
 465     for addr in addrs:
 466         ctrlr_address = "-b Nvme{} -t pcie -a 0000:{}".format(addrs.index(addr), addr)
 467         rpc.construct_nvme_bdev(ctrlr_address)
 468         print("add nvme device passed first time")
 469         test_pass = 0
 470         try:
 471             rpc.construct_nvme_bdev(ctrlr_address)
 472         except Exception as e:
 473             print("add nvme device passed second time")
 474             test_pass = 1
 475             pass
 476         else:
 477             pass
 478         verify(test_pass == 1, 1, "add nvme device passed second time")
 479     print("verify_add_nvme_bdev_rpc_methods passed.")
 480
 481
 482 if __name__ == "__main__":
 483
 484     rpc_py = sys.argv[1]
 485
 486     try:
 487         verify_log_flag_rpc_methods(rpc_py, rpc_param)
 488         verify_get_interfaces(rpc_py)
 489         verify_add_delete_ip_address(rpc_py)
 490         create_malloc_bdevs_rpc_methods(rpc_py, rpc_param)
 491         verify_portal_groups_rpc_methods(rpc_py, rpc_param)
 492         verify_initiator_groups_rpc_methods(rpc_py, rpc_param)
 493         verify_target_nodes_rpc_methods(rpc_py, rpc_param)
 494         verify_scsi_devices_rpc_methods(rpc_py)
 495         verify_iscsi_connection_rpc_methods(rpc_py)
 496         verify_add_nvme_bdev_rpc_methods(rpc_py)
 497     except RpcException as e:
 498         print("{}. Exiting with status {}".format(e.message, e.retval))
 499         raise e
 500     except Exception as e:
 501         raise e
 502
 503     sys.exit(0)