openstack/cinder
Code Issues Proposed changes

SPDK drivers: Update RPC calls to match latest SPDK changes

Browse Source 
With latest SPDK release most of the old RPC calls has been
deprecated and soon will be obsolete. This patch updates
relevant calls to the latest version.

Signed-off-by: Maciej Szwed <maciej.szwed@intel.com>
Change-Id: I615e34f2f8df60eaea09e32b15437deb36f441c0
This commit is contained in:
Maciej Szwed 2019-11-12 15:20:20 +01:00
parent 121d9f512b
commit 01d8401d14
6 changed files with 63 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
cinder/tests/unit/targets/test_spdknvmf.py
View File

@ -220,16 +220,16 @@ class JSONRPCException(Exception):
class JSONRPCClient(object): class JSONRPCClient(object):
def __init__(self, addr=None, port=None): def __init__(self, addr=None, port=None):
self.methods = {"get_bdevs": self.get_bdevs, self.methods = {"bdev_get_bdevs": self.get_bdevs,
"construct_nvmf_subsystem": "construct_nvmf_subsystem":
self.construct_nvmf_subsystem, self.construct_nvmf_subsystem,
"delete_nvmf_subsystem": self.delete_nvmf_subsystem, "nvmf_delete_subsystem": self.delete_nvmf_subsystem,
"nvmf_subsystem_create": self.nvmf_subsystem_create, "nvmf_create_subsystem": self.nvmf_subsystem_create,
"nvmf_subsystem_add_listener": "nvmf_subsystem_add_listener":
self.nvmf_subsystem_add_listener, self.nvmf_subsystem_add_listener,
"nvmf_subsystem_add_ns": "nvmf_subsystem_add_ns":
self.nvmf_subsystem_add_ns, self.nvmf_subsystem_add_ns,
"get_nvmf_subsystems": self.get_nvmf_subsystems} "nvmf_get_subsystems": self.get_nvmf_subsystems}
self.bdevs = copy.deepcopy(BDEVS) self.bdevs = copy.deepcopy(BDEVS)
self.nvmf_subsystems = copy.deepcopy(NVMF_SUBSYSTEMS) self.nvmf_subsystems = copy.deepcopy(NVMF_SUBSYSTEMS)
@ -362,7 +362,7 @@ class SpdkNvmfDriverTestCase(test.TestCase):
def test__get_spdk_volume_name(self): def test__get_spdk_volume_name(self):
with mock.patch.object(self.driver, "_rpc_call", with mock.patch.object(self.driver, "_rpc_call",
self.jsonrpcclient.call): self.jsonrpcclient.call):
bdevs = self.driver._rpc_call("get_bdevs") bdevs = self.driver._rpc_call("bdev_get_bdevs")
bdev_name = bdevs[0]['name'] bdev_name = bdevs[0]['name']
volume_name = self.driver._get_spdk_volume_name(bdev_name) volume_name = self.driver._get_spdk_volume_name(bdev_name)
self.assertEqual(bdev_name, volume_name) self.assertEqual(bdev_name, volume_name)
@ -373,7 +373,7 @@ class SpdkNvmfDriverTestCase(test.TestCase):
with mock.patch.object(self.driver, "_rpc_call", with mock.patch.object(self.driver, "_rpc_call",
self.jsonrpcclient.call): self.jsonrpcclient.call):
nqn = self.driver._get_nqn_with_volume_name("Nvme0n1p0") nqn = self.driver._get_nqn_with_volume_name("Nvme0n1p0")
nqn_tmp = self.driver._rpc_call("get_nvmf_subsystems")[1]['nqn'] nqn_tmp = self.driver._rpc_call("nvmf_get_subsystems")[1]['nqn']
self.assertEqual(nqn, nqn_tmp) self.assertEqual(nqn, nqn_tmp)
nqn = self.driver._get_nqn_with_volume_name("fake") nqn = self.driver._get_nqn_with_volume_name("fake")
self.assertIsNone(nqn) self.assertIsNone(nqn)
@ -387,21 +387,21 @@ class SpdkNvmfDriverTestCase(test.TestCase):
def test_create_nvmeof_target(self): def test_create_nvmeof_target(self):
with mock.patch.object(self.driver, "_rpc_call", with mock.patch.object(self.driver, "_rpc_call",
self.jsonrpcclient.call): self.jsonrpcclient.call):
subsystems_first = self.driver._rpc_call("get_nvmf_subsystems") subsystems_first = self.driver._rpc_call("nvmf_get_subsystems")
self.driver.create_nvmeof_target("Nvme0n1p1", self.driver.create_nvmeof_target("Nvme0n1p1",
"nqn.2016-06.io.spdk", "nqn.2016-06.io.spdk",
"192.168.0.1", "192.168.0.1",
4420, "rdma", -1, -1, "") 4420, "rdma", -1, -1, "")
subsystems_last = self.driver._rpc_call("get_nvmf_subsystems") subsystems_last = self.driver._rpc_call("nvmf_get_subsystems")
self.assertEqual(len(subsystems_first) + 1, len(subsystems_last)) self.assertEqual(len(subsystems_first) + 1, len(subsystems_last))
def test_delete_nvmeof_target(self): def test_delete_nvmeof_target(self):
with mock.patch.object(self.driver, "_rpc_call", with mock.patch.object(self.driver, "_rpc_call",
self.jsonrpcclient.call): self.jsonrpcclient.call):
subsystems_first = self.driver._rpc_call("get_nvmf_subsystems") subsystems_first = self.driver._rpc_call("nvmf_get_subsystems")
target = Target() target = Target()
self.driver.delete_nvmeof_target(target) self.driver.delete_nvmeof_target(target)
subsystems_last = self.driver._rpc_call("get_nvmf_subsystems") subsystems_last = self.driver._rpc_call("nvmf_get_subsystems")
self.assertEqual(len(subsystems_first) - 1, len(subsystems_last)) self.assertEqual(len(subsystems_first) - 1, len(subsystems_last))
target.name = "fake" target.name = "fake"
self.driver.delete_nvmeof_target(target) self.driver.delete_nvmeof_target(target)

