def GetSyncStatus(self):
"""Returns the sync status of the device.
If this device is a mirroring device, this function returns the
status of the mirror.
For logical volumes, sync_percent and estimated_time are always
None (no recovery in progress, as we don't handle the mirrored LV
case). The is_degraded parameter is the inverse of the ldisk
parameter.
For the ldisk parameter, we check if the logical volume has the
'virtual' type, which means it's not backed by existing storage
anymore (read from it return I/O error). This happens after a
physical disk failure and subsequent 'vgreduce --removemissing' on
the volume group.
The status was already read in Attach, so we just return it.
@rtype: objects.BlockDevStatus
"""
if self._degraded:
ldisk_status = constants.LDS_FAULTY
else:
ldisk_status = constants.LDS_OKAY
return objects.BlockDevStatus(dev_path=self.dev_path,
major=self.major,
minor=self.minor,
sync_percent=None,
estimated_time=None,
is_degraded=self._degraded,
ldisk_status=ldisk_status)
def GetSyncStatus(self):
"""Returns the sync status of the device.
If this device is a mirroring device, this function returns the
status of the mirror.
If sync_percent is None, it means the device is not syncing.
If estimated_time is None, it means we can't estimate
the time needed, otherwise it's the time left in seconds.
If is_degraded is True, it means the device is missing
redundancy. This is usually a sign that something went wrong in
the device setup, if sync_percent is None.
The ldisk parameter represents the degradation of the local
data. This is only valid for some devices, the rest will always
return False (not degraded).
@rtype: objects.BlockDevStatus
"""
return objects.BlockDevStatus(dev_path=self.dev_path,
major=self.major,
minor=self.minor,
sync_percent=None,
estimated_time=None,
is_degraded=False,
ldisk_status=constants.LDS_OKAY)
def CombinedSyncStatus(self):
"""Calculate the mirror status recursively for our children.
The return value is the same as for `GetSyncStatus()` except the
minimum percent and maximum time are calculated across our
children.
@rtype: objects.BlockDevStatus
"""
status = self.GetSyncStatus()
min_percent = status.sync_percent
max_time = status.estimated_time
is_degraded = status.is_degraded
ldisk_status = status.ldisk_status
if self._children:
for child in self._children:
child_status = child.GetSyncStatus()
if min_percent is None:
min_percent = child_status.sync_percent
elif child_status.sync_percent is not None:
min_percent = min(min_percent, child_status.sync_percent)
if max_time is None:
max_time = child_status.estimated_time
elif child_status.estimated_time is not None:
max_time = max(max_time, child_status.estimated_time)
is_degraded = is_degraded or child_status.is_degraded
if ldisk_status is None:
ldisk_status = child_status.ldisk_status
elif child_status.ldisk_status is not None:
ldisk_status = max(ldisk_status, child_status.ldisk_status)
return objects.BlockDevStatus(dev_path=self.dev_path,
major=self.major,
minor=self.minor,
sync_percent=min_percent,
estimated_time=max_time,
is_degraded=is_degraded,
ldisk_status=ldisk_status)
def setUp(self):
super(TestLUInstanceMigrate, self).setUp()
self.snode = self.cfg.AddNewNode()
hv_info = ("bootid",
[{
"type": constants.ST_LVM_VG,
"storage_free": 10000
}],
({"memory_free": 10000}, ))
self.rpc.call_node_info.return_value = \
self.RpcResultsBuilder() \
.AddSuccessfulNode(self.master, hv_info) \
.AddSuccessfulNode(self.snode, hv_info) \
.Build()
self.rpc.call_blockdev_find.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, objects.BlockDevStatus())
self.rpc.call_migration_info.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
self.rpc.call_accept_instance.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.snode, True)
self.rpc.call_instance_migrate.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
self.rpc.call_instance_get_migration_status.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, objects.MigrationStatus())
self.rpc.call_instance_finalize_migration_dst.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.snode, True)
self.rpc.call_instance_finalize_migration_src.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
self.inst = self.cfg.AddNewInstance(disk_template=constants.DT_DRBD8,
admin_state=constants.ADMINST_UP,
secondary_node=self.snode)
self.op = opcodes.OpInstanceMigrate(instance_name=self.inst.name)
def GetSyncStatus(self):
"""Returns the sync status of the device.
If sync_percent is None, it means all is ok
If estimated_time is None, it means we can't estimate
the time needed, otherwise it's the time left in seconds.
We set the is_degraded parameter to True on two conditions:
network not connected or local disk missing.
We compute the ldisk parameter based on whether we have a local
disk or not.
@rtype: objects.BlockDevStatus
"""
if self.minor is None and not self.Attach():
base.ThrowError("drbd%d: can't Attach() in GetSyncStatus",
self._aminor)
stats = self.GetProcStatus()
is_degraded = not stats.is_connected or not stats.is_disk_uptodate
if stats.is_disk_uptodate:
ldisk_status = constants.LDS_OKAY
elif stats.is_diskless:
ldisk_status = constants.LDS_FAULTY
elif stats.is_in_resync:
ldisk_status = constants.LDS_SYNC
else:
ldisk_status = constants.LDS_UNKNOWN
return objects.BlockDevStatus(dev_path=self.dev_path,
major=self.major,
minor=self.minor,
sync_percent=stats.sync_percent,
estimated_time=stats.est_time,
is_degraded=is_degraded,
ldisk_status=ldisk_status)
def setUp(self):
super(TestLUInstanceFailover, self).setUp()
self.snode = self.cfg.AddNewNode()
hv_info = ("bootid",
[{
"type": constants.ST_LVM_VG,
"storage_free": 10000
}],
({"memory_free": 10000}, ))
self.rpc.call_node_info.return_value = \
self.RpcResultsBuilder() \
.AddSuccessfulNode(self.master, hv_info) \
.AddSuccessfulNode(self.snode, hv_info) \
.Build()
self.rpc.call_blockdev_find.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, objects.BlockDevStatus())
self.rpc.call_instance_shutdown.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
self.rpc.call_blockdev_shutdown.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
self.rpc.call_blockdev_assemble.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.snode,
("/dev/mock", "/var/mock", None))
self.rpc.call_instance_start.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.snode, True)
self.inst = self.cfg.AddNewInstance(disk_template=constants.DT_DRBD8,
admin_state=constants.ADMINST_UP,
secondary_node=self.snode)
self.op = opcodes.OpInstanceFailover(instance_name=self.inst.name)
def _ResetRPC(self):
hv_info = ("bootid",
[{
"type": constants.ST_LVM_VG,
"storage_free": 10000
}],
({"memory_free": 10000}, ))
self.rpc.call_node_info.return_value = \
self.RpcResultsBuilder() \
.AddSuccessfulNode(self.master, hv_info) \
.AddSuccessfulNode(self.snode, hv_info) \
.Build()
self.rpc.call_blockdev_find.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, objects.BlockDevStatus())
self.rpc.call_migration_info.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
self.rpc.call_accept_instance.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.snode, True)
self.rpc.call_instance_migrate.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
self.rpc.call_instance_get_migration_status.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, objects.MigrationStatus())
self.rpc.call_instance_start_postcopy.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
self.rpc.call_instance_finalize_migration_dst.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.snode, True)
self.rpc.call_instance_finalize_migration_src.return_value = \
self.RpcResultsBuilder() \
.CreateSuccessfulNodeResult(self.master, True)
