[Libstoragemgmt-devel] [PATCH 4/4] plugin_test.py: Add test for duplicate ag name

[Tony Asleson]

We are expecting a NAME_CONFLICT error when doing this.

Signed-off-by: Tony Asleson <***@redhat.com>
---
test/plugin_test.py | 51 ++++++++++++++++++++++++++++++++++++++++++++-------
1 file changed, 44 insertions(+), 7 deletions(-)

diff --git a/test/plugin_test.py b/test/plugin_test.py
index 125ff35..9d23844 100755
--- a/test/plugin_test.py
+++ b/test/plugin_test.py
@@ -664,18 +664,18 @@ class TestPlugin(unittest.TestCase):
if vol:
self._volume_delete(vol)

- def _create_access_group(self, cap, s, init_type):
+ def _create_access_group(self, cap, name, s, init_type):
ag_created = None

if init_type == lsm.AccessGroup.INIT_TYPE_ISCSI_IQN:
ag_created = self.c.access_group_create(
- rs('ag'),
+ name,
'iqn.1994-05.com.domain:01.89bd01',
lsm.AccessGroup.INIT_TYPE_ISCSI_IQN, s)

elif init_type == lsm.AccessGroup.INIT_TYPE_WWPN:
ag_created = self.c.access_group_create(
- rs('ag'),
+ name,
r_fcpn(),
lsm.AccessGroup.INIT_TYPE_WWPN, s)

@@ -703,7 +703,7 @@ class TestPlugin(unittest.TestCase):
if supported(cap, [lsm.Capabilities.ACCESS_GROUPS,
lsm.Capabilities.ACCESS_GROUP_CREATE_ISCSI_IQN]):
ag = self._create_access_group(
- cap, s, lsm.AccessGroup.INIT_TYPE_ISCSI_IQN)
+ cap, rs('ag'), s, lsm.AccessGroup.INIT_TYPE_ISCSI_IQN)
if ag is not None and \
supported(cap, [lsm.Capabilities.ACCESS_GROUP_DELETE]):
self._delete_access_group(ag)
@@ -711,7 +711,7 @@ class TestPlugin(unittest.TestCase):
if supported(cap, [lsm.Capabilities.ACCESS_GROUPS,
lsm.Capabilities.ACCESS_GROUP_CREATE_WWPN]):
ag = self._create_access_group(
- cap, s, lsm.AccessGroup.INIT_TYPE_WWPN)
+ cap, rs('ag'), s, lsm.AccessGroup.INIT_TYPE_WWPN)
if ag is not None and \
supported(cap, [lsm.Capabilities.ACCESS_GROUP_DELETE]):
self._delete_access_group(ag)
@@ -776,13 +776,14 @@ class TestPlugin(unittest.TestCase):
cap, [lsm.Capabilities.ACCESS_GROUP_CREATE_ISCSI_IQN,
lsm.Capabilities.ACCESS_GROUP_DELETE]):
ag_to_delete = self._create_access_group(
- cap, s, lsm.AccessGroup.INIT_TYPE_ISCSI_IQN)
+ cap, rs('ag'), s,
+ lsm.AccessGroup.INIT_TYPE_ISCSI_IQN)
ag_list = self.c.access_groups('system_id', s.id)
if supported(
cap, [lsm.Capabilities.ACCESS_GROUP_CREATE_WWPN,
lsm.Capabilities.ACCESS_GROUP_DELETE]):
ag_to_delete = self._create_access_group(
- cap, s, lsm.AccessGroup.INIT_TYPE_WWPN)
+ cap, rs('ag'), s, lsm.AccessGroup.INIT_TYPE_WWPN)
ag_list = self.c.access_groups('system_id', s.id)

if len(ag_list):
@@ -835,6 +836,42 @@ class TestPlugin(unittest.TestCase):
supported(cap, [lsm.Capabilities.VOLUME_DELETE]):
self._volume_delete(vol)

