Synnefo » snf-ganeti

  cluster, indexed by instance name; the contents are similar to the

  instance definitions for the allocate mode, with the addition of:

    if this instance is set to run (but not the actual status of the

    instance)

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,

      raise errors.ConfigurationError("Unknown instance '%s'" %

                                      instance_name)

    instance = self._config_data.instances[instance_name]

      instance.serial_no += 1

      instance.mtime = time.time()

      self._WriteConfig()

  INSTST_ERRORDOWN,

  ])

# Node roles

NR_REGULAR = "R"

NR_MASTER = "M"

    "hvparams",

    "beparams",

    "osparams",

    "nics",

    "disks",

    "disk_template",

    """Custom function for instances.

    """

    obj = super(Instance, cls).FromDict(val)

    obj.nics = cls._ContainerFromDicts(obj.nics, list, NIC)

    obj.disks = cls._ContainerFromDicts(obj.disks, list, Disk)

  if bool(ctx.live_data.get(inst.name)):

    if inst.name in ctx.wrongnode_inst:

      return constants.INSTST_WRONGNODE

      return constants.INSTST_RUNNING

    else:

      return constants.INSTST_ERRORUP

    return constants.INSTST_ERRORDOWN

  return constants.INSTST_ADMINDOWN

    (_MakeField("admin_state", "Autostart", QFT_BOOL,

                "Desired state of instance (if set, the instance should be"

                " up)"),

    (_MakeField("tags", "Tags", QFT_OTHER, "Tags"), IQ_CONFIG, 0,

     lambda ctx, inst: list(inst.GetTags())),

    (_MakeField("console", "Console", QFT_OTHER,

      objects.Instance(name="inst1", hvparams={}, beparams={}, nics=[],

        uuid="f90eccb3-e227-4e3c-bf2a-94a21ca8f9cd",

        ctime=1291244000, mtime=1291244400, serial_no=30,

        primary_node="node1",

        disk_template=constants.DT_PLAIN,

        disks=[],

      objects.Instance(name="inst2", hvparams={}, nics=[],

        uuid="73a0f8a7-068c-4630-ada2-c3440015ab1a",

        ctime=1291211000, mtime=1291211077, serial_no=1,

        primary_node="node5",

        disk_template=constants.DT_DISKLESS,

        disks=[],

      objects.Instance(name="inst3", hvparams={}, beparams={},

        uuid="11ec8dff-fb61-4850-bfe0-baa1803ff280",

        ctime=1291011000, mtime=1291013000, serial_no=1923,

        primary_node="node6",

        disk_template=constants.DT_DRBD8,

        disks=[],

      objects.Instance(name="inst4", hvparams={}, beparams={},

        uuid="68dab168-3ef5-4c9d-b4d3-801e0672068c",

        ctime=1291244390, mtime=1291244395, serial_no=25,

        primary_node="nodeoff2",

        disk_template=constants.DT_DRBD8,

        disks=[],

      objects.Instance(name="inst5", hvparams={}, nics=[],

        uuid="0e3dca12-5b42-4e24-98a2-415267545bd0",

        ctime=1231211000, mtime=1261200000, serial_no=3,

        primary_node="nodebad2",

        disk_template=constants.DT_DISKLESS,

        disks=[],

      objects.Instance(name="inst6", hvparams={}, nics=[],

        uuid="72de6580-c8d5-4661-b902-38b5785bb8b3",

        ctime=7513, mtime=11501, serial_no=13390,

        primary_node="node7",

        disk_template=constants.DT_DISKLESS,

        disks=[],

      objects.Instance(name="inst7", hvparams={}, nics=[],

        uuid="ceec5dc4-b729-4f42-ae28-69b3cd24920e",

        ctime=None, mtime=None, serial_no=1947,

        primary_node="node6",

        disk_template=constants.DT_DISKLESS,

        disks=[],

      elif inst.name in live_data:

        if inst.name in wrongnode_inst:

          exp_status = constants.INSTST_WRONGNODE

          exp_status = constants.INSTST_RUNNING

        else:

          exp_status = constants.INSTST_ERRORUP

        exp_status = constants.INSTST_ERRORDOWN

      else:

        exp_status = constants.INSTST_ADMINDOWN