40
cinder/tests/unit/volume/drivers/test_spdk.py
View File

@ -250,23 +250,23 @@ class JSONRPCException(Exception):
class JSONRPCClient(object): class JSONRPCClient(object):
def __init__(self, addr=None, port=None): def __init__(self, addr=None, port=None):
self.methods = {"get_bdevs": self.get_bdevs, self.methods = {"bdev_get_bdevs": self.get_bdevs,
"get_lvol_stores": self.get_lvol_stores, "bdev_lvol_get_lvstores": self.get_lvol_stores,
"destroy_lvol_bdev": self.destroy_lvol_bdev, "bdev_lvol_delete": self.destroy_lvol_bdev,
"snapshot_lvol_bdev": self.snapshot_lvol_bdev, "bdev_lvol_snapshot": self.snapshot_lvol_bdev,
"clone_lvol_bdev": self.clone_lvol_bdev, "bdev_lvol_clone": self.clone_lvol_bdev,
"construct_lvol_bdev": self.construct_lvol_bdev, "bdev_lvol_create": self.construct_lvol_bdev,
"resize_lvol_bdev": self.resize_lvol_bdev, "bdev_lvol_resize": self.resize_lvol_bdev,
"get_nvmf_subsystems": self.get_nvmf_subsystems, "nvmf_get_subsystems": self.get_nvmf_subsystems,
"construct_nvmf_subsystem": "construct_nvmf_subsystem":
self.construct_nvmf_subsystem, self.construct_nvmf_subsystem,
"nvmf_subsystem_create": "nvmf_create_subsystem":
self.nvmf_subsystem_create, self.nvmf_subsystem_create,
"nvmf_subsystem_add_listener": "nvmf_subsystem_add_listener":
self.nvmf_subsystem_add_listener, self.nvmf_subsystem_add_listener,
"nvmf_subsystem_add_ns": "nvmf_subsystem_add_ns":
self.nvmf_subsystem_add_ns, self.nvmf_subsystem_add_ns,
"inflate_lvol_bdev": self.inflate_lvol_bdev} "bdev_lvol_inflate": self.inflate_lvol_bdev}
self.bdevs = copy.deepcopy(BDEVS) self.bdevs = copy.deepcopy(BDEVS)
self.nvmf_subsystems = copy.deepcopy(NVMF_SUBSYSTEMS) self.nvmf_subsystems = copy.deepcopy(NVMF_SUBSYSTEMS)
self.lvol_stores = copy.deepcopy(LVOL_STORES) self.lvol_stores = copy.deepcopy(LVOL_STORES)
@ -536,7 +536,7 @@ class SpdkDriverTestCase(test.TestCase):
with mock.patch.object(self.driver, "_rpc_call", with mock.patch.object(self.driver, "_rpc_call",
self.jsonrpcclient.call): self.jsonrpcclient.call):
bdev = self.driver._rpc_call( bdev = self.driver._rpc_call(
"get_bdevs", params={"name": "lvs_test/lvol0"}) "bdev_get_bdevs", params={"name": "lvs_test/lvol0"})
self.assertEqual( self.assertEqual(
bdev[0]['driver_specific']['lvol']['lvol_store_uuid'], bdev[0]['driver_specific']['lvol']['lvol_store_uuid'],
self.driver._get_spdk_lvs_uuid( self.driver._get_spdk_lvs_uuid(
@ -547,7 +547,7 @@ class SpdkDriverTestCase(test.TestCase):
def test__get_spdk_lvs_free_space(self): def test__get_spdk_lvs_free_space(self):
with mock.patch.object(self.driver, "_rpc_call", with mock.patch.object(self.driver, "_rpc_call",
self.jsonrpcclient.call): self.jsonrpcclient.call):
lvs = self.driver._rpc_call("get_lvol_stores") lvs = self.driver._rpc_call("bdev_lvol_get_lvstores")
lvol_store = None lvol_store = None
for lvol in lvs: for lvol in lvs:
if lvol['name'] == "lvs_test": if lvol['name'] == "lvs_test":
@ -583,7 +583,7 @@ class SpdkDriverTestCase(test.TestCase):
bdev) bdev)
volume_clone = Volume() volume_clone = Volume()
volume_clone.name = "clone0" volume_clone.name = "clone0"
self.driver._rpc_call("snapshot_lvol_bdev", self.driver._rpc_call("bdev_lvol_snapshot",
params={'snapshot_name': "snapshot0", params={'snapshot_name': "snapshot0",
'lvol_name': "lvs_test/lvol2"}) 'lvol_name': "lvs_test/lvol2"})
bdev = self.driver._get_spdk_volume_name("lvs_test/snapshot0") bdev = self.driver._get_spdk_volume_name("lvs_test/snapshot0")
@ -628,19 +628,19 @@ class SpdkDriverTestCase(test.TestCase):
db_volume = objects.Volume._from_db_object(ctxt, objects.Volume(), db_volume = objects.Volume._from_db_object(ctxt, objects.Volume(),
db_volume) db_volume)
volume_get.return_value = db_volume volume_get.return_value = db_volume
start_bdevs_len = len(self.driver._rpc_call('get_bdevs')) start_bdevs_len = len(self.driver._rpc_call('bdev_get_bdevs'))
self.driver.create_volume(db_volume) self.driver.create_volume(db_volume)
tmp_bdevs = self.driver._rpc_call('get_bdevs') tmp_bdevs = self.driver._rpc_call('bdev_get_bdevs')
self.assertEqual(start_bdevs_len + 1, len(tmp_bdevs)) self.assertEqual(start_bdevs_len + 1, len(tmp_bdevs))
volume = Volume() volume = Volume()
volume.name = "lvs_test/%s" % db_volume.name volume.name = "lvs_test/%s" % db_volume.name
volume_name = self.driver._get_spdk_volume_name(volume.name) volume_name = self.driver._get_spdk_volume_name(volume.name)
self.driver._rpc_call('destroy_lvol_bdev', {"name": volume_name}) self.driver._rpc_call('bdev_lvol_delete', {"name": volume_name})
self.driver.delete_volume(volume) self.driver.delete_volume(volume)
bdev = self.driver._get_spdk_volume_name("lvs_test/%s" bdev = self.driver._get_spdk_volume_name("lvs_test/%s"
% db_volume.name) % db_volume.name)
self.assertIsNone(bdev) self.assertIsNone(bdev)
tmp_bdevs = self.driver._rpc_call('get_bdevs') tmp_bdevs = self.driver._rpc_call('bdev_get_bdevs')
self.assertEqual(start_bdevs_len, len(tmp_bdevs)) self.assertEqual(start_bdevs_len, len(tmp_bdevs))
def get_volume_stats(self): def get_volume_stats(self):
@ -654,7 +654,7 @@ class SpdkDriverTestCase(test.TestCase):
self.jsonrpcclient.call): self.jsonrpcclient.call):
volume_clone = Volume() volume_clone = Volume()
volume_clone.name = "clone0" volume_clone.name = "clone0"
self.driver._rpc_call("snapshot_lvol_bdev", self.driver._rpc_call("bdev_lvol_snapshot",
params={'snapshot_name': "snapshot0", params={'snapshot_name': "snapshot0",
'lvol_name': "lvs_test/lvol2"}) 'lvol_name': "lvs_test/lvol2"})
snapshot = Snapshot() snapshot = Snapshot()
@ -688,7 +688,7 @@ class SpdkDriverTestCase(test.TestCase):
self.jsonrpcclient.call): self.jsonrpcclient.call):
snapshot = Snapshot() snapshot = Snapshot()
snapshot.name = "snapshot0" snapshot.name = "snapshot0"
self.driver._rpc_call("snapshot_lvol_bdev", self.driver._rpc_call("bdev_lvol_snapshot",
params = {'snapshot_name': snapshot.name}) params = {'snapshot_name': snapshot.name})
self.driver.delete_snapshot(snapshot) self.driver.delete_snapshot(snapshot)
snapshot = self.driver._get_spdk_volume_name("lvs_test/" + snapshot = self.driver._get_spdk_volume_name("lvs_test/" +
@ -750,7 +750,7 @@ class SpdkDriverTestCase(test.TestCase):
volume = Volume() volume = Volume()
volume.name = "lvs_test/lvol0" volume.name = "lvs_test/lvol0"
self.driver.extend_volume(volume, 2) self.driver.extend_volume(volume, 2)
bdev = self.driver._rpc_call("get_bdevs", bdev = self.driver._rpc_call("bdev_get_bdevs",
params={"name": "lvs_test/lvol0"}) params={"name": "lvs_test/lvol0"})
self.assertEqual(2 * units.Gi, self.assertEqual(2 * units.Gi,
bdev[0]['num_blocks'] * bdev[0]['block_size']) bdev[0]['num_blocks'] * bdev[0]['block_size'])

40
cinder/volume/drivers/spdk.py
View File

@ -92,7 +92,7 @@ class SPDKDriver(driver.VolumeDriver):
pools_status = [] pools_status = []
self.lvs = [] self.lvs = []
output = self._rpc_call('get_lvol_stores') output = self._rpc_call('bdev_lvol_get_lvstores')
if output: if output:
for lvs in output: for lvs in output:
pool = {} pool = {}
@ -128,14 +128,14 @@ class SPDKDriver(driver.VolumeDriver):
lvs['free_size']) lvs['free_size'])
def _get_spdk_volume_name(self, name): def _get_spdk_volume_name(self, name):
output = self._rpc_call('get_bdevs') output = self._rpc_call('bdev_get_bdevs')
for bdev in output: for bdev in output:
for alias in bdev['aliases']: for alias in bdev['aliases']:
if name in alias: if name in alias:
return bdev['name'] return bdev['name']
def _get_spdk_lvs_uuid(self, spdk_name): def _get_spdk_lvs_uuid(self, spdk_name):
output = self._rpc_call('get_bdevs') output = self._rpc_call('bdev_get_bdevs')
for bdev in output: for bdev in output:
if spdk_name in bdev['name']: if spdk_name in bdev['name']:
return bdev['driver_specific']['lvol']['lvol_store_uuid'] return bdev['driver_specific']['lvol']['lvol_store_uuid']
@ -153,13 +153,13 @@ class SPDKDriver(driver.VolumeDriver):
spdk_name = self._get_spdk_volume_name(name) spdk_name = self._get_spdk_volume_name(name)
if spdk_name is not None: if spdk_name is not None:
params = {'name': spdk_name} params = {'name': spdk_name}
self._rpc_call('destroy_lvol_bdev', params) self._rpc_call('bdev_lvol_delete', params)
LOG.debug('SPDK bdev %s deleted', spdk_name) LOG.debug('SPDK bdev %s deleted', spdk_name)
else: else:
LOG.debug('Could not find volume %s using SPDK driver', name) LOG.debug('Could not find volume %s using SPDK driver', name)
def _create_volume(self, volume, snapshot=None): def _create_volume(self, volume, snapshot=None):
output = self._rpc_call('get_lvol_stores') output = self._rpc_call('bdev_lvol_get_lvstores')
for lvs in output: for lvs in output:
free_size = (lvs['free_clusters'] * lvs['cluster_size']) free_size = (lvs['free_clusters'] * lvs['cluster_size'])
if free_size / units.Gi >= volume.size: if free_size / units.Gi >= volume.size:
@ -168,22 +168,22 @@ class SPDKDriver(driver.VolumeDriver):
'lvol_name': volume.name, 'lvol_name': volume.name,
'size': volume.size * units.Gi, 'size': volume.size * units.Gi,
'uuid': lvs['uuid']} 'uuid': lvs['uuid']}
output2 = self._rpc_call('construct_lvol_bdev', params) output2 = self._rpc_call('bdev_lvol_create', params)
else: else:
snapshot_spdk_name = ( snapshot_spdk_name = (
self._get_spdk_volume_name(snapshot.name)) self._get_spdk_volume_name(snapshot.name))
params = { params = {
'clone_name': volume.name, 'clone_name': volume.name,
'snapshot_name': snapshot_spdk_name} 'snapshot_name': snapshot_spdk_name}
output2 = self._rpc_call('clone_lvol_bdev', params) output2 = self._rpc_call('bdev_lvol_clone', params)
spdk_name = self._get_spdk_volume_name(volume.name) spdk_name = self._get_spdk_volume_name(volume.name)
params = {'name': spdk_name} params = {'name': spdk_name}
self._rpc_call('inflate_lvol_bdev', params) self._rpc_call('bdev_lvol_inflate', params)
if volume.size > snapshot.volume_size: if volume.size > snapshot.volume_size:
params = {'name': spdk_name, params = {'name': spdk_name,
'size': volume.size * units.Gi} 'size': volume.size * units.Gi}
self._rpc_call('resize_lvol_bdev', params) self._rpc_call('bdev_lvol_resize', params)
LOG.debug('SPDK created lvol: %s', output2) LOG.debug('SPDK created lvol: %s', output2)
@ -196,7 +196,7 @@ class SPDKDriver(driver.VolumeDriver):
def do_setup(self, context): def do_setup(self, context):
try: try:
payload = {'method': 'get_bdevs', 'jsonrpc': '2.0', 'id': 1} payload = {'method': 'bdev_get_bdevs', 'jsonrpc': '2.0', 'id': 1}
self.url = ('http://%(ip)s:%(port)s/' % self.url = ('http://%(ip)s:%(port)s/' %
{'ip': self.configuration.spdk_rpc_ip, {'ip': self.configuration.spdk_rpc_ip,
'port': self.configuration.spdk_rpc_port}) 'port': self.configuration.spdk_rpc_port})
@ -217,7 +217,7 @@ class SPDKDriver(driver.VolumeDriver):
"""Verify that requirements are in place to use LVM driver.""" """Verify that requirements are in place to use LVM driver."""
# If configuration is incorrect we will get exception here # If configuration is incorrect we will get exception here
self._rpc_call('get_bdevs') self._rpc_call('bdev_get_bdevs')
def create_volume(self, volume): def create_volume(self, volume):
"""Creates a logical volume.""" """Creates a logical volume."""
@ -269,10 +269,10 @@ class SPDKDriver(driver.VolumeDriver):
params = { params = {
'lvol_name': spdk_name, 'lvol_name': spdk_name,
'snapshot_name': snapshot['name']} 'snapshot_name': snapshot['name']}
self._rpc_call('snapshot_lvol_bdev', params) self._rpc_call('bdev_lvol_snapshot', params)
params = {'name': spdk_name} params = {'name': spdk_name}
self._rpc_call('inflate_lvol_bdev', params) self._rpc_call('bdev_lvol_inflate', params)
def delete_snapshot(self, snapshot): def delete_snapshot(self, snapshot):
"""Deletes a snapshot.""" """Deletes a snapshot."""
@ -281,12 +281,12 @@ class SPDKDriver(driver.VolumeDriver):
return return
params = {'name': spdk_name} params = {'name': spdk_name}
bdev = self._rpc_call('get_bdevs', params) bdev = self._rpc_call('bdev_get_bdevs', params)
if 'clones' in bdev[0]['driver_specific']['lvol']: if 'clones' in bdev[0]['driver_specific']['lvol']:
for clone in bdev[0]['driver_specific']['lvol']['clones']: for clone in bdev[0]['driver_specific']['lvol']['clones']:
spdk_name = self._get_spdk_volume_name(clone) spdk_name = self._get_spdk_volume_name(clone)
params = {'name': spdk_name} params = {'name': spdk_name}
self._rpc_call('inflate_lvol_bdev', params) self._rpc_call('bdev_lvol_inflate', params)
self._delete_bdev(snapshot.name) self._delete_bdev(snapshot.name)
@ -306,21 +306,21 @@ class SPDKDriver(driver.VolumeDriver):
params = { params = {
'lvol_name': spdk_name, 'lvol_name': spdk_name,
'snapshot_name': snapshot_name} 'snapshot_name': snapshot_name}
self._rpc_call('snapshot_lvol_bdev', params) self._rpc_call('bdev_lvol_snapshot', params)
params = {'name': spdk_name} params = {'name': spdk_name}
self._rpc_call('inflate_lvol_bdev', params) self._rpc_call('bdev_lvol_inflate', params)
snapshot_spdk_name = self._get_spdk_volume_name(snapshot_name) snapshot_spdk_name = self._get_spdk_volume_name(snapshot_name)
params = { params = {
'clone_name': volume.name, 'clone_name': volume.name,
'snapshot_name': snapshot_spdk_name} 'snapshot_name': snapshot_spdk_name}
self._rpc_call('clone_lvol_bdev', params) self._rpc_call('bdev_lvol_clone', params)
spdk_name = self._get_spdk_volume_name(volume.name) spdk_name = self._get_spdk_volume_name(volume.name)
params = {'name': spdk_name} params = {'name': spdk_name}
self._rpc_call('inflate_lvol_bdev', params) self._rpc_call('bdev_lvol_inflate', params)
self._delete_bdev(snapshot_name) self._delete_bdev(snapshot_name)
@ -387,7 +387,7 @@ class SPDKDriver(driver.VolumeDriver):
"""Extend an existing volume's size.""" """Extend an existing volume's size."""
spdk_name = self._get_spdk_volume_name(volume.name) spdk_name = self._get_spdk_volume_name(volume.name)
params = {'name': spdk_name, 'size': new_size * units.Gi} params = {'name': spdk_name, 'size': new_size * units.Gi}
self._rpc_call('resize_lvol_bdev', params) self._rpc_call('bdev_lvol_resize', params)
# ####### Interface methods for DataPath (Target Driver) ######## # ####### Interface methods for DataPath (Target Driver) ########
def ensure_export(self, context, volume): def ensure_export(self, context, volume):