+ def test_duplicate_access_group_name(self):
+ for s in self.systems:
+ ag_to_delete = None
+
+ ag_type = None
+ ag_name = rs('ag_dupe')
+
+ cap = self.c.capabilities(s)
+ if supported(cap, [lsm.Capabilities.ACCESS_GROUPS]):
+ ag_list = self.c.access_groups('system_id', s.id)
+
+ if supported(
+ cap, [lsm.Capabilities.ACCESS_GROUP_CREATE_ISCSI_IQN,
+ lsm.Capabilities.ACCESS_GROUP_DELETE]):
+ ag_type = lsm.AccessGroup.INIT_TYPE_ISCSI_IQN
+
+ elif supported(cap, [lsm.Capabilities.ACCESS_GROUP_CREATE_WWPN,
+ lsm.Capabilities.ACCESS_GROUP_DELETE]):
+ ag_type = lsm.AccessGroup.INIT_TYPE_WWPN
+
+ ag_created = self._create_access_group(
+ cap, ag_name, s, ag_type)
+
+ # Try to create a duplicate
+ got_exception = False
+ try:
+ ag_dupe = self._create_access_group(
+ cap, ag_name, s, ag_type)
+ except LsmError as le:
+ got_exception = True
+ self.assertTrue(le.code == ErrorNumber.NAME_CONFLICT)
+
+ self.assertTrue(got_exception)
+
+ self._delete_access_group(ag_created)
+

