ceph/src/spdk/test/json_config/clear_config.py

   1 #!/usr/bin/env python3
   2
   3 import os
   4 import sys
   5 import argparse
   6 import logging
   7 sys.path.append(os.path.join(os.path.dirname(__file__), "../../scripts"))
   8 import rpc   # noqa
   9 from rpc.client import print_dict, JSONRPCException  # noqa
  10
  11
  12 def get_bdev_name_key(bdev):
  13     bdev_name_key = 'name'
  14     if 'method' in bdev and bdev['method'] == 'construct_split_vbdev':
  15         bdev_name_key = "base_bdev"
  16     return bdev_name_key
  17
  18
  19 def get_bdev_name(bdev):
  20     bdev_name = None
  21     if 'params' in bdev:
  22         if 'name' in bdev['params']:
  23             bdev_name = bdev['params']['name']
  24         elif 'base_name' in bdev['params']:
  25             bdev_name = bdev['params']['base_name']
  26         elif 'base_bdev' in bdev['params']:
  27             bdev_name = bdev['params']['base_bdev']
  28     if 'method' in bdev and bdev['method'] == 'construct_error_bdev':
  29         bdev_name = "EE_%s" % bdev_name
  30     return bdev_name
  31
  32
  33 def delete_subbdevs(args, bdev, rpc_bdevs):
  34     ret_value = False
  35     bdev_name = get_bdev_name(bdev)
  36     if bdev_name and 'method' in bdev:
  37         construct_method = bdev['method']
  38         if construct_method == 'construct_nvme_bdev':
  39             for rpc_bdev in rpc_bdevs:
  40                 if bdev_name in rpc_bdev['name'] and rpc_bdev['product_name'] == "NVMe disk":
  41                     args.client.call('delete_nvme_controller', {'name': "%s" % rpc_bdev['name'].split('n')[0]})
  42                     ret_value = True
  43
  44     return ret_value
  45
  46
  47 def get_bdev_destroy_method(bdev):
  48     destroy_method_map = {'construct_nvme_bdev': "delete_nvme_controller",
  49                           'construct_malloc_bdev': "delete_malloc_bdev",
  50                           'construct_null_bdev': "delete_null_bdev",
  51                           'construct_rbd_bdev': "delete_rbd_bdev",
  52                           'construct_pmem_bdev': "delete_pmem_bdev",
  53                           'construct_aio_bdev': "delete_aio_bdev",
  54                           'construct_error_bdev': "delete_error_bdev",
  55                           'construct_split_vbdev': "destruct_split_vbdev",
  56                           'construct_virtio_dev': "remove_virtio_bdev",
  57                           'construct_crypto_bdev': "delete_crypto_bdev",
  58                           'bdev_delay_create': "bdev_delay_delete",
  59                           'construct_passthru_bdev': "delete_passthru_bdev",
  60                           'construct_compress_bdev': 'delete_compress_bdev',
  61                           }
  62     destroy_method = None
  63     if 'method' in bdev:
  64         construct_method = bdev['method']
  65         if construct_method in list(destroy_method_map.keys()):
  66             destroy_method = destroy_method_map[construct_method]
  67
  68     return destroy_method
  69
  70
  71 def clear_bdev_subsystem(args, bdev_config):
  72     rpc_bdevs = args.client.call("get_bdevs")
  73     for bdev in bdev_config:
  74         if delete_subbdevs(args, bdev, rpc_bdevs):
  75             continue
  76         bdev_name_key = get_bdev_name_key(bdev)
  77         bdev_name = get_bdev_name(bdev)
  78         destroy_method = get_bdev_destroy_method(bdev)
  79         if destroy_method:
  80             args.client.call(destroy_method, {bdev_name_key: bdev_name})
  81
  82     ''' Disable and reset hotplug '''
  83     rpc.bdev.set_bdev_nvme_hotplug(args.client, False)
  84
  85
  86 def get_nvmf_destroy_method(nvmf):
  87     destroy_method_map = {'nvmf_subsystem_create': "delete_nvmf_subsystem"}
  88     try:
  89         return destroy_method_map[nvmf['method']]
  90     except KeyError:
  91         return None
  92
  93
  94 def clear_nvmf_subsystem(args, nvmf_config):
  95     for nvmf in nvmf_config:
  96         destroy_method = get_nvmf_destroy_method(nvmf)
  97         if destroy_method:
  98             args.client.call(destroy_method, {'nqn': nvmf['params']['nqn']})
  99
 100
 101 def get_iscsi_destroy_method(iscsi):
 102     destroy_method_map = {'add_portal_group': "delete_portal_group",
 103                           'add_initiator_group': "delete_initiator_group",
 104                           'construct_target_node': "delete_target_node",
 105                           'set_iscsi_options': None
 106                           }
 107     return destroy_method_map[iscsi['method']]
 108
 109
 110 def get_iscsi_name(iscsi):
 111     if 'name' in iscsi['params']:
 112         return iscsi['params']['name']
 113     else:
 114         return iscsi['params']['tag']
 115
 116
 117 def get_iscsi_name_key(iscsi):
 118     if iscsi['method'] == 'construct_target_node':
 119         return "name"
 120     else:
 121         return 'tag'
 122
 123
 124 def clear_iscsi_subsystem(args, iscsi_config):
 125     for iscsi in iscsi_config:
 126         destroy_method = get_iscsi_destroy_method(iscsi)
 127         if destroy_method:
 128             args.client.call(destroy_method, {get_iscsi_name_key(iscsi): get_iscsi_name(iscsi)})
 129
 130
 131 def get_nbd_destroy_method(nbd):
 132     destroy_method_map = {'start_nbd_disk': "stop_nbd_disk"
 133                           }
 134     return destroy_method_map[nbd['method']]
 135
 136
 137 def clear_nbd_subsystem(args, nbd_config):
 138     for nbd in nbd_config:
 139         destroy_method = get_nbd_destroy_method(nbd)
 140         if destroy_method:
 141             args.client.call(destroy_method, {'nbd_device': nbd['params']['nbd_device']})
 142
 143
 144 def clear_net_framework_subsystem(args, net_framework_config):
 145     pass
 146
 147
 148 def clear_copy_subsystem(args, copy_config):
 149     pass
 150
 151
 152 def clear_interface_subsystem(args, interface_config):
 153     pass
 154
 155
 156 def clear_vhost_subsystem(args, vhost_config):
 157     for vhost in reversed(vhost_config):
 158         if 'method' in vhost:
 159             method = vhost['method']
 160             if method in ['add_vhost_scsi_lun']:
 161                 args.client.call("remove_vhost_scsi_target",
 162                                  {"ctrlr": vhost['params']['ctrlr'],
 163                                   "scsi_target_num": vhost['params']['scsi_target_num']})
 164             elif method in ['construct_vhost_scsi_controller', 'construct_vhost_blk_controller',
 165                             'construct_vhost_nvme_controller']:
 166                 args.client.call("remove_vhost_controller", {'ctrlr': vhost['params']['ctrlr']})
 167
 168
 169 def call_test_cmd(func):
 170     def rpc_test_cmd(*args, **kwargs):
 171         try:
 172             func(*args, **kwargs)
 173         except JSONRPCException as ex:
 174             print((ex.message))
 175             exit(1)
 176     return rpc_test_cmd
 177
 178
 179 if __name__ == "__main__":
 180     parser = argparse.ArgumentParser(description='Clear config command')
 181     parser.add_argument('-s', dest='server_addr', default='/var/tmp/spdk.sock')
 182     parser.add_argument('-p', dest='port', default=5260, type=int)
 183     parser.add_argument('-t', dest='timeout', default=60.0, type=float)
 184     parser.add_argument('-v', dest='verbose', action='store_const', const="INFO",
 185                         help='Set verbose mode to INFO', default="ERROR")
 186     parser.add_argument('--verbose', dest='verbose', choices=['DEBUG', 'INFO', 'ERROR'],
 187                         help="""Set verbose level. """)
 188     subparsers = parser.add_subparsers(help='RPC methods')
 189
 190     @call_test_cmd
 191     def clear_config(args):
 192         for subsystem_item in reversed(args.client.call('get_subsystems')):
 193             args.subsystem = subsystem_item['subsystem']
 194             clear_subsystem(args)
 195
 196     p = subparsers.add_parser('clear_config', help="""Clear configuration of all SPDK subsystems and targets using JSON RPC""")
 197     p.set_defaults(func=clear_config)
 198
 199     @call_test_cmd
 200     def clear_subsystem(args):
 201         config = args.client.call('get_subsystem_config', {"name": args.subsystem})
 202         if config is None:
 203             return
 204         if args.verbose:
 205             print("Calling clear_%s_subsystem" % args.subsystem)
 206         globals()["clear_%s_subsystem" % args.subsystem](args, config)
 207
 208     p = subparsers.add_parser('clear_subsystem', help="""Clear configuration of SPDK subsystem using JSON RPC""")
 209     p.add_argument('--subsystem', help="""Subsystem name""")
 210     p.set_defaults(func=clear_subsystem)
 211
 212     args = parser.parse_args()
 213
 214     with rpc.client.JSONRPCClient(args.server_addr, args.port, args.timeout, log_level=getattr(logging, args.verbose.upper())) as client:
 215         try:
 216             args.client = client
 217             args.func(args)
 218         except JSONRPCException as ex:
 219             print((ex.message))
 220             exit(1)