10
cinder/volume/targets/spdknvmf.py
View File

@ -91,7 +91,7 @@ class SpdkNvmf(nvmeof.NVMeOF):
return req.json()['result'] return req.json()['result']
def _get_spdk_volume_name(self, name): def _get_spdk_volume_name(self, name):
output = self._rpc_call('get_bdevs') output = self._rpc_call('bdev_get_bdevs')
for bdev in output: for bdev in output:
for alias in bdev['aliases']: for alias in bdev['aliases']:
@ -99,7 +99,7 @@ class SpdkNvmf(nvmeof.NVMeOF):
return bdev['name'] return bdev['name']
def _get_nqn_with_volume_name(self, name): def _get_nqn_with_volume_name(self, name):
output = self._rpc_call('get_nvmf_subsystems') output = self._rpc_call('nvmf_get_subsystems')
spdk_name = self._get_spdk_volume_name(name) spdk_name = self._get_spdk_volume_name(name)
@ -112,7 +112,7 @@ class SpdkNvmf(nvmeof.NVMeOF):
def _get_first_free_node(self): def _get_first_free_node(self):
cnode_num = [] cnode_num = []
output = self._rpc_call('get_nvmf_subsystems') output = self._rpc_call('nvmf_get_subsystems')
# Get node numbers for nqn string like this: nqn.2016-06.io.spdk:cnode1 # Get node numbers for nqn string like this: nqn.2016-06.io.spdk:cnode1
@ -149,7 +149,7 @@ class SpdkNvmf(nvmeof.NVMeOF):
'allow_any_host': True, 'allow_any_host': True,
'serial_number': serial, 'serial_number': serial,
} }
self._rpc_call('nvmf_subsystem_create', params) self._rpc_call('nvmf_create_subsystem', params)
listen_address = { listen_address = {
'trtype': transport_type, 'trtype': transport_type,
@ -189,7 +189,7 @@ class SpdkNvmf(nvmeof.NVMeOF):
if nqn is not None: if nqn is not None:
try: try:
params = {'nqn': nqn} params = {'nqn': nqn}
self._rpc_call('delete_nvmf_subsystem', params) self._rpc_call('nvmf_delete_subsystem', params)
LOG.debug('SPDK subsystem %s deleted', nqn) LOG.debug('SPDK subsystem %s deleted', nqn)
except Exception as e: except Exception as e:
LOG.debug('SPDK ERROR: subsystem not deleted: %s', e) LOG.debug('SPDK ERROR: subsystem not deleted: %s', e)

3
doc/source/configuration/block-storage/drivers/spdk-volume-driver.rst
View File

@ -15,7 +15,8 @@ SPDK NVMe-oF target installation
-------------------------------- --------------------------------
Follow instructions available on https://spdk.io/doc/nvmf.html to install Follow instructions available on https://spdk.io/doc/nvmf.html to install
and configure environment with SPDK NVMe-oF target application. and configure environment with SPDK NVMe-oF target application. Starting
from Ussuri release SPDK release v19.10 or higher is required.
Storage pools configuration Storage pools configuration
--------------------------- ---------------------------

6
releasenotes/notes/rpc-update-50bef83f48d4f96f.yaml Normal file
View File

@ -0,0 +1,6 @@
---
upgrade:
- |
SPDK target and volume drivers have been updated with new SPDK specific
RPC calls due to deprecation of some old RPC calls. Starting from Ussuri
release SPDK release v19.10 or higher is required.