return (True, "Migration successfull")
-def CreateBlockDevice(disk, size, owner, on_primary, info):
+def BlockdevCreate(disk, size, owner, on_primary, info):
"""Creates a block device for an instance.
@type disk: L{objects.Disk}
clist = []
if disk.children:
for child in disk.children:
- crdev = _RecursiveAssembleBD(child, owner, on_primary)
+ try:
+ crdev = _RecursiveAssembleBD(child, owner, on_primary)
+ except errors.BlockDeviceError, err:
+ errmsg = "Can't assemble device %s: %s" % (child, err)
+ logging.error(errmsg)
+ return False, errmsg
if on_primary or disk.AssembleOnSecondary():
# we need the children open in case the device itself has to
# be assembled
- crdev.Open()
+ try:
+ crdev.Open()
+ except errors.BlockDeviceError, err:
+ errmsg = "Can't make child '%s' read-write: %s" % (child, err)
+ logging.error(errmsg)
+ return False, errmsg
clist.append(crdev)
try:
device = bdev.Create(disk.dev_type, disk.physical_id, clist, size)
- except errors.GenericError, err:
+ except errors.BlockDeviceError, err:
return False, "Can't create block device: %s" % str(err)
if on_primary or disk.AssembleOnSecondary():
- if not device.Assemble():
- errorstring = "Can't assemble device after creation, very unusual event"
- logging.error(errorstring)
- return False, errorstring
+ try:
+ device.Assemble()
+ except errors.BlockDeviceError, err:
+ errmsg = ("Can't assemble device after creation, very"
+ " unusual event: %s" % str(err))
+ logging.error(errmsg)
+ return False, errmsg
device.SetSyncSpeed(constants.SYNC_SPEED)
if on_primary or disk.OpenOnSecondary():
- device.Open(force=True)
+ try:
+ device.Open(force=True)
+ except errors.BlockDeviceError, err:
+ errmsg = ("Can't make device r/w after creation, very"
+ " unusual event: %s" % str(err))
+ logging.error(errmsg)
+ return False, errmsg
DevCacheManager.UpdateCache(device.dev_path, owner,
on_primary, disk.iv_name)
return True, physical_id
-def RemoveBlockDevice(disk):
+def BlockdevRemove(disk):
"""Remove a block device.
@note: This is intended to be called recursively.
@return: the success of the operation
"""
+ msgs = []
+ result = True
try:
rdev = _RecursiveFindBD(disk)
except errors.BlockDeviceError, err:
rdev = None
if rdev is not None:
r_path = rdev.dev_path
- result = rdev.Remove()
+ try:
+ rdev.Remove()
+ except errors.BlockDeviceError, err:
+ msgs.append(str(err))
+ result = False
if result:
DevCacheManager.RemoveCache(r_path)
- else:
- result = True
+
if disk.children:
for child in disk.children:
- result = result and RemoveBlockDevice(child)
- return result
+ c_status, c_msg = BlockdevRemove(child)
+ result = result and c_status
+ if c_msg: # not an empty message
+ msgs.append(c_msg)
+
+ return (result, "; ".join(msgs))
def _RecursiveAssembleBD(disk, owner, as_primary):
if children.count(None) >= mcn:
raise
cdev = None
- logging.debug("Error in child activation: %s", str(err))
+ logging.error("Error in child activation (but continuing): %s",
+ str(err))
children.append(cdev)
if as_primary or disk.AssembleOnSecondary():
return result
-def AssembleBlockDevice(disk, owner, as_primary):
+def BlockdevAssemble(disk, owner, as_primary):
"""Activate a block device for an instance.
This is a wrapper over _RecursiveAssembleBD.
C{True} for secondary nodes
"""
- result = _RecursiveAssembleBD(disk, owner, as_primary)
- if isinstance(result, bdev.BlockDev):
- result = result.dev_path
- return result
+ status = True
+ result = "no error information"
+ try:
+ result = _RecursiveAssembleBD(disk, owner, as_primary)
+ if isinstance(result, bdev.BlockDev):
+ result = result.dev_path
+ except errors.BlockDeviceError, err:
+ result = "Error while assembling disk: %s" % str(err)
+ status = False
+ return (status, result)
-def ShutdownBlockDevice(disk):
+def BlockdevShutdown(disk):
"""Shut down a block device.
First, if the device is assembled (Attach() is successfull), then
@return: the success of the operation
"""
+ msgs = []
+ result = True
r_dev = _RecursiveFindBD(disk)
if r_dev is not None:
r_path = r_dev.dev_path
- result = r_dev.Shutdown()
- if result:
+ try:
+ r_dev.Shutdown()
DevCacheManager.RemoveCache(r_path)
- else:
- result = True
+ except errors.BlockDeviceError, err:
+ msgs.append(str(err))
+ result = False
+
if disk.children:
for child in disk.children:
- result = result and ShutdownBlockDevice(child)
- return result
+ c_status, c_msg = BlockdevShutdown(child)
+ result = result and c_status
+ if c_msg: # not an empty message
+ msgs.append(c_msg)
+
+ return (result, "; ".join(msgs))
-def MirrorAddChildren(parent_cdev, new_cdevs):
+def BlockdevAddchildren(parent_cdev, new_cdevs):
"""Extend a mirrored block device.
@type parent_cdev: L{objects.Disk}
return True
-def MirrorRemoveChildren(parent_cdev, new_cdevs):
+def BlockdevRemovechildren(parent_cdev, new_cdevs):
"""Shrink a mirrored block device.
@type parent_cdev: L{objects.Disk}
return True
-def GetMirrorStatus(disks):
+def BlockdevGetmirrorstatus(disks):
"""Get the mirroring status of a list of devices.
@type disks: list of L{objects.Disk}
return bdev.FindDevice(disk.dev_type, disk.physical_id, children)
-def CallBlockdevFind(disk):
+def BlockdevFind(disk):
"""Check if a device is activated.
If it is, return informations about the real device.
return result
-def GrowBlockDevice(disk, amount):
+def BlockdevGrow(disk, amount):
"""Grow a stack of block devices.
This function is called recursively, with the childrens being the
return True, None
-def SnapshotBlockDevice(disk):
+def BlockdevSnapshot(disk):
"""Create a snapshot copy of a block device.
This function is called recursively, and the snapshot is actually created
if disk.children:
if len(disk.children) == 1:
# only one child, let's recurse on it
- return SnapshotBlockDevice(disk.children[0])
+ return BlockdevSnapshot(disk.children[0])
else:
# more than one child, choose one that matches
for child in disk.children:
if child.size == disk.size:
# return implies breaking the loop
- return SnapshotBlockDevice(child)
+ return BlockdevSnapshot(child)
elif disk.dev_type == constants.LD_LV:
r_dev = _RecursiveFindBD(disk)
if r_dev is not None:
return True
-def RenameBlockDevices(devlist):
+def BlockdevRename(devlist):
"""Rename a list of block devices.
@type devlist: list of tuples
return True
-def CloseBlockDevices(instance_name, disks):
+def BlockdevClose(instance_name, disks):
"""Closes the given block devices.
This means they will be switched to secondary mode (in case of
projects / ganeti-local / blobdiff