/ - Diff - snf-ganeti - Greek Research and Technology Network's projects

       # the new block devices  --------------------------
       def perspective_blockdev_create(self, params):
         bdev_s, size, on_primary = params
         bdev_s, size, on_primary, info = params
         bdev = objects.ConfigObject.Loads(bdev_s)
         if bdev is None:
           raise ValueError("can't unserialize data!")
         return backend.CreateBlockDevice(bdev, size, on_primary)
         return backend.CreateBlockDevice(bdev, size, on_primary, info)
       def perspective_blockdev_remove(self, params):
         bdev_s = params[0]
         bdev = objects.ConfigObject.Loads(bdev_s)
         return backend.RemoveBlockDevice(bdev)
       def perspective_blockdev_assemble(self, params):
         bdev_s, on_primary = params
         bdev = objects.ConfigObject.Loads(bdev_s)
-...
           raise ValueError("can't unserialize data!")
         return backend.AssembleBlockDevice(bdev, on_primary)
       def perspective_blockdev_shutdown(self, params):
         bdev_s = params[0]
         bdev = objects.ConfigObject.Loads(bdev_s)
-...
           raise ValueError("can't unserialize data!")
         return backend.ShutdownBlockDevice(bdev)
       def perspective_blockdev_addchild(self, params):
         bdev_s, ndev_s = params
         bdev = objects.ConfigObject.Loads(bdev_s)
-...
           raise ValueError("can't unserialize data!")
         return backend.MirrorAddChild(bdev, ndev)
       def perspective_blockdev_removechild(self, params):
         bdev_s, ndev_s = params
         bdev = objects.ConfigObject.Loads(bdev_s)

       return True
     def CreateBlockDevice(disk, size, on_primary):
     def CreateBlockDevice(disk, size, on_primary, info):
       """Creates a block device for an instance.
       Args:
-...
         device.SetSyncSpeed(constants.SYNC_SPEED)
         if on_primary or disk.OpenOnSecondary():
           device.Open(force=True)
       device.SetInfo(info)
       physical_id = device.unique_id
       return physical_id

         return min_percent, max_time, is_degraded
       def SetInfo(self, text):
         """Update metadata with info text.
         Only supported for some device types.
         """
         for child in self._children:
           child.SetInfo(text)
       def __repr__(self):
         return ("<%s: unique_id: %s, children: %s, %s:%s, %s>" %
                 (self.__class__, self.unique_id, self._children,
-...
         return snap_name
       def SetInfo(self, text):
         """Update metadata with info text.
         """
         BlockDev.SetInfo(self, text)
         # Replace invalid characters
         text = re.sub('^[^A-Za-z0-9_+.]', '_', text)
         text = re.sub('[^-A-Za-z0-9_+.]', '_', text)
         # Only up to 128 characters are allowed
         text = text[:128]
         result = utils.RunCmd(["lvchange", "--addtag", text,
                                self.dev_path])
         if result.failed:
           raise errors.BlockDeviceError, ("Command: %s error: %s" %
                                           (result.cmd, result.fail_reason))
     class MDRaid1(BlockDev):
       """raid1 device implemented via md.

                                    (instance.name, target_node))
     def _CreateBlockDevOnPrimary(cfg, node, device):
     def _CreateBlockDevOnPrimary(cfg, node, device, info):
       """Create a tree of block devices on the primary node.
       This always creates all devices.
-...
       """
       if device.children:
         for child in device.children:
           if not _CreateBlockDevOnPrimary(cfg, node, child):
           if not _CreateBlockDevOnPrimary(cfg, node, child, info):
             return False
       cfg.SetDiskID(device, node)
       new_id = rpc.call_blockdev_create(node, device, device.size, True)
       new_id = rpc.call_blockdev_create(node, device, device.size, True, info)
       if not new_id:
         return False
       if device.physical_id is None:
