Synnefo » snf-ganeti

      raise ValueError("Invalid configuration data %s" % str(unique_id))

    self.driver, self.vol_name = unique_id

    self.major = self.minor = None

    self.Attach()

    # Call the External Storage's create script,

    # to provision a new Volume inside the External Storage

    return ExtStorageDevice(unique_id, children, size, params)

    # Call the External Storage's remove script,

    # to remove the Volume from the External Storage

  def Rename(self, new_id):

    """Rename this device.

    # Call the External Storage's attach script,

    # to attach an existing Volume to a block device under /dev

    self.dev_path = _ExtStorageAction(constants.ES_ACTION_ATTACH,

    try:

      st = os.stat(self.dev_path)

    # Call the External Storage's detach script,

    # to detach an existing Volume from it's block device under /dev

    self.minor = None

    self.dev_path = None

    # Call the External Storage's grow script,

    # to grow an existing Volume inside the External Storage

    _ExtStorageAction(constants.ES_ACTION_GROW, self.unique_id,

  def SetInfo(self, text):

    """Update metadata with info text.

    # Call the External Storage's setinfo script,

    # to set metadata for an existing Volume inside the External Storage

    _ExtStorageAction(constants.ES_ACTION_SETINFO, self.unique_id,

  """Take an External Storage action.

  Take an External Storage action concerning or affecting

  @type unique_id: tuple (driver, vol_name)

  @param unique_id: a tuple containing the type of ExtStorage (driver)

                    and the Volume name

  @type size: integer

  @param size: the size of the Volume in mebibytes

  @type grow: integer

    _ThrowError("%s" % inst_es)

  # Create the basic environment for the driver's scripts

  # Do not use log file for action `attach' as we need

  # to get the output from RunResult

  # an optional one

  es_files = dict.fromkeys(constants.ES_SCRIPTS, True)

    es_files[filename] = utils.PathJoin(es_dir, filename)

    try:

        return False, ("File '%s' under path '%s' is not executable" %

                       (filename, es_dir))

  es_obj = \

    objects.ExtStorage(name=name, path=es_dir,

                       create_script=es_files[constants.ES_SCRIPT_CREATE],

                       grow_script=es_files[constants.ES_SCRIPT_GROW],

                       attach_script=es_files[constants.ES_SCRIPT_ATTACH],

                       detach_script=es_files[constants.ES_SCRIPT_DETACH],

  return True, es_obj

  """Calculate the environment for an External Storage script.

  @type unique_id: tuple (driver, vol_name)

  @param unique_id: ExtStorage pool and name of the Volume

  @type size: string

  @param size: size of the Volume (in mebibytes)

  @type grow: string

  result = {}

  result["VOL_NAME"] = vol_name

  if size is not None:

    result["VOL_SIZE"] = size

    # TODO: Implement support changing VG while recreating

    constants.IDISK_VG,

    constants.IDISK_METAVG,

    ]))

  def _RunAllocator(self):

    elif template_name == constants.DT_RBD:

      logical_id_fn = lambda idx, _, disk: ("rbd", names[idx])

    elif template_name == constants.DT_EXT:

    else:

      raise errors.ProgrammerError("Unknown disk template '%s'" % template_name)

    dev_type = _DISK_TEMPLATE_DEVICE_TYPE[template_name]

    for idx, disk in enumerate(disk_info):

      disk_index = idx + base_index

      size = disk[constants.IDISK_SIZE]

      feedback_fn("* disk %s, size %s" %

                                logical_id=logical_id_fn(idx, disk_index, disk),

                                iv_name="disk/%d" % disk_index,

                                mode=disk[constants.IDISK_MODE],

  return disks

  @param op: The instance opcode

  @param default_vg: The default_vg to assume

  """

  disks = []

      raise errors.OpPrereqError("Invalid disk size '%s'" % size,

                                 errors.ECODE_INVAL)

    data_vg = disk.get(constants.IDISK_VG, default_vg)

    new_disk = {

      constants.IDISK_SIZE: size,

      constants.IDISK_MODE: mode,

      constants.IDISK_VG: data_vg,

      }

    if constants.IDISK_METAVG in disk:

      new_disk[constants.IDISK_METAVG] = disk[constants.IDISK_METAVG]

    if constants.IDISK_ADOPT in disk:

      new_disk[constants.IDISK_ADOPT] = disk[constants.IDISK_ADOPT]

    disks.append(new_disk)

  return disks

    # check disks. parameter names and consistent adopt/no-adopt strategy

    has_adopt = has_no_adopt = False

    for disk in self.op.disks:

      if constants.IDISK_ADOPT in disk:

        has_adopt = True

      else:

    _CheckNicsBridgesExist(self, self.nics, self.pnode.name)

    # memory check on primary node

    #TODO(dynmem): use MINMEM for checking

    if self.op.start:

ES_ACTION_ATTACH = "attach"

ES_ACTION_DETACH = "detach"

ES_ACTION_SETINFO = "setinfo"

ES_SCRIPT_CREATE = ES_ACTION_CREATE

ES_SCRIPT_REMOVE = ES_ACTION_REMOVE

ES_SCRIPT_ATTACH = ES_ACTION_ATTACH

ES_SCRIPT_DETACH = ES_ACTION_DETACH

ES_SCRIPT_SETINFO = ES_ACTION_SETINFO

ES_SCRIPTS = frozenset([

  ES_SCRIPT_CREATE,

  ES_SCRIPT_REMOVE,

  ES_SCRIPT_GROW,

  ES_SCRIPT_ATTACH,

  ES_SCRIPT_DETACH,

  ])

# ssh constants

SSH = "ssh"

SCP = "scp"

IDISK_ADOPT = "adopt"

IDISK_VG = "vg"

IDISK_METAVG = "metavg"

IDISK_PARAMS_TYPES = {

  IDISK_SIZE: VTYPE_SIZE,

  IDISK_MODE: VTYPE_STRING,

  IDISK_ADOPT: VTYPE_STRING,

  IDISK_VG: VTYPE_STRING,

  IDISK_METAVG: VTYPE_STRING,

  }

IDISK_PARAMS = frozenset(IDISK_PARAMS_TYPES.keys())

        constants.LDP_POOL: dt_params[constants.RBD_POOL],

        }))

    return result

    "attach_script",

    "detach_script",

    "setinfo_script",

    ]