Synnefo » snf-ganeti » ganeti-local

def _CheckInstanceDown(lu, instance, reason):

  """Ensure that an instance is not running."""

    raise errors.OpPrereqError("Instance %s is marked to be up, %s" %

                               (instance.name, reason), errors.ECODE_STATE)

    "primary_node": instance.primary_node,

    "secondary_nodes": instance.secondary_nodes,

    "os_type": instance.os,

    "memory": bep[constants.BE_MEMORY],

    "vcpus": bep[constants.BE_VCPUS],

    "nics": _NICListToTuple(lu, instance.nics),

        _ErrorIf(test, constants.CV_EINSTANCEMISSINGDISK, instance,

                 "volume %s missing on node %s", volume, node)

      pri_img = node_image[node_current]

      test = instance not in pri_img.instances and not pri_img.offline

      _ErrorIf(test, constants.CV_EINSTANCEDOWN, instance,

      # node here

      snode = node_image[nname]

      bad_snode = snode.ghost or snode.offline

               constants.CV_EINSTANCEFAULTYDISK, instance,

               "couldn't retrieve status for disk/%s on %s: %s",

               idx, nname, bdev_status)

                bdev_status.ldisk_status == constants.LDS_FAULTY),

               constants.CV_EINSTANCEFAULTYDISK, instance,

               "disk/%s on %s is faulty", idx, nname)

        node_drbd[minor] = (instance, False)

      else:

        instance = instanceinfo[instance]

    # and now check them

    used_minors = nresult.get(constants.NV_DRBDLIST, [])

               constants.CV_ENODERPC, pnode, "instance %s, connection to"

               " primary node failed", instance)

               constants.CV_EINSTANCEBADNODE, instance,

               "instance is marked as running and lives on offline node %s",

               inst_config.primary_node)

    nv_dict = _MapInstanceDisksToNodes([inst

                                        for inst in self.instances.values()

    if nv_dict:

      nodes = utils.NiceSort(set(self.owned_locks(locking.LEVEL_NODE)) &

    _CheckNodeNotDrained(self, target_node)

    _CheckNodeVmCapable(self, target_node)

      # check memory requirements on the secondary node

      _CheckNodeFreeMemory(self, target_node, "failing over instance %s" %

                           instance.name, bep[constants.BE_MEMORY],

    _RemoveDisks(self, instance, target_node=source_node)

    # Only start the instance if it's marked as up

      self.LogInfo("Starting instance %s on node %s",

                   instance.name, target_node)

    assert instance is not None

    self.instance = instance

        self.fallback):

      self.lu.LogInfo("Instance is marked down, fallback allowed, switching"

                      " to failover")

    i_be = self.cfg.GetClusterInfo().FillBE(instance)

    # check memory requirements on the secondary node

      _CheckNodeFreeMemory(self.lu, target_node, "migrating instance %s" %

                           instance.name, i_be[constants.BE_MEMORY],

                           instance.hypervisor)

    source_node = instance.primary_node

    target_node = self.target_node

      self.feedback_fn("* checking disk consistency between source and target")

      for dev in instance.disks:

        # for drbd, these are drbd over lvm

    self.cfg.Update(instance, self.feedback_fn)

    # Only start the instance if it's marked as up

      self.feedback_fn("* activating the instance's disks on target node %s" %

                       target_node)

      logging.info("Starting instance %s on node %s",

                            primary_node=pnode_name,

                            nics=self.nics, disks=disks,

                            disk_template=self.op.disk_template,

                            network_port=network_port,

                            beparams=self.op.beparams,

                            hvparams=self.op.hvparams,

    assert not self.owned_locks(locking.LEVEL_NODE_RES)

    if self.op.start:

      self.cfg.Update(iobj, feedback_fn)

      logging.info("Starting instance %s on node %s", instance, pnode_name)

      feedback_fn("* starting instance...")

    node_insts.Raise("Can't get node information from %s" % node)

    if instance.name not in node_insts.payload:

        state = constants.INSTST_ERRORDOWN

      else:

        state = constants.INSTST_ADMINDOWN

    feedback_fn("Replacing disk(s) %s for %s" %

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

    # Activate the instance disks if we're replacing them on a down instance

    if activate_disks:

    """

    # Check whether any instance on this node has faulty disks

    for inst in _GetNodeInstances(self.cfg, self.op.node_name):

        continue

      check_nodes = set(inst.all_nodes)

      check_nodes.discard(self.op.node_name)

      if disk_abort:

        self.proc.LogWarning("Disk sync-ing has not returned a good"

                             " status; please check the instance")

        _SafeShutdownInstanceDisks(self, instance, disks=[disk])

      self.proc.LogWarning("Not shutting down the disk even if the instance is"

                           " not supposed to be running because no wait for"

                           " sync mode was requested")

        else:

          remote_state = "down"

        config_state = "up"

      else:

        config_state = "down"

          "Cannot retrieve locked instance %s" % self.op.instance_name

    _CheckNodeOnline(self, self.instance.primary_node)

        not self.op.shutdown):

      raise errors.OpPrereqError("Can not remove instance without shutting it"

                                 " down before")

    for disk in instance.disks:

      self.cfg.SetDiskID(disk, src_node)

    if activate_disks:

      # Activate the instance disks if we'exporting a stopped instance

      helper.CreateSnapshots()

      try:

            not self.op.remove_instance):

          assert not activate_disks

          feedback_fn("Starting instance %s" % instance.name)

            i_mem_diff = beinfo[constants.BE_MEMORY] - i_used_mem

            remote_info["memory_free"] -= max(0, i_mem_diff)

              i_p_up_mem += beinfo[constants.BE_MEMORY]

        # compute memory used by instances

        nic_data.append(nic_dict)

      pir = {

        "tags": list(iinfo.GetTags()),

        "vcpus": beinfo[constants.BE_VCPUS],

        "memory": beinfo[constants.BE_MEMORY],

        "os": iinfo.os,