def test_set_device_specific_load_balancing_policy__complex(self, execute):
raise unittest.SkipTest
from . import ROUND_ROBIN
device, policy = self._get_sample_device_and_policy()
MultipathClaim.set_device_specific_load_balancing_policy(device, policy)
call_args = execute.call_args[0][0]
self.assertEqual(call_args, "-l -d 123 1 0000000077030000 0 0 1 0000000077030001 1 0 0".split())
def test_set_device_specific_load_balancing_policy__simple(self, execute):
raise unittest.SkipTest
from . import ROUND_ROBIN
device, policy = self._get_sample_device_and_policy()
policy.LoadBalancePolicy = ROUND_ROBIN
MultipathClaim.set_device_specific_load_balancing_policy(device, policy)
call_args = execute.call_args[0][0]
self.assertEqual(" ".join(call_args),
"-l -d 123 2")
def test_get_claimed_hardware(self, LocalComputer):
class Mock(object):
class SubMock(object):
@classmethod
def to_python_object(cls):
return [self.HARDWARE_ID]
values_store = dict(MPIOSupportedDeviceList=SubMock())
mock = Mock()
LocalComputer.return_value.local_machine = \
{"SYSTEM\\CurrentControlSet\\Control\\MPDEV":mock}
MultipathClaim.get_claimed_hardware()
def test_get_default_load_balancing_policy(self, execute):
raise unittest.SkipTest
from . import ROUND_ROBIN
output = "\n".join(["", "MSDSM-wide Load Balance Policy: Round Robin", ""])
execute.return_value = output
self.assertEqual(MultipathClaim.get_default_load_balancing_policy(), ROUND_ROBIN)
self.assertEqual(" ".join(execute.call_args[0][0]), "-s -m")
def test_extract_load_balancing(self, policy):
from . import CLEAR_POLICY, ROUND_ROBIN, FAIL_OVER_ONLY, LEAST_BLOCKS, LEAST_QUEUE_DEPTH
if policy:
output = "\n".join(["", "MSDSM-wide Load Balance Policy: %s" % policy , ""])
else:
output = "\n".join(["", "No MSDSM-wide default load balance policy has been set", ""])
self.assertIn(MultipathClaim._extract_load_balancing_from_output(output),
[CLEAR_POLICY, ROUND_ROBIN, FAIL_OVER_ONLY, LEAST_BLOCKS, LEAST_QUEUE_DEPTH])
def test_extract_hardware_specific_load_balancing(self, policy, is_output_empty):
from . import CLEAR_POLICY, ROUND_ROBIN, FAIL_OVER_ONLY, LEAST_BLOCKS, LEAST_QUEUE_DEPTH
if is_output_empty:
output = "\n".join(["", "No target-level default load balance policies have been set.", ""])
else:
if policy is None:
raise unittest.SkipTest
output = "\n".join(["",
""""Target H/W Identifier " LB Policy """,
"""-------------------------------------------------------------------------------""",
""""ABC 123 " %s """ % policy,
""])
if is_output_empty:
self.assertEqual(MultipathClaim._extract_hardware_specific_load_balacing_policy(output, self.HARDWARE_ID),
CLEAR_POLICY)
else:
self.assertIn(MultipathClaim._extract_hardware_specific_load_balacing_policy(output, self.HARDWARE_ID),
[ROUND_ROBIN, FAIL_OVER_ONLY, LEAST_BLOCKS, LEAST_QUEUE_DEPTH])
def test_change_load_balancing_policy(self, new_policy):
raise unittest.SkipTest
from ..wmi import WmiClient, get_multipath_devices, get_load_balace_policies
client = WmiClient()
devices = get_multipath_devices(client)
policies = get_load_balace_policies(client)
key = list(devices.keys())[0]
device, policy = devices[key], policies[key]
policy.LoadBalancePolicy = new_policy
if new_policy == FAIL_OVER_ONLY or new_policy == ROUND_ROBIN_WITH_SUBSET:
for path in [path for path in device.PdoInformation][0:1]:
path.DeviceState = ACTIVE_OPTIMIZED
for path in [path for path in device.PdoInformation][1:]:
path.DeviceState = ACTIVE_NON_OPTIMIZED
if new_policy == WEIGHTED_PATHS:
for path in device.PdoInformation:
path.DeviceState = ACTIVE_OPTIMIZED
for path in policy.DSM_Paths:
path.PathWeight = 1
MultipathClaim.set_device_specific_load_balancing_policy(device, policy)
def test_get_hardware_specific_load_balancing_policy(self, execute):
raise unittest.SkipTest
from . import ROUND_ROBIN
output = "\n".join(["",
""""Target H/W Identifier " LB Policy """,
"""-------------------------------------------------------------------------------""",
""""ABC 123 " RR """,
""])
execute.return_value = output
args = (self.VENDOR_ID, self.PRODUCT_ID)
self.assertEqual(MultipathClaim.get_hardware_specific_load_balancing_poicy(*args), ROUND_ROBIN)
self.assertEqual(" ".join(execute.call_args[0][0]), "-s -t")
def test_real_add_claim_rule(self):
raise unittest.SkipTest
MultipathClaim.claim_specific_hardware("A", "B")
self.assertTrue(MultipathClaim.is_hardware_claimed("A", "B"))
def test_unclaim_specific_hardware(self, is_hardware_claimed, execute):
is_hardware_claimed.return_value = True
MultipathClaim.unclaim_specific_hardware(self.VENDOR_ID, self.PRODUCT_ID)
self.assertEqual(' '.join(execute.call_args[0][0]),
("-n -u -d %s" % self.HARDWARE_ID))
def test_unclaim_all_hardware(self, execute):
MultipathClaim.unclaim_all_hardware()
self.assertEqual(' '.join(execute.call_args[0][0]),
"-n -u -a ")
def test_is_hardware_claimed(self, get_claimed_hardware):
get_claimed_hardware.return_value = [dict(vendor_id="foo", product_id="bar"),
dict(vendor_id="hello", product_id="world"), ]
self.assertTrue(MultipathClaim.is_hardware_claimed("hello", "world"))
self.assertTrue(MultipathClaim.is_hardware_claimed("foo", "bar"))
def test_claim_all__spc3_only(self, execute):
MultipathClaim.claim_discovered_hardware(True)
self.assertEqual(' '.join(execute.call_args[0][0]),
"-n -i %s " % "-c")
def test_claim_all(self, execute):
MultipathClaim.claim_discovered_hardware(False)
self.assertEqual(' '.join(execute.call_args[0][0]),
"-n -i %s " % "-a")
def test_claim_specific_hardware(self, execute, _create_mpdev_key_if_missing):
MultipathClaim.claim_specific_hardware(self.VENDOR_ID, self.PRODUCT_ID)
self.assertEqual(' '.join(execute.call_args[0][0]),
("-n -i -d %s" % self.HARDWARE_ID))
def test_hardware_id(self):
self.assertEqual(MultipathClaim._get_hardware_id("NFINIDAT", "InfiniBox"),
"NFINIDATInfiniBox ")
self.assertEqual(MultipathClaim._get_hardware_id("", ""), " "*24)
def test_set_default_load_balancing_policy(self, execute):
raise unittest.SkipTest
from . import ROUND_ROBIN
MultipathClaim.set_default_load_balancing_policy(ROUND_ROBIN)
self.assertEqual(" ".join(execute.call_args[0][0]), "-l -m %s" % ROUND_ROBIN)
def test_execute__ok(self, execute):
execute.return_value.get_returncode.return_value = 0
execute.return_value.get_stdout.return_value = "ok"
self.assertEqual(MultipathClaim.execute(["something"]), "ok")
def test_set_hardware_specific_load_balancing_policy(self, execute):
raise unittest.SkipTest
from . import ROUND_ROBIN
MultipathClaim.set_hardware_specific_load_balancing_policy(self.VENDOR_ID, self.PRODUCT_ID, ROUND_ROBIN)
self.assertEqual(" ".join(execute.call_args[0][0]), "-l -t %s %s" % (self.HARDWARE_ID, ROUND_ROBIN))
def test_path(self):
from os.path import join, sep
self.assertEqual(MultipathClaim.path(),
join(join("C:", sep, "Windows"), "System32", "mpclaim.exe"))
