Synnefo » snf-ganeti

import ganeti.masterd.instance # pylint: disable=W0611

# States of instance

INSTANCE_DOWN = [constants.ADMINST_DOWN]

INSTANCE_ONLINE = [constants.ADMINST_DOWN, constants.ADMINST_UP]

def _AssembleInstanceDisks(lu, instance, disks=None, ignore_secondaries=False,

  """Prepare the block devices for an instance.

  This sets up the block devices on all nodes.

  device_info = []

  disks_ok = True

  iname = instance.name

  # With the two passes mechanism we try to reduce the window of

  # opportunity for the race condition of switching DRBD to primary

  return results

def _GenerateDRBD8Branch(lu, primary, secondary, size, vgnames, names,

                         iv_name, p_minor, s_minor):

  """Generate a drbd8 device complete with its children.

                          size=constants.DRBD_META_SIZE,

                          logical_id=(vgnames[1], names[1]),

                          params={})

  drbd_dev = objects.Disk(dev_type=constants.LD_DRBD8, size=size,

                          logical_id=(primary, secondary, port,

                                      p_minor, s_minor,

                                      shared_secret),

                          children=[dev_data, dev_meta],

                          iv_name=iv_name, params={})

  return drbd_dev

      size = disk[constants.IDISK_SIZE]

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

                  (disk_index, utils.FormatUnit(size, "h")))

  return disks

                                       node_whitelist=node_whitelist)

  """Computes the nics.

  @param op: The instance opcode

  @param cluster: Cluster configuration object

  @param default_ip: The default ip to assign

    check_params = cluster.SimpleFillNIC(nicparams)

    objects.NIC.CheckParameterSyntax(check_params)

  return nics

    if self.op.identify_defaults:

      self._RevertToDefaults(cluster)

    # NIC buildup

                             self.proc.GetECId())

    # disk checks/pre-build

                            hvparams=self.op.hvparams,

                            hypervisor=self.op.hypervisor,

                            osparams=self.op.osparams,

                            )

    if self.op.tags:

      node_whitelist = None

    insts = [_CreateInstanceAllocRequest(op, _ComputeDisks(op, default_vg),

                                                      self.cfg, ec_id),

                                         _ComputeFullBeParams(op, cluster),

                                         node_whitelist)

        if remove_fn is not None:

          remove_fn(absidx, item, private)

        changes = [("%s/%s" % (kind, absidx), "remove")]

        assert container[absidx] == item

        del container[absidx]

      elif op == constants.DDM_MODIFY:

        if modify_fn is not None:

          changes = modify_fn(absidx, item, params, private)

      else:

        raise errors.ProgrammerError("Unhandled operation '%s'" % op)

                                 " (%d), cannot add more" % constants.MAX_NICS,

                                 errors.ECODE_STATE)

    # Verify disk changes (operating on a copy)

    disks = instance.disks[:]

    if len(disks) > constants.MAX_DISKS:

      raise errors.OpPrereqError("Instance has too many disks (%d), cannot add"

                                 " more" % constants.MAX_DISKS,

      # Operate on copies as this is still in prereq

      nics = [nic.Copy() for nic in instance.nics]

      ApplyContainerMods("NIC", nics, self._nic_chgdesc, self.nicmod,

      self._new_nics = nics

      ispec[constants.ISPEC_NIC_COUNT] = len(self._new_nics)

    else:

                utils.CommaJoin(set(res_max + res_min))))

        raise errors.OpPrereqError(msg, errors.ECODE_INVAL)

  def _ConvertPlainToDrbd(self, feedback_fn):

    """Converts an instance from plain to drbd.

        self.LogWarning("Failed to create volume %s (%s) on node '%s': %s",

                        disk.iv_name, disk, node, err)

    return (disk, [

      ("disk/%d" % idx, "add:size=%s,mode=%s" % (disk.size, disk.mode)),

      ])

    """Removes a disk.

    """

    (anno_disk,) = _AnnotateDiskParams(self.instance, [root], self.cfg)

    for node, disk in anno_disk.ComputeNodeTree(self.instance.primary_node):

      self.cfg.SetDiskID(disk, node)

    if root.dev_type in constants.LDS_DRBD:

      self.cfg.AddTcpUdpPort(root.logical_id[2])

    """Creates data structure for a new network interface.

    """

    mac = params[constants.INIC_MAC]

    ip = params.get(constants.INIC_IP, None)

    net = params.get(constants.INIC_NETWORK, None)

    nicparams = private.filled

      ("nic.%d" % idx,

       "add:mac=%s,ip=%s,mode=%s,link=%s,network=%s" %

       (mac, ip, private.filled[constants.NIC_MODE],

    """Modifies a network interface.

    """

      for (key, val) in nic.nicparams.items():

        changes.append(("nic.%s/%d" % (key, idx), val))

    return changes

  def Exec(self, feedback_fn):

    """Modifies an instance.