From 504514d294cd573bfebe4b86bc2d38b9302469ee Mon Sep 17 00:00:00 2001 From: Avishay Traeger Date: Thu, 13 Sep 2012 09:23:40 +0300 Subject: [PATCH] Fix config opts for Storwize/SVC volume driver. Removed the "vtype" option which did not work in the driver, and added the "easytier" option. Added another check to _check_flags and made sure -warning flag is passed properly. Added unit tests to check all option variations. Fixes bug 1049446. Change-Id: I135ed85ad1b9d60e6a8cc406aa49360e0f080039 --- etc/nova/nova.conf.sample | 6 +- nova/tests/test_storwize_svc.py | 306 +++++++++++++++++++++++--------- nova/volume/storwize_svc.py | 106 +++++------ 3 files changed, 271 insertions(+), 147 deletions(-) diff --git a/etc/nova/nova.conf.sample b/etc/nova/nova.conf.sample index a673cb84778c..13cc5289d694 100644 --- a/etc/nova/nova.conf.sample +++ b/etc/nova/nova.conf.sample @@ -1999,9 +1999,6 @@ # storwize_svc_volpool_name=volpool #### (StrOpt) Storage system storage pool for volumes -# storwize_svc_vol_vtype=striped -#### (StrOpt) Storage system volume type for volumes - # storwize_svc_vol_rsize=2% #### (StrOpt) Storage system space-efficiency parameter for volumes @@ -2018,6 +2015,9 @@ # storwize_svc_vol_compression=false #### (BoolOpt) Storage system compression option for volumes +# storwize_svc_vol_easytier=true +#### (BoolOpt) Enable Easy Tier for volumes + # storwize_svc_flashcopy_timeout=120 #### (StrOpt) Maximum number of seconds to wait for FlashCopy to be #### prepared. Maximum value is 600 seconds (10 minutes). diff --git a/nova/tests/test_storwize_svc.py b/nova/tests/test_storwize_svc.py index ac17f09689d3..c74cc6b9f4d2 100644 --- a/nova/tests/test_storwize_svc.py +++ b/nova/tests/test_storwize_svc.py @@ -28,11 +28,14 @@ import random import socket from nova import exception +from nova import flags from nova.openstack.common import excutils from nova.openstack.common import log as logging from nova import test from nova.volume import storwize_svc +FLAGS = flags.FLAGS + LOG = logging.getLogger(__name__) @@ -46,6 +49,7 @@ class StorwizeSVCManagementSimulator: self._next_cmd_error = { "lsportip": "", "lsnodecanister": "", + "mkvdisk": "", "lsvdisk": "", "lsfcmap": "", "prestartfcmap": "", @@ -92,6 +96,9 @@ class StorwizeSVCManagementSimulator: "virtual disks (VDisks) are different sizes."), "CMMVC6303E": ("", "CMMVC6303E The create failed because the " + "source and target VDisks are the same."), + "CMMVC7050E": ("", "CMMVC7050E The command failed because at " + + "least one node in the I/O group does not " + + "support compressed VDisks."), } # Find an unused ID @@ -142,7 +149,8 @@ class StorwizeSVCManagementSimulator: "source", "target", "unit", - "vtype", + "easytier", + "warning", ] # Handle the special case of lsnode which is a two-word command @@ -182,16 +190,20 @@ class StorwizeSVCManagementSimulator: # Print mostly made-up stuff in the correct syntax def _cmd_lsmdiskgrp(self, **kwargs): - rows = [None] * 2 + rows = [None] * 3 rows[0] = ["id", "name", "status", "mdisk_count", "vdisk_count capacity", "extent_size", "free_capacity", "virtual_capacity", "used_capacity", "real_capacity", "overallocation", "warning", "easy_tier", "easy_tier_status"] - rows[1] = ["0", self._flags["storwize_svc_volpool_name"], "online", + rows[1] = ["1", self._flags["storwize_svc_volpool_name"], "online", "1", str(len(self._volumes_list)), "3.25TB", "256", "3.21TB", "1.54TB", "264.97MB", "35.58GB", "47", "80", "auto", "inactive"] + rows[2] = ["2", "volpool2", "online", + "1", "0", "3.25TB", "256", + "3.21TB", "1.54TB", "264.97MB", "35.58GB", "47", "80", + "auto", "inactive"] return self._print_info_cmd(rows=rows, **kwargs) # Print mostly made-up stuff in the correct syntax @@ -302,17 +314,64 @@ class StorwizeSVCManagementSimulator: unit = kwargs["unit"] if unit == "b": - volume_info["capacity"] = capacity + cap_bytes = capacity elif unit == "kb": - volume_info["capacity"] = capacity * pow(1024, 1) + cap_bytes = capacity * pow(1024, 1) elif unit == "mb": - volume_info["capacity"] = capacity * pow(1024, 2) + cap_bytes = capacity * pow(1024, 2) elif unit == "gb": - volume_info["capacity"] = capacity * pow(1024, 3) + cap_bytes = capacity * pow(1024, 3) elif unit == "tb": - volume_info["capacity"] = capacity * pow(1024, 4) + cap_bytes = capacity * pow(1024, 4) elif unit == "pb": - volume_info["capacity"] = capacity * pow(1024, 5) + cap_bytes = capacity * pow(1024, 5) + volume_info["cap_bytes"] = str(cap_bytes) + volume_info["capacity"] = str(capacity) + unit.upper() + + if "easytier" in kwargs: + if kwargs["easytier"] == "on": + volume_info["easy_tier"] = "on" + else: + volume_info["easy_tier"] = "off" + + if "rsize" in kwargs: + # Fake numbers + volume_info["used_capacity"] = "0.75MB" + volume_info["real_capacity"] = "36.98MB" + volume_info["free_capacity"] = "36.23MB" + volume_info["used_capacity_bytes"] = "786432" + volume_info["real_capacity_bytes"] = "38776340" + volume_info["free_capacity_bytes"] = "37989908" + if "warning" in kwargs: + volume_info["warning"] = kwargs["warning"].rstrip('%') + else: + volume_info["warning"] = "80" + if "autoexpand" in kwargs: + volume_info["autoexpand"] = "on" + else: + volume_info["autoexpand"] = "off" + if "grainsize" in kwargs: + volume_info["grainsize"] = kwargs["grainsize"] + else: + volume_info["grainsize"] = "32" + if "compressed" in kwargs: + if self._next_cmd_error["mkvdisk"] == "no_compression": + self._next_cmd_error["mkvdisk"] = "" + return self._errors["CMMVC7050E"] + volume_info["compressed_copy"] = "yes" + else: + volume_info["compressed_copy"] = "no" + else: + volume_info["used_capacity"] = volume_info["capacity"] + volume_info["real_capacity"] = volume_info["capacity"] + volume_info["free_capacity"] = "0.00MB" + volume_info["used_capacity_bytes"] = volume_info["cap_bytes"] + volume_info["real_capacity_bytes"] = volume_info["cap_bytes"] + volume_info["free_capacity_bytes"] = "0" + volume_info["warning"] = "" + volume_info["autoexpand"] = "" + volume_info["grainsize"] = "" + volume_info["compressed_copy"] = "no" if volume_info["name"] in self._volumes_list: return self._errors["CMMVC6035E"] @@ -375,10 +434,14 @@ class StorwizeSVCManagementSimulator: (kwargs["filtervalue"] == "name=" + vol["name"])): fcmap_info = self._get_fcmap_info(vol["name"]) + if "bytes" in kwargs: + cap = vol["cap_bytes"] + else: + cap = vol["capacity"] rows.append([str(vol["id"]), vol["name"], "0", "io_grp0", "online", "0", self._flags["storwize_svc_volpool_name"], - str(vol["capacity"]), "striped", + cap, "striped", fcmap_info["fc_id"], fcmap_info["fc_name"], "", "", vol["uid"], fcmap_info["fc_map_count"], "1", "empty", @@ -391,7 +454,18 @@ class StorwizeSVCManagementSimulator: return self._errors["CMMVC5754E"] vol = self._volumes_list[kwargs["obj"]] fcmap_info = self._get_fcmap_info(vol["name"]) + if "bytes" in kwargs: + cap = vol["cap_bytes"] + cap_u = vol["used_capacity_bytes"] + cap_r = vol["real_capacity_bytes"] + cap_f = vol["free_capacity_bytes"] + else: + cap = vol["capacity"] + cap_u = vol["used_capacity"] + cap_r = vol["real_capacity"] + cap_f = vol["free_capacity"] rows = [] + rows.append(["id", str(vol["id"])]) rows.append(["name", vol["name"]]) rows.append(["IO_group_id", "0"]) @@ -400,7 +474,7 @@ class StorwizeSVCManagementSimulator: rows.append(["mdisk_grp_id", "0"]) rows.append(["mdisk_grp_name", self._flags["storwize_svc_volpool_name"]]) - rows.append(["capacity", str(vol["capacity"])]) + rows.append(["capacity", cap]) rows.append(["type", "striped"]) rows.append(["formatted", "no"]) rows.append(["mdisk_id", ""]) @@ -428,6 +502,14 @@ class StorwizeSVCManagementSimulator: rows.append(["se_copy_count", "0"]) rows.append(["mirror_write_priority", "latency"]) rows.append(["RC_change", "no"]) + rows.append(["used_capacity", cap_u]) + rows.append(["real_capacity", cap_r]) + rows.append(["free_capacity", cap_f]) + rows.append(["autoexpand", vol["autoexpand"]]) + rows.append(["warning", vol["warning"]]) + rows.append(["grainsize", vol["grainsize"]]) + rows.append(["easy_tier", vol["easy_tier"]]) + rows.append(["compressed_copy", vol["compressed_copy"]]) if "nohdr" in kwargs: for index in range(len(rows)): @@ -625,8 +707,8 @@ class StorwizeSVCManagementSimulator: if source == target: return self._errors["CMMVC6303E"] - if (self._volumes_list[source]["capacity"] != - self._volumes_list[target]["capacity"]): + if (self._volumes_list[source]["cap_bytes"] != + self._volumes_list[target]["cap_bytes"]): return self._errors["CMMVC5924E"] fcmap_info = {} @@ -835,27 +917,29 @@ class StorwizeSVCDriverTestCase(test.TestCase): super(StorwizeSVCDriverTestCase, self).setUp() self.USESIM = 1 if self.USESIM == 1: + self.flags( + san_ip="hostname", + san_login="user", + san_password="pass", + storwize_svc_flashcopy_timeout="20", + ) self.sim = StorwizeSVCManagementSimulator("volpool") - driver = StorwizeSVCFakeDriver() - driver.set_fake_storage(self.sim) - storwize_svc.FLAGS.san_ip = "hostname" - storwize_svc.FLAGS.san_login = "user" - storwize_svc.FLAGS.san_password = "pass" - storwize_svc.FLAGS.storwize_svc_volpool_name = "volpool" - storwize_svc.FLAGS.storwize_svc_flashcopy_timeout = "20" + self.driver = StorwizeSVCFakeDriver() + self.driver.set_fake_storage(self.sim) else: - driver = storwize_svc.StorwizeSVCDriver() - storwize_svc.FLAGS.san_ip = "-1.-1.-1.-1" - storwize_svc.FLAGS.san_login = "user" - storwize_svc.FLAGS.san_password = "password" - storwize_svc.FLAGS.storwize_svc_volpool_name = "pool" + self.flags( + san_ip="-1.-1.-1.-1", + san_login="user", + san_password="password", + storwize_svc_volpool_name="pool", + ) + self.driver = storwize_svc.StorwizeSVCDriver() - self.driver = driver self.driver.do_setup(None) self.driver.check_for_setup_error() def test_storwize_svc_volume_tests(self): - storwize_svc.FLAGS.storwize_svc_vol_rsize = "-1" + self.flags(storwize_svc_vol_rsize="-1") volume = {} volume["name"] = "test1_volume%s" % random.randint(10000, 99999) volume["size"] = 10 @@ -867,48 +951,38 @@ class StorwizeSVCDriverTestCase(test.TestCase): self.driver.delete_volume(volume) if self.USESIM == 1: - saved_rsize = storwize_svc.FLAGS.storwize_svc_vol_rsize - saved_comp = storwize_svc.FLAGS.storwize_svc_vol_compression - storwize_svc.FLAGS.storwize_svc_vol_rsize = "2%" - storwize_svc.FLAGS.storwize_svc_vol_compression = True + self.flags(storwize_svc_vol_rsize="2%") + self.flags(storwize_svc_vol_compression=True) self.driver.create_volume(volume) is_volume_defined = self.driver._is_volume_defined(volume["name"]) self.assertEqual(is_volume_defined, True) self.driver.delete_volume(volume) - storwize_svc.FLAGS.storwize_svc_vol_rsize = saved_rsize - storwize_svc.FLAGS.storwize_svc_vol_compression = saved_comp + FLAGS.reset() def test_storwize_svc_ip_connectivity(self): # Check for missing san_ip - saved = storwize_svc.FLAGS.san_ip - storwize_svc.FLAGS.san_ip = None + self.flags(san_ip=None) self.assertRaises(exception.InvalidInput, self.driver._check_flags) - storwize_svc.FLAGS.san_ip = saved if self.USESIM != 1: - saved = storwize_svc.FLAGS.san_ip - # Check for invalid ip - storwize_svc.FLAGS.san_ip = "-1.-1.-1.-1" + self.flags(san_ip="-1.-1.-1.-1") self.assertRaises(socket.gaierror, self.driver.check_for_setup_error) # Check for unreachable IP - storwize_svc.FLAGS.san_ip = "1.1.1.1" + self.flags(san_ip="1.1.1.1") self.assertRaises(socket.error, self.driver.check_for_setup_error) - storwize_svc.FLAGS.san_ip = saved - def test_storwize_svc_connectivity(self): # Make sure we detect if the pool doesn't exist - orig_pool = getattr(storwize_svc.FLAGS, "storwize_svc_volpool_name") no_exist_pool = "i-dont-exist-%s" % random.randint(10000, 99999) - storwize_svc.FLAGS.storwize_svc_volpool_name = no_exist_pool + self.flags(storwize_svc_volpool_name=no_exist_pool) self.assertRaises(exception.InvalidInput, self.driver.check_for_setup_error) - storwize_svc.FLAGS.storwize_svc_volpool_name = orig_pool + FLAGS.reset() # Check the case where the user didn't configure IP addresses # as well as receiving unexpected results from the storage @@ -930,57 +1004,49 @@ class StorwizeSVCDriverTestCase(test.TestCase): self.driver.check_for_setup_error) # Check with bad parameters - saved_pass = storwize_svc.FLAGS.san_password - saved_key = storwize_svc.FLAGS.san_private_key - storwize_svc.FLAGS.san_password = None - storwize_svc.FLAGS.san_private_key = None + self.flags(san_password=None) + self.flags(san_private_key=None) self.assertRaises(exception.InvalidInput, self.driver._check_flags) - storwize_svc.FLAGS.san_password = saved_pass - storwize_svc.FLAGS.san_private_key = saved_key + FLAGS.reset() - saved = storwize_svc.FLAGS.storwize_svc_vol_vtype - storwize_svc.FLAGS.storwize_svc_vol_vtype = "invalid" + self.flags(storwize_svc_vol_rsize="invalid") self.assertRaises(exception.InvalidInput, self.driver._check_flags) - storwize_svc.FLAGS.storwize_svc_vol_vtype = saved + FLAGS.reset() - saved = storwize_svc.FLAGS.storwize_svc_vol_rsize - storwize_svc.FLAGS.storwize_svc_vol_rsize = "invalid" + self.flags(storwize_svc_vol_warning="invalid") self.assertRaises(exception.InvalidInput, self.driver._check_flags) - storwize_svc.FLAGS.storwize_svc_vol_rsize = saved + FLAGS.reset() - saved = storwize_svc.FLAGS.storwize_svc_vol_warning - storwize_svc.FLAGS.storwize_svc_vol_warning = "invalid" + self.flags(storwize_svc_vol_autoexpand="invalid") self.assertRaises(exception.InvalidInput, self.driver._check_flags) - storwize_svc.FLAGS.storwize_svc_vol_warning = saved + FLAGS.reset() - saved = storwize_svc.FLAGS.storwize_svc_vol_autoexpand - storwize_svc.FLAGS.storwize_svc_vol_autoexpand = "invalid" + self.flags(storwize_svc_vol_grainsize=str(42)) self.assertRaises(exception.InvalidInput, self.driver._check_flags) - storwize_svc.FLAGS.storwize_svc_vol_autoexpand = saved + FLAGS.reset() - saved = storwize_svc.FLAGS.storwize_svc_vol_grainsize - storwize_svc.FLAGS.storwize_svc_vol_grainsize = str(42) + self.flags(storwize_svc_flashcopy_timeout=str(601)) self.assertRaises(exception.InvalidInput, self.driver._check_flags) - storwize_svc.FLAGS.storwize_svc_vol_grainsize = saved + FLAGS.reset() - saved = storwize_svc.FLAGS.storwize_svc_flashcopy_timeout - storwize_svc.FLAGS.storwize_svc_flashcopy_timeout = str(601) + self.flags(storwize_svc_vol_compression=True) + self.flags(storwize_svc_vol_rsize="-1") self.assertRaises(exception.InvalidInput, self.driver._check_flags) - storwize_svc.FLAGS.storwize_svc_flashcopy_timeout = saved + FLAGS.reset() # Finally, check with good parameters self.driver.check_for_setup_error() def test_storwize_svc_flashcopy(self): volume1 = {} - volume1["name"] = "test_volume%s" % random.randint(10000, 99999) + volume1["name"] = "test1_volume%s" % random.randint(10000, 99999) volume1["size"] = 10 volume1["id"] = 10 self.driver.create_volume(volume1) @@ -990,13 +1056,12 @@ class StorwizeSVCDriverTestCase(test.TestCase): snapshot["volume_name"] = volume1["name"] # Test timeout and volume cleanup - saved = storwize_svc.FLAGS.storwize_svc_flashcopy_timeout - storwize_svc.FLAGS.storwize_svc_flashcopy_timeout = str(1) + self.flags(storwize_svc_flashcopy_timeout=str(1)) self.assertRaises(exception.InvalidSnapshot, self.driver.create_snapshot, snapshot) is_volume_defined = self.driver._is_volume_defined(snapshot["name"]) self.assertEqual(is_volume_defined, False) - storwize_svc.FLAGS.storwize_svc_flashcopy_timeout = saved + FLAGS.reset() # Test bogus statuses if self.USESIM == 1: @@ -1069,7 +1134,7 @@ class StorwizeSVCDriverTestCase(test.TestCase): # Check with target with different size volume3 = {} - volume3["name"] = "test_volume%s" % random.randint(10000, 99999) + volume3["name"] = "test3_volume%s" % random.randint(10000, 99999) volume3["size"] = 11 volume3["id"] = 11 self.driver.create_volume(volume3) @@ -1107,10 +1172,8 @@ class StorwizeSVCDriverTestCase(test.TestCase): attributes = self.driver._get_volume_attributes(volume["name"]) attr_size = float(attributes["capacity"]) / 1073741824 # bytes to GB self.assertEqual(attr_size, float(volume["size"])) - pool = getattr(storwize_svc.FLAGS, "storwize_svc_volpool_name") + pool = storwize_svc.FLAGS.storwize_svc_volpool_name self.assertEqual(attributes["mdisk_grp_name"], pool) - vtype = getattr(storwize_svc.FLAGS, "storwize_svc_vol_vtype") - self.assertEqual(attributes["type"], vtype) # Try to create the volume again (should fail) self.assertRaises(exception.ProcessExecutionError, @@ -1125,14 +1188,91 @@ class StorwizeSVCDriverTestCase(test.TestCase): # Delete the volume self.driver.delete_volume(volume) - # Check auto-expand option - saved = storwize_svc.FLAGS.storwize_svc_vol_autoexpand - storwize_svc.FLAGS.storwize_svc_vol_autoexpand = False + def _create_test_vol(self): + volume = {} + volume["name"] = "testparam_volume%s" % random.randint(10000, 99999) + volume["size"] = 1 + volume["id"] = 1 self.driver.create_volume(volume) - is_volume_defined = self.driver._is_volume_defined(volume["name"]) - self.assertEqual(is_volume_defined, True) + + attrs = self.driver._get_volume_attributes(volume["name"]) self.driver.delete_volume(volume) - storwize_svc.FLAGS.storwize_svc_vol_autoexpand = saved + return attrs + + def test_storwize_svc_volume_params(self): + # Option test matrix + # Option Value Covered by test # + # rsize -1 1 + # rsize 2% 2,3 + # warning 0 2 + # warning 80% 3 + # autoexpand True 2 + # autoexpand False 3 + # grainsize 32 2 + # grainsize 256 3 + # compression True 4 + # compression False 2,3 + # easytier True 1,3 + # easytier False 2 + + # Test 1 + self.flags(storwize_svc_vol_rsize="-1") + self.flags(storwize_svc_vol_easytier=True) + attrs = self._create_test_vol() + self.assertEquals(attrs["free_capacity"], "0") + self.assertEquals(attrs["easy_tier"], "on") + FLAGS.reset() + + # Test 2 + self.flags(storwize_svc_vol_rsize="2%") + self.flags(storwize_svc_vol_compression=False) + self.flags(storwize_svc_vol_warning="0") + self.flags(storwize_svc_vol_autoexpand=True) + self.flags(storwize_svc_vol_grainsize="32") + self.flags(storwize_svc_vol_easytier=False) + attrs = self._create_test_vol() + self.assertNotEqual(attrs["capacity"], attrs["real_capacity"]) + self.assertEquals(attrs["compressed_copy"], "no") + self.assertEquals(attrs["warning"], "0") + self.assertEquals(attrs["autoexpand"], "on") + self.assertEquals(attrs["grainsize"], "32") + self.assertEquals(attrs["easy_tier"], "off") + FLAGS.reset() + + # Test 3 + self.flags(storwize_svc_vol_rsize="2%") + self.flags(storwize_svc_vol_compression=False) + self.flags(storwize_svc_vol_warning="80%") + self.flags(storwize_svc_vol_autoexpand=False) + self.flags(storwize_svc_vol_grainsize="256") + self.flags(storwize_svc_vol_easytier=True) + attrs = self._create_test_vol() + self.assertNotEqual(attrs["capacity"], attrs["real_capacity"]) + self.assertEquals(attrs["compressed_copy"], "no") + self.assertEquals(attrs["warning"], "80") + self.assertEquals(attrs["autoexpand"], "off") + self.assertEquals(attrs["grainsize"], "256") + self.assertEquals(attrs["easy_tier"], "on") + FLAGS.reset() + + # Test 4 + self.flags(storwize_svc_vol_rsize="2%") + self.flags(storwize_svc_vol_compression=True) + try: + attrs = self._create_test_vol() + self.assertNotEqual(attrs["capacity"], attrs["real_capacity"]) + self.assertEquals(attrs["compressed_copy"], "yes") + except exception.ProcessExecutionError as e: + if "CMMVC7050E" not in e.stderr: + raise exception.ProcessExecutionError(exit_code=e.exit_code, + stdout=e.stdout, + stderr=e.stderr, + cmd=e.cmd) + if self.USESIM == 1: + self.sim.error_injection("mkvdisk", "no_compression") + self.assertRaises(exception.ProcessExecutionError, + self._create_test_vol) + FLAGS.reset() def test_storwize_svc_unicode_host_and_volume_names(self): volume1 = {} diff --git a/nova/volume/storwize_svc.py b/nova/volume/storwize_svc.py index d9b92126e490..52a735018497 100644 --- a/nova/volume/storwize_svc.py +++ b/nova/volume/storwize_svc.py @@ -28,9 +28,9 @@ Notes: key file only. 2. When using a key file for authentication, it is up to the user or system administrator to store the private key in a safe manner. -3. The defaults for creating volumes are "-vtype striped -rsize 2% -autoexpand - -grainsize 256 -warning 0". These can be changed in the configuration file - (recommended only for advanced users). +3. The defaults for creating volumes are "-rsize 2% -autoexpand + -grainsize 256 -warning 0". These can be changed in the configuration + file or by using volume types(recommended only for advanced users). Limitations: 1. The driver was not tested with SVC or clustered configurations of Storwize @@ -57,9 +57,6 @@ storwize_svc_opts = [ cfg.StrOpt('storwize_svc_volpool_name', default='volpool', help='Storage system storage pool for volumes'), - cfg.StrOpt('storwize_svc_vol_vtype', - default='striped', - help='Storage system volume type for volumes'), cfg.StrOpt('storwize_svc_vol_rsize', default='2%', help='Storage system space-efficiency parameter for volumes'), @@ -77,6 +74,9 @@ storwize_svc_opts = [ cfg.BoolOpt('storwize_svc_vol_compression', default=False, help='Storage system compression option for volumes'), + cfg.BoolOpt('storwize_svc_vol_easytier', + default=True, + help='Enable Easy Tier for volumes'), cfg.StrOpt('storwize_svc_flashcopy_timeout', default='120', help='Maximum number of seconds to wait for FlashCopy to be ' @@ -149,11 +149,11 @@ class StorwizeSVCDriver(san.SanISCSIDriver): % {'cmd': ssh_cmd, 'out': str(out), 'err': str(err)}) - search_text = '!%s!' % getattr(FLAGS, 'storwize_svc_volpool_name') + search_text = '!%s!' % FLAGS.storwize_svc_volpool_name if search_text not in out: raise exception.InvalidInput( reason=(_('pool %s doesn\'t exist') - % getattr(FLAGS, 'storwize_svc_volpool_name'))) + % FLAGS.storwize_svc_volpool_name)) storage_nodes = {} # Get the iSCSI names of the Storwize/SVC nodes @@ -326,45 +326,29 @@ class StorwizeSVCDriver(san.SanISCSIDriver): reason=_('%s is not set') % flag) # Ensure that either password or keyfile were set - if not (getattr(FLAGS, 'san_password', None) - or getattr(FLAGS, 'san_private_key', None)): + if not (FLAGS.san_password or FLAGS.san_private_key): raise exception.InvalidInput( reason=_('Password or SSH private key is required for ' 'authentication: set either san_password or ' 'san_private_key option')) - # vtype should either be 'striped' or 'seq' - vtype = getattr(FLAGS, 'storwize_svc_vol_vtype') - if vtype not in ['striped', 'seq']: - raise exception.InvalidInput( - reason=_('Illegal value specified for storwize_svc_vol_vtype: ' - 'set to either \'striped\' or \'seq\'')) - # Check that rsize is a number or percentage - rsize = getattr(FLAGS, 'storwize_svc_vol_rsize') - if not self._check_num_perc(rsize) and (rsize not in ['auto', '-1']): + rsize = FLAGS.storwize_svc_vol_rsize + if not self._check_num_perc(rsize) and (rsize != '-1'): raise exception.InvalidInput( reason=_('Illegal value specified for storwize_svc_vol_rsize: ' 'set to either a number or a percentage')) # Check that warning is a number or percentage - warning = getattr(FLAGS, 'storwize_svc_vol_warning') + warning = FLAGS.storwize_svc_vol_warning if not self._check_num_perc(warning): raise exception.InvalidInput( reason=_('Illegal value specified for ' 'storwize_svc_vol_warning: ' 'set to either a number or a percentage')) - # Check that autoexpand is a boolean - autoexpand = getattr(FLAGS, 'storwize_svc_vol_autoexpand') - if type(autoexpand) != type(True): - raise exception.InvalidInput( - reason=_('Illegal value specified for ' - 'storwize_svc_vol_autoexpand: set to either ' - 'True or False')) - # Check that grainsize is 32/64/128/256 - grainsize = getattr(FLAGS, 'storwize_svc_vol_grainsize') + grainsize = FLAGS.storwize_svc_vol_grainsize if grainsize not in ['32', '64', '128', '256']: raise exception.InvalidInput( reason=_('Illegal value specified for ' @@ -372,7 +356,7 @@ class StorwizeSVCDriver(san.SanISCSIDriver): '\'32\', \'64\', \'128\', or \'256\'')) # Check that flashcopy_timeout is numeric and 32/64/128/256 - flashcopy_timeout = getattr(FLAGS, 'storwize_svc_flashcopy_timeout') + flashcopy_timeout = FLAGS.storwize_svc_flashcopy_timeout if not (flashcopy_timeout.isdigit() and int(flashcopy_timeout) > 0 and int(flashcopy_timeout) <= 600): raise exception.InvalidInput( @@ -381,13 +365,13 @@ class StorwizeSVCDriver(san.SanISCSIDriver): 'valid values are between 0 and 600') % flashcopy_timeout) - # Check that compression is a boolean - volume_compression = getattr(FLAGS, 'storwize_svc_vol_compression') - if type(volume_compression) != type(True): + # Check that rsize is set + volume_compression = FLAGS.storwize_svc_vol_compression + if ((volume_compression == True) and + (FLAGS.storwize_svc_vol_rsize == '-1')): raise exception.InvalidInput( - reason=_('Illegal value specified for ' - 'storwize_svc_vol_compression: set to either ' - 'True or False')) + reason=_('If compression is set to True, rsize must ' + 'also be set (not equal to -1)')) def do_setup(self, context): """Validate the flags.""" @@ -402,42 +386,43 @@ class StorwizeSVCDriver(san.SanISCSIDriver): def _create_volume(self, volume, units='gb'): """Create a new volume.""" - default_size = '1' # 1GB name = volume['name'] model_update = None LOG.debug(_('enter: create_volume: volume %s ') % name) - if int(volume['size']) > 0: - size = int(volume['size']) - else: - size = default_size + size = int(volume['size']) - if getattr(FLAGS, 'storwize_svc_vol_autoexpand'): - autoexpand = '-autoexpand' + if FLAGS.storwize_svc_vol_autoexpand == True: + autoex = '-autoexpand' else: - autoexpand = '' + autoex = '' + + if FLAGS.storwize_svc_vol_easytier == True: + easytier = '-easytier on' + else: + easytier = '-easytier off' # Set space-efficient options - if getattr(FLAGS, 'storwize_svc_vol_rsize').strip() == '-1': + if FLAGS.storwize_svc_vol_rsize.strip() == '-1': ssh_cmd_se_opt = '' else: - ssh_cmd_se_opt = ('-rsize %(rsize)s %(autoexpand)s ' % - {'rsize': getattr(FLAGS, 'storwize_svc_vol_rsize'), - 'autoexpand': autoexpand}) - if getattr(FLAGS, 'storwize_svc_vol_compression'): - ssh_cmd_se_opt = ssh_cmd_se_opt + '-compressed' + ssh_cmd_se_opt = ('-rsize %(rsize)s %(autoex)s -warning %(warn)s' % + {'rsize': FLAGS.storwize_svc_vol_rsize, + 'autoex': autoex, + 'warn': FLAGS.storwize_svc_vol_warning}) + if FLAGS.storwize_svc_vol_compression: + ssh_cmd_se_opt = ssh_cmd_se_opt + ' -compressed' else: - ssh_cmd_se_opt = ssh_cmd_se_opt + ('-grainsize %(grain)s' % - {'grain': getattr(FLAGS, 'storwize_svc_vol_grainsize')}) + ssh_cmd_se_opt = ssh_cmd_se_opt + (' -grainsize %(grain)s' % + {'grain': FLAGS.storwize_svc_vol_grainsize}) ssh_cmd = ('mkvdisk -name %(name)s -mdiskgrp %(mdiskgrp)s ' - '-iogrp 0 -vtype %(vtype)s -size %(size)s -unit ' - '%(unit)s %(ssh_cmd_se_opt)s' + '-iogrp 0 -size %(size)s -unit ' + '%(unit)s %(easytier)s %(ssh_cmd_se_opt)s' % {'name': name, - 'mdiskgrp': getattr(FLAGS, 'storwize_svc_volpool_name'), - 'vtype': getattr(FLAGS, 'storwize_svc_vol_vtype'), - 'size': size, 'unit': units, + 'mdiskgrp': FLAGS.storwize_svc_volpool_name, + 'size': size, 'unit': units, 'easytier': easytier, 'ssh_cmd_se_opt': ssh_cmd_se_opt}) out, err = self._run_ssh(ssh_cmd) self._driver_assert(len(out.strip()) > 0, @@ -724,8 +709,8 @@ class StorwizeSVCDriver(san.SanISCSIDriver): mapping_ready = False wait_time = 5 # Allow waiting of up to timeout (set as parameter) - max_retries = (int(getattr(FLAGS, - 'storwize_svc_flashcopy_timeout')) / wait_time) + 1 + max_retries = (int(FLAGS.storwize_svc_flashcopy_timeout) + / wait_time) + 1 for try_number in range(1, max_retries): mapping_attributes = self._get_flashcopy_mapping_attributes( fc_map_id) @@ -752,8 +737,7 @@ class StorwizeSVCDriver(san.SanISCSIDriver): exception_msg = (_('mapping %(id)s prepare failed to complete ' 'within the alloted %(to)s seconds timeout. ' 'Terminating') % {'id': fc_map_id, - 'to': getattr( - FLAGS, 'storwize_svc_flashcopy_timeout')}) + 'to': FLAGS.storwize_svc_flashcopy_timeout}) LOG.error(_('_run_flashcopy: fail to start FlashCopy ' 'from %(source)s to %(target)s with ' 'exception %(ex)s')