Synnefo » snf-ganeti

                              logical_id=logical_id_fn(idx, disk_index, disk),

                              iv_name="disk/%d" % disk_index,

                              mode=disk[constants.IDISK_MODE],

      disk_dev.name = disk.get(constants.IDISK_NAME, None)

      disk_dev.uuid = lu.cfg.GenerateUniqueID(lu.proc.GetECId())

      disks.append(disk_dev)

        disk.logical_id = new_id

      if changes:

        disk.Update(size=changes.get(constants.IDISK_SIZE, None),

    # change primary node, if needed

    if self.op.nodes:

class Disk(ConfigObject):

  """Config object representing a block device."""

  def CreateOnSecondary(self):

    """Test if this device needs to be created on a secondary node."""

      raise errors.ProgrammerError("Disk.RecordGrow called for unsupported"

                                   " disk type %s" % self.dev_type)

    """

    if self.dev_type == constants.LD_DRBD8:

      self.size = size

    if mode is not None:

      self.mode = mode

  def UnsetSize(self):

    """Sets recursively the size to zero for the disk and its children.

      val += ", not visible"

    else:

      val += ", visible as /dev/%s" % self.iv_name

    if isinstance(self.size, int):

      val += ", size=%dm)>" % self.size

    else:

  , diskSize       :: Int

  , diskMode       :: DiskMode

  , diskName       :: Maybe String

  , diskUuid       :: String

  } deriving (Show, Eq)

  , simpleField "size" [t| Int |]

  , defaultField [| DiskRdWr |] $ simpleField "mode" [t| DiskMode |]

  , optionalField $ simpleField "name" [t| String |]

  ]

  ++ uuidFields)

instance Arbitrary Disk where

  arbitrary = Disk <$> arbitrary <*> pure [] <*> arbitrary

                   <*> arbitrary <*> arbitrary <*> arbitrary

-- FIXME: we should generate proper values, >=0, etc., but this is

-- hard for partial ones, where all must be wrapped in a 'Maybe'

  size <- arbitrary

  mode <- arbitrary

  name <- genMaybe genName

  uuid <- genName

  return disk

genDisk :: Gen Disk