def dump_results():
"""

[Tony Asleson]

Signed-off-by: Tony Asleson <***@redhat.com>
---
test/plugin_test.py | 22 ++++++++++++----------
1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/test/plugin_test.py b/test/plugin_test.py
index 24fe687..125ff35 100755
--- a/test/plugin_test.py
+++ b/test/plugin_test.py
@@ -328,6 +328,8 @@ class TestPlugin(unittest.TestCase):
p = self._get_pool_by_usage(system_id,
lsm.Pool.ELEMENT_TYPE_VOLUME)

+ self.assertTrue(p is not None, "Unable to find a suitable pool")
+
if p:
vol_size = self._object_size(p)

@@ -340,16 +342,16 @@ class TestPlugin(unittest.TestCase):

def _fs_create(self, system_id):
if system_id in self.pool_by_sys_id:
- pools = self.pool_by_sys_id[system_id]
-
- for p in pools:
- if p.free_space > mb_in_bytes(MIN_POOL_SIZE) and \
- p.element_type & lsm.Pool.ELEMENT_TYPE_FS:
- fs_size = self._object_size(p)
- fs = self.c.fs_create(p, rs('fs'), fs_size)[1]
- self.assertTrue(self._fs_exists(fs.id))
- return fs, p
- return None, None
+ pool = self._get_pool_by_usage(system_id,
+ lsm.Pool.ELEMENT_TYPE_FS)
+
+ fs_size = self._object_size(pool)
+ fs = self.c.fs_create(pool, rs('fs'), fs_size)[1]
+ self.assertTrue(self._fs_exists(fs.id))
+
+ self.assertTrue(fs is not None)
+ self.assertTrue(pool is not None)
+ return fs, pool

def _volume_delete(self, volume):
self.c.volume_delete(volume)

[Tony Asleson]

This is unique and it allows NetApp users a framiliar id
when looking at logical units.

Signed-off-by: Tony Asleson <***@redhat.com>
---
plugin/ontap/ontap.py | 38 ++++++++++++++++++++++----------------
1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/plugin/ontap/ontap.py b/plugin/ontap/ontap.py
index a921854..89b0e4d 100644
--- a/plugin/ontap/ontap.py
+++ b/plugin/ontap/ontap.py
@@ -95,6 +95,10 @@ def _na_init_type_to_lsm(na_ag):
return AccessGroup.INIT_TYPE_UNKNOWN


+def _lsm_vol_to_na_vol_path(vol):
+ return vol.id
+
+
class Ontap(IStorageAreaNetwork, INfs):
TMO_CONV = 1000.0

@@ -205,10 +209,10 @@ class Ontap(IStorageAreaNetwork, INfs):
block_size = int(l['block-size'])
num_blocks = int(l['size']) / block_size
#TODO: Need to retrieve actual volume status
- return Volume(md5(l['serial-number']), self._lsm_lun_name(l['path']),
+ return Volume(l['path'], self._lsm_lun_name(l['path']),
Ontap._create_vpd(l['serial-number']), block_size,
num_blocks, Volume.STATUS_OK, self.sys_info.id,
- l['aggr'], l['path'])
+ l['aggr'])

def _vol(self, v, pools=None):
pool_name = v['containing-aggregate']
@@ -511,7 +515,7 @@ class Ontap(IStorageAreaNetwork, INfs):

@staticmethod
def _vol_to_na_volume_name(volume):
- return os.path.dirname(volume.plugin_data)[5:]
+ return os.path.dirname(_lsm_vol_to_na_vol_path(volume))[5:]

@handle_ontap_errors
def volume_delete(self, volume, flags=0):
@@ -521,9 +525,9 @@ class Ontap(IStorageAreaNetwork, INfs):
na_volume_name=vol)

if len(luns) == 1 and na.Filer.LSM_VOL_PREFIX in vol:
- self.f.volume_delete(volume.plugin_data)
+ self.f.volume_delete(_lsm_vol_to_na_vol_path(volume))
else:
- self.f.lun_delete(volume.plugin_data)
+ self.f.lun_delete(_lsm_vol_to_na_vol_path(volume))

return None

@@ -533,8 +537,9 @@ class Ontap(IStorageAreaNetwork, INfs):

@handle_ontap_errors
def volume_resize(self, volume, new_size_bytes, flags=0):
- self.f.lun_resize(volume.plugin_data, new_size_bytes)
- return None, self._get_volume(volume.plugin_data, volume.pool_id)
+ self.f.lun_resize(_lsm_vol_to_na_vol_path(volume), new_size_bytes)
+ return None, self._get_volume(_lsm_vol_to_na_vol_path(volume),
+ volume.pool_id)

def _volume_on_aggr(self, pool, volume):
search = Ontap._vol_to_na_volume_name(volume)
@@ -552,8 +557,9 @@ class Ontap(IStorageAreaNetwork, INfs):
#the pool itself is None
if pool is None or self._volume_on_aggr(pool, volume_src):
#Thin provision copy the logical unit
- dest = os.path.dirname(volume_src.plugin_data) + '/' + name
- self.f.clone(volume_src.plugin_data, dest)
+ dest = os.path.dirname(_lsm_vol_to_na_vol_path(volume_src)) + '/' \
+ + name
+ self.f.clone(_lsm_vol_to_na_vol_path(volume_src), dest)
return None, self._get_volume(dest, volume_src.pool_id)
else:
#TODO Need to get instructions on how to provide this
@@ -570,25 +576,25 @@ class Ontap(IStorageAreaNetwork, INfs):
flags=0):
if rep_type != Volume.REPLICATE_CLONE:
raise LsmError(ErrorNumber.NO_SUPPORT, "rep_type not supported")
- self.f.clone(volume_src.plugin_data, volume_dest.plugin_data, None,
- ranges)
+ self.f.clone(_lsm_vol_to_na_vol_path(volume_src),
+ _lsm_vol_to_na_vol_path(volume_dest), None, ranges)

@handle_ontap_errors
def volume_online(self, volume, flags=0):
- return self.f.lun_online(volume.plugin_data)
+ return self.f.lun_online(_lsm_vol_to_na_vol_path(volume))

@handle_ontap_errors
def volume_offline(self, volume, flags=0):
- return self.f.lun_offline(volume.plugin_data)
+ return self.f.lun_offline(_lsm_vol_to_na_vol_path(volume))

@handle_ontap_errors
def volume_mask(self, access_group, volume, flags=0):
- self.f.lun_map(access_group.name, volume.plugin_data)
+ self.f.lun_map(access_group.name, _lsm_vol_to_na_vol_path(volume))
return None

@handle_ontap_errors
def volume_unmask(self, access_group, volume, flags=0):
- self.f.lun_unmap(access_group.name, volume.plugin_data)
+ self.f.lun_unmap(access_group.name, _lsm_vol_to_na_vol_path(volume))
return None

@staticmethod
@@ -712,7 +718,7 @@ class Ontap(IStorageAreaNetwork, INfs):

@handle_ontap_errors
def access_groups_granted_to_volume(self, volume, flags=0):
- groups = self.f.lun_map_list_info(volume.plugin_data)
+ groups = self.f.lun_map_list_info(_lsm_vol_to_na_vol_path(volume))
return [self._access_group(g) for g in groups]

@handle_ontap_errors