Synnefo » snf-ganeti

    for _, instance in self.cfg.GetMultiInstanceInfoByName(locked_i):

      wanted_node_uuids.append(instance.primary_node)

      if not primary_only:

    if self.recalculate_locks[level] == constants.LOCKS_REPLACE:

      self.needed_locks[level] = wanted_node_uuids

        # Important: access only the instances whose lock is owned

        instance = self.cfg.GetInstanceInfoByName(inst_name)

        if instance.disk_template in constants.DTS_INT_MIRROR:

      self.needed_locks[locking.LEVEL_NODE] = nodes

                  "instance %s, connection to primary node failed",

                  instance.name)

                  constants.CV_EINSTANCELAYOUT, instance.name,

                  "instance has multiple secondary nodes: %s",

                  code=self.ETYPE_WARNING)

    es_flags = rpc.GetExclusiveStorageForNodes(self.cfg, instance.all_nodes)

                    code=self.ETYPE_WARNING)

    inst_nodes_offline = []

      s_img = node_image[snode]

      self._ErrorIf(s_img.rpc_fail and not s_img.offline, constants.CV_ENODERPC,

                    self.cfg.GetNodeName(snode),

      pnode = instance.primary_node

      node_image[pnode].pinst.append(instance.uuid)

        nimg = node_image[snode]

        nimg.sinst.append(instance.uuid)

        if pnode not in nimg.sbp:

    # is secondary for an instance whose primary is in another group. To avoid

    # them, we find these instances and add their volumes to node_vol_should.

    for instance in self.all_inst_info.values():

        if (secondary in self.my_node_info

            and instance.name not in self.my_inst_info):

          instance.MapLVsByNode(node_vol_should)

      if not inst.disks_active or inst.disk_template != constants.DT_DRBD8:

        continue

      for node_uuid in itertools.chain([inst.primary_node],

        node_to_inst.setdefault(node_uuid, []).append(inst)

    for (node_uuid, insts) in node_to_inst.items():

      mem_check_list = [pnode_uuid]

      if be_new[constants.BE_AUTO_BALANCE]:

        # either we changed auto_balance to yes or it was from before

      instance_info = self.rpc.call_instance_info(

          pnode_uuid, self.instance.name, self.instance.hypervisor,

          cluster_hvparams)

                                       miss_mem, errors.ECODE_NORES)

      if be_new[constants.BE_AUTO_BALANCE]:

        for node_uuid, nres in nodeinfo.items():

            continue

          nres.Raise("Can't get info from secondary node %s" %

                     self.cfg.GetNodeName(node_uuid), prereq=True,

    """Converts an instance from drbd to plain.

    """

    assert self.instance.disk_template == constants.DT_DRBD8

    pnode_uuid = self.instance.primary_node

    feedback_fn("Converting template to plain")

    old_disks = AnnotateDiskParams(self.instance, self.instance.disks, self.cfg)

    else:

      file_driver = file_path = None

    disk = \

      GenerateDiskTemplate(self, self.instance.disk_template,

                           self.instance.uuid, self.instance.primary_node,

                           file_driver, idx, self.Log, self.diskparams)[0]

    new_disks = CreateDisks(self, self.instance, disks=[disk])

      }

    if instance.disk_template in constants.DTS_INT_MIRROR:

      env["NEW_SECONDARY"] = self.cfg.GetNodeName(source_node_uuid)

    else:

      env["OLD_SECONDARY"] = env["NEW_SECONDARY"] = ""

    """

    instance = self._migrater.instance

    nl.append(self._migrater.target_node_uuid)

    return (nl, nl + [instance.primary_node])

      })

    if instance.disk_template in constants.DTS_INT_MIRROR:

      env["NEW_SECONDARY"] = self.cfg.GetNodeName(source_node_uuid)

    else:

      env["OLD_SECONDARY"] = env["NEW_SECONDARY"] = ""

    """

    instance = self._migrater.instance

    nl = [self.cfg.GetMasterNode(), instance.primary_node] + snode_uuids

    nl.append(self._migrater.target_node_uuid)

    return (nl, nl)

    else:

      assert not self.lu.glm.is_owned(locking.LEVEL_NODE_ALLOC)

      if not secondary_node_uuids:

        raise errors.ConfigurationError("No secondary node but using"

                                        " %s disk template" %

    # FIXME: if we implement migrate-to-any in DRBD, this needs fixing

    if self.instance.disk_template in constants.DTS_INT_MIRROR:

      # Otherwise self.target_node has been populated either

      # directly, or through an iallocator.

                                 node_uuid2name_fn),

                  instance.disks)

      snodes_group_uuids = [nodes[snode_uuid].group

      result[instance.name] = {

        "name": instance.name,

        "pnode": pnode.name,

        "pnode_group_uuid": pnode.group,

        "pnode_group_name": group2name_fn(pnode.group),

        "snodes_group_uuids": snodes_group_uuids,

        "snodes_group_names": map(group2name_fn, snodes_group_uuids),

        "os": instance.os,

                                             instance.name, False, idx)

      msg = result.fail_msg

      if msg:

                                result.offline)

        lu.LogWarning("Could not prepare block device %s on node %s"

                      " (is_primary=False, pass=1): %s",

    """

    instance = self.replacer.instance

    env = {

      "MODE": self.op.mode,

      "NEW_SECONDARY": self.op.remote_node,

      }

    env.update(BuildInstanceHookEnvByObject(self, instance))

    return env

      raise errors.OpPrereqError("Can only run replace disks for DRBD8-based"

                                 " instances", errors.ECODE_INVAL)

      raise errors.OpPrereqError("The instance has a strange layout,"

                                 " expected one secondary but found %d" %

                                 errors.ECODE_FAULT)

    if self.iallocator_name is None:

      remote_node_uuid = self.remote_node_uuid

    else:

      remote_node_uuid = self._RunAllocator(self.lu, self.iallocator_name,

                                            self.instance.uuid,

    if remote_node_uuid is None:

      self.remote_node_info = None

                (utils.CommaJoin(self.disks), self.instance.name))

    feedback_fn("Current primary node: %s" %

                self.cfg.GetNodeName(self.instance.primary_node))

    feedback_fn("Current seconary node: %s" %

    activate_disks = not self.instance.disks_active

  cluster = lu.cfg.GetClusterInfo()

  bep = cluster.FillBE(instance)

  hvp = cluster.FillHV(instance)

  args = {

    "name": instance.name,

    "primary_node_name": lu.cfg.GetNodeName(instance.primary_node),

    "os_type": instance.os,

    "status": instance.admin_state,

    "maxmem": bep[constants.BE_MAXMEM],

  """

  return _GetNodeInstancesInner(cfg,

def _GetNodeInstances(cfg, node_uuid):

      (self.inst_uuid, self.op.name) = ExpandInstanceUuidAndName(self.cfg, None,

                                                                 self.op.name)

      self.relocate_from_node_uuids = \

    elif self.op.mode in (constants.IALLOCATOR_MODE_CHG_GROUP,

                          constants.IALLOCATOR_MODE_NODE_EVAC):

      if not self.op.instances:

      if instance.primary_node not in data.nodes:

        result.append("instance '%s' has invalid primary node '%s'" %

                      (instance.name, instance.primary_node))

        if snode not in data.nodes:

          result.append("instance '%s' has invalid secondary node '%s'" %

                        (instance.name, snode))

    for inst in self._config_data.instances.values():

      if inst.primary_node == node_uuid:

        pri.append(inst.uuid)

        sec.append(inst.uuid)

    return (pri, sec)

      raise errors.OpPrereqError("Can't relocate non-mirrored instances",

                                 errors.ECODE_INVAL)

    if (instance.disk_template in constants.DTS_INT_MIRROR and

      raise errors.OpPrereqError("Instance has not exactly one secondary node",

                                 errors.ECODE_STATE)

        "spindle_use": beinfo[constants.BE_SPINDLE_USE],

        "os": iinfo.os,

        "nodes": [cfg.GetNodeName(iinfo.primary_node)] +

        "nics": nic_data,

        "disks": [{constants.IDISK_SIZE: dsk.size,

                   constants.IDISK_MODE: dsk.mode,

  __slots__ = [

    "name",

    "primary_node",

    "os",

    "hypervisor",

    "hvparams",

    "serial_no",

    ] + _TIMESTAMPS + _UUID

  def _ComputeAllNodes(self):

    """Compute the list of all nodes.

    idict = instance.ToDict()

    cluster = self._cfg.GetClusterInfo()

    idict["hvparams"] = cluster.FillHV(instance)

    if hvp is not None:

      idict["hvparams"].update(hvp)

    idict["beparams"] = cluster.FillBE(instance)

        admin_state=constants.ADMINST_UP, hypervisor=constants.HT_XEN_PVM,

        os="linux1",

        primary_node="node1-uuid",

        disk_template=constants.DT_PLAIN,

        disks=[],

        disks_active=True,

        admin_state=constants.ADMINST_UP, hypervisor=constants.HT_XEN_HVM,

        os="deb99",

        primary_node="node5-uuid",

        disk_template=constants.DT_DISKLESS,

        disks=[],

        disks_active=True,

        admin_state=constants.ADMINST_DOWN, hypervisor=constants.HT_KVM,

        os="busybox",

        primary_node="node6-uuid",

        disk_template=constants.DT_DRBD8,

        disks=[],

        disks_active=False,

        admin_state=constants.ADMINST_DOWN, hypervisor=constants.HT_XEN_PVM,

        os="linux1",

        primary_node="nodeoff2-uuid",

        disk_template=constants.DT_DRBD8,

        disks=[],

        disks_active=True,

        admin_state=constants.ADMINST_UP, hypervisor=constants.HT_XEN_HVM,

        os="deb99",

        primary_node="nodebad2-uuid",

        disk_template=constants.DT_DISKLESS,

        disks=[],

        disks_active=True,

        admin_state=constants.ADMINST_DOWN, hypervisor=constants.HT_XEN_HVM,

        os="deb99",

        primary_node="node7-uuid",

        disk_template=constants.DT_DISKLESS,

        disks=[],

        disks_active=False,

        admin_state=constants.ADMINST_DOWN, hypervisor=constants.HT_XEN_HVM,

        os="deb99",

        primary_node="node6-uuid",

        disk_template=constants.DT_DISKLESS,

        disks=[],

        disks_active=False,

        admin_state=constants.ADMINST_OFFLINE, hypervisor=constants.HT_XEN_HVM,

        os="deb99",

        primary_node="node6-uuid",

        disk_template=constants.DT_DISKLESS,

        disks=[],

        disks_active=False,

        admin_state=constants.ADMINST_UP, hypervisor=constants.HT_XEN_HVM,

        os="deb99",

        primary_node="node6-uuid",

        disk_template=constants.DT_DISKLESS,

        disks=[],

        disks_active=False,

  def GetInstanceDiskParams(self, _):

    return constants.DISK_DT_DEFAULTS

class TestRpcRunner(unittest.TestCase):

  def testUploadFile(self):