-...
       return True
     def _CreateBlockDevOnSecondary(cfg, node, device, force):
     def _CreateBlockDevOnSecondary(cfg, node, device, force, info):
       """Create a tree of block devices on a secondary node.
       If this device type has to be created on secondaries, create it and
-...
         force = True
       if device.children:
         for child in device.children:
           if not _CreateBlockDevOnSecondary(cfg, node, child, force):
           if not _CreateBlockDevOnSecondary(cfg, node, child, force, info):
             return False
       if not force:
         return True
       cfg.SetDiskID(device, node)
       new_id = rpc.call_blockdev_create(node, device, device.size, False)
       new_id = rpc.call_blockdev_create(node, device, device.size, False, info)
       if not new_id:
         return False
       if device.physical_id is None:
-...
       return disks
     def _GetInstanceInfoText(instance):
       return "originstname+%s" % instance.name
     def _CreateDisks(cfg, instance):
       """Create all disks for an instance.
-...
         True or False showing the success of the creation process
       """
       info = _GetInstanceInfoText(instance)
       for device in instance.disks:
         logger.Info("creating volume %s for instance %s" %
                   (device.iv_name, instance.name))
         #HARDCODE
         for secondary_node in instance.secondary_nodes:
           if not _CreateBlockDevOnSecondary(cfg, secondary_node, device, False):
           if not _CreateBlockDevOnSecondary(cfg, secondary_node, device, False,
                                             info):
             logger.Error("failed to create volume %s (%s) on secondary node %s!" %
                          (device.iv_name, device, secondary_node))
             return False
         #HARDCODE
         if not _CreateBlockDevOnPrimary(cfg, instance.primary_node, device):
         if not _CreateBlockDevOnPrimary(cfg, instance.primary_node, device, info):
           logger.Error("failed to create volume %s on primary!" %
                        device.iv_name)
           return False
-...
         logger.Info("adding new mirror component on secondary")
         #HARDCODE
         if not _CreateBlockDevOnSecondary(self.cfg, remote_node, new_drbd, False):
         if not _CreateBlockDevOnSecondary(self.cfg, remote_node, new_drbd, False,
                                           _GetInstanceInfoText(instance)):
           raise errors.OpExecError, ("Failed to create new component on secondary"
                                      " node %s" % remote_node)
         logger.Info("adding new mirror component on primary")
         #HARDCODE
         if not _CreateBlockDevOnPrimary(self.cfg, instance.primary_node, new_drbd):
         if not _CreateBlockDevOnPrimary(self.cfg, instance.primary_node, new_drbd,
                                         _GetInstanceInfoText(instance)):
           # remove secondary dev
           self.cfg.SetDiskID(new_drbd, remote_node)
           rpc.call_blockdev_remove(remote_node, new_drbd)
-...
           logger.Info("adding new mirror component on secondary for %s" %
                       dev.iv_name)
           #HARDCODE
           if not _CreateBlockDevOnSecondary(cfg, remote_node, new_drbd, False):
           if not _CreateBlockDevOnSecondary(cfg, remote_node, new_drbd, False,
                                             _GetInstanceInfoText(instance)):
             raise errors.OpExecError, ("Failed to create new component on"
                                        " secondary node %s\n"
                                        "Full abort, cleanup manually!" %
-...
           logger.Info("adding new mirror component on primary")
           #HARDCODE
           if not _CreateBlockDevOnPrimary(cfg, instance.primary_node, new_drbd):
           if not _CreateBlockDevOnPrimary(cfg, instance.primary_node, new_drbd,
                                           _GetInstanceInfoText(instance)):
             # remove secondary dev
             cfg.SetDiskID(new_drbd, remote_node)
             rpc.call_blockdev_remove(remote_node, new_drbd)

       return c.getresult()
     def call_blockdev_create(node, bdev, size, on_primary):
     def call_blockdev_create(node, bdev, size, on_primary, info):
       """Request creation of a given block device.
       This is a single-node call.
       """
       params = [bdev.Dumps(), size, on_primary]
       params = [bdev.Dumps(), size, on_primary, info]
       c = Client("blockdev_create", params)
       c.connect(node)
       c.run()

Synnefo » snf-ganeti

Revision a0c3fea1