def test_manually_overruled_dtl(self):
"""
The DTL target of a vDisk can be manually overruled by the customer
"""
# || StorageRouter || vDisk | Regular Domain || Recovery Domain || DTL Target ||
# | sr 1 | 1 | | domain 1 | |
# | sr 2 | | domain 1 | | |
# | sr 3 | | domain 1 | | |
# | sr 4 | | domain 2 | | |
# | sr 5 | | | | |
structure = Helper.build_service_structure(
{'vpools': [1],
'vdisks': [(1, 1, 1, 1)], # (<id>, <storagedriver_id>, <vpool_id>, <mds_service_id>)
'domains': [1, 2],
'mds_services': [(1, 1)], # (<id>, <storagedriver_id>)
'storagerouters': [1, 2, 3, 4, 5],
'storagerouter_domains': [(1, 1, 1, True), (2, 2, 1, False), (3, 3, 1, False), (4, 4, 2, False)], # (<sr_domain_id>, <sr_id>, <domain_id>, <backup>)
'storagedrivers': [(1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4), (5, 1, 5)]} # (<id>, <vpool_id>, <sr_id>)
)
vpool = structure['vpools'][1]
vdisk = structure['vdisks'][1]
domains = structure['domains']
storagerouters = structure['storagerouters']
self._roll_out_dtl_services(vpool=vpool, storagerouters=storagerouters)
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'host', 'value': [sr.storagedrivers[0].storage_ip for sr in storagerouters.values()[1:3]]},
{'key': 'port', 'value': 3},
{'key': 'mode', 'value': DTLMode.ASYNCHRONOUS}])
# Set DTL manually to node 2 and add 2 vdisk domains to the vdisk
vdisk.storagedriver_client.set_manual_dtl_config(volume_id=vdisk.volume_id,
config=DTLConfig(str(storagerouters[2].storagedrivers[0].storage_ip), 3, DTLMode.SYNCHRONOUS))
vdomain1 = VDiskDomain()
vdomain2 = VDiskDomain()
vdomain1.vdisk = vdisk
vdomain2.vdisk = vdisk
vdomain1.domain = domains[1]
vdomain2.domain = domains[2]
vdomain1.save()
vdomain2.save()
vdisk.has_manual_dtl = True
vdisk.save()
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'host', 'value': storagerouters[2].storagedrivers[0].storage_ip},
{'key': 'port', 'value': 3},
{'key': 'mode', 'value': DTLMode.SYNCHRONOUS}])
# Delete the vDiskDomain on which the DTL resides, 1 other vDiskDomain remains
vdomain1.delete()
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'host', 'value': storagerouters[4].storagedrivers[0].storage_ip},
{'key': 'port', 'value': 3},
{'key': 'mode', 'value': DTLMode.SYNCHRONOUS}])
# Delete the last vDiskDomain --> DTL is no longer manual
vdomain2.delete()
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'host', 'value': [sr.storagedrivers[0].storage_ip for sr in storagerouters.values()[1:3]]},
{'key': 'port', 'value': 3},
{'key': 'mode', 'value': DTLMode.ASYNCHRONOUS}])
vdisk.discard()
self.assertFalse(expr=vdisk.has_manual_dtl,
msg='vDisk "vdisk_1" should have manual_dtl flag set to False')
# Overrules the DTL manually to None and validate DTL checkup leaves it as it is
vdisk.storagedriver_client.set_manual_dtl_config(volume_id=vdisk.volume_id, config=None)
vdisk.has_manual_dtl = True
vdisk.save()
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'config', 'value': None}])
def test_manually_overruled_dtl(self):
"""
The DTL target of a vDisk can be manually overruled by the customer
"""
# || StorageRouter || vDisk | Regular Domain || Recovery Domain || DTL Target ||
# | sr 1 | 1 | | domain 1 | |
# | sr 2 | | domain 1 | | |
# | sr 3 | | domain 1 | | |
# | sr 4 | | domain 2 | | |
# | sr 5 | | | | |
structure = DalHelper.build_dal_structure(
{'vpools': [1],
'vdisks': [(1, 1, 1, 1)], # (<id>, <storagedriver_id>, <vpool_id>, <mds_service_id>)
'domains': [1, 2],
'mds_services': [(1, 1)], # (<id>, <storagedriver_id>)
'storagerouters': [1, 2, 3, 4, 5],
'storagerouter_domains': [(1, 1, 1, True), (2, 2, 1, False), (3, 3, 1, False), (4, 4, 2, False)], # (<sr_domain_id>, <sr_id>, <domain_id>, <backup>)
'storagedrivers': [(1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4), (5, 1, 5)]} # (<id>, <vpool_id>, <sr_id>)
)
vpool = structure['vpools'][1]
vdisk = structure['vdisks'][1]
domains = structure['domains']
storagerouters = structure['storagerouters']
self._roll_out_dtl_services(vpool=vpool, storagerouters=storagerouters)
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'host', 'value': [sr.storagedrivers[0].storage_ip for sr in storagerouters.values()[1:3]]},
{'key': 'port', 'value': 3},
{'key': 'mode', 'value': DTLMode.ASYNCHRONOUS}])
# Set DTL manually to node 2 and add 2 vdisk domains to the vdisk
vdisk.storagedriver_client.set_manual_dtl_config(volume_id=vdisk.volume_id,
config=DTLConfig(str(storagerouters[2].storagedrivers[0].storage_ip), 3, DTLMode.SYNCHRONOUS))
vdomain1 = VDiskDomain()
vdomain2 = VDiskDomain()
vdomain1.vdisk = vdisk
vdomain2.vdisk = vdisk
vdomain1.domain = domains[1]
vdomain2.domain = domains[2]
vdomain1.save()
vdomain2.save()
vdisk.has_manual_dtl = True
vdisk.save()
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'host', 'value': storagerouters[2].storagedrivers[0].storage_ip},
{'key': 'port', 'value': 3},
{'key': 'mode', 'value': DTLMode.SYNCHRONOUS}])
# Delete the vDiskDomain on which the DTL resides, 1 other vDiskDomain remains, no changes should be made, but OVS_WARNING should be logged
vdomain1.delete()
LogHandler._logs = {}
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'host', 'value': storagerouters[2].storagedrivers[0].storage_ip},
{'key': 'port', 'value': 3},
{'key': 'mode', 'value': DTLMode.SYNCHRONOUS}])
warning_logs = []
for log in LogHandler._logs['lib_vdisk']:
if 'OVS_WARNING' in log and 'manual DTL configuration is no longer' in log and vdisk.guid in log:
warning_logs.append(log)
self.assertEqual(first=1, second=len(warning_logs))
# Delete the last vDiskDomain --> DTL should not be changed
vdomain2.delete()
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'host', 'value': storagerouters[2].storagedrivers[0].storage_ip},
{'key': 'port', 'value': 3},
{'key': 'mode', 'value': DTLMode.SYNCHRONOUS}])
vdisk.discard()
self.assertTrue(expr=vdisk.has_manual_dtl)
# Overrules the DTL manually to None and validate DTL checkup leaves it as it is
vdisk.storagedriver_client.set_manual_dtl_config(volume_id=vdisk.volume_id, config=None)
vdisk.has_manual_dtl = True
vdisk.save()
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{'key': 'config', 'value': None}])
def test_manually_overruled_dtl(self):
"""
The DTL target of a vDisk can be manually overruled by the customer
"""
# || StorageRouter || vDisk | Regular Domain || Recovery Domain || DTL Target ||
# | sr 1 | 1 | | domain 1 | |
# | sr 2 | | domain 1 | | |
# | sr 3 | | domain 1 | | |
# | sr 4 | | domain 2 | | |
# | sr 5 | | | | |
structure = Helper.build_service_structure({
'vpools': [1],
'vdisks': [
(1, 1, 1, 1)
], # (<id>, <storagedriver_id>, <vpool_id>, <mds_service_id>)
'domains': [1, 2],
'mds_services': [(1, 1)], # (<id>, <storagedriver_id>)
'storagerouters': [1, 2, 3, 4, 5],
'storagerouter_domains': [
(1, 1, 1, True), (2, 2, 1, False), (3, 3, 1, False),
(4, 4, 2, False)
], # (<sr_domain_id>, <sr_id>, <domain_id>, <backup>)
'storagedrivers': [(1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4),
(5, 1, 5)]
} # (<id>, <vpool_id>, <sr_id>)
)
vpool = structure['vpools'][1]
vdisk = structure['vdisks'][1]
domains = structure['domains']
storagerouters = structure['storagerouters']
self._roll_out_dtl_services(vpool=vpool, storagerouters=storagerouters)
self._run_and_validate_dtl_checkup(
vdisk=vdisk,
validations=[{
'key':
'host',
'value': [
sr.storagedrivers[0].storage_ip
for sr in storagerouters.values()[1:3]
]
}, {
'key': 'port',
'value': 3
}, {
'key': 'mode',
'value': DTLMode.ASYNCHRONOUS
}])
# Set DTL manually to node 2 and add 2 vdisk domains to the vdisk
vdisk.storagedriver_client.set_manual_dtl_config(
volume_id=vdisk.volume_id,
config=DTLConfig(
str(storagerouters[2].storagedrivers[0].storage_ip), 3,
DTLMode.SYNCHRONOUS))
vdomain1 = VDiskDomain()
vdomain2 = VDiskDomain()
vdomain1.vdisk = vdisk
vdomain2.vdisk = vdisk
vdomain1.domain = domains[1]
vdomain2.domain = domains[2]
vdomain1.save()
vdomain2.save()
vdisk.has_manual_dtl = True
vdisk.save()
self._run_and_validate_dtl_checkup(
vdisk=vdisk,
validations=[{
'key':
'host',
'value':
storagerouters[2].storagedrivers[0].storage_ip
}, {
'key': 'port',
'value': 3
}, {
'key': 'mode',
'value': DTLMode.SYNCHRONOUS
}])
# Delete the vDiskDomain on which the DTL resides, 1 other vDiskDomain remains
vdomain1.delete()
self._run_and_validate_dtl_checkup(
vdisk=vdisk,
validations=[{
'key':
'host',
'value':
storagerouters[4].storagedrivers[0].storage_ip
}, {
'key': 'port',
'value': 3
}, {
'key': 'mode',
'value': DTLMode.SYNCHRONOUS
}])
# Delete the last vDiskDomain --> DTL is no longer manual
vdomain2.delete()
self._run_and_validate_dtl_checkup(
vdisk=vdisk,
validations=[{
'key':
'host',
'value': [
sr.storagedrivers[0].storage_ip
for sr in storagerouters.values()[1:3]
]
}, {
'key': 'port',
'value': 3
}, {
'key': 'mode',
'value': DTLMode.ASYNCHRONOUS
}])
vdisk.discard()
self.assertFalse(
expr=vdisk.has_manual_dtl,
msg='vDisk "vdisk_1" should have manual_dtl flag set to False')
# Overrules the DTL manually to None and validate DTL checkup leaves it as it is
vdisk.storagedriver_client.set_manual_dtl_config(
volume_id=vdisk.volume_id, config=None)
vdisk.has_manual_dtl = True
vdisk.save()
self._run_and_validate_dtl_checkup(vdisk=vdisk,
validations=[{
'key': 'config',
'value': None
}])
