Synnefo » snf-ganeti

  @param secondary_nodes: list of secondary nodes as strings

  @type os_type: string

  @param os_type: the name of the instance's OS

  @type memory: string

  @param memory: the memory size of the instance

  @type vcpus: string

  @return: the hook environment for this instance

  """

  env = {

    "OP_TARGET": name,

    "INSTANCE_NAME": name,

    "INSTANCE_PRIMARY": primary_node,

    "INSTANCE_SECONDARIES": " ".join(secondary_nodes),

    "INSTANCE_OS_TYPE": os_type,

    "INSTANCE_MEMORY": memory,

    "INSTANCE_VCPUS": vcpus,

  }

    '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': [(nic.ip, nic.bridge, nic.mac) for nic in instance.nics],

                          (volume, node))

          bad = True

      if ((node_current not in node_instance or

          not instance in node_instance[node_current]) and

          node_current not in n_offline):

      node_drbd = {}

      for minor, instance in all_drbd_map[node].items():

        instance = instanceinfo[instance]

      result = self._VerifyNode(node_i, file_names, local_checksums,

                                nresult, feedback_fn, master_files,

                                node_drbd)

    nv_dict = {}

    for inst in instances:

      inst_lvs = {}

          inst.disk_template not in constants.DTS_NET_MIRROR):

        continue

      inst.MapLVsByNode(inst_lvs)

    if instance.disk_template == constants.DT_DISKLESS:

      raise errors.OpPrereqError("Instance '%s' has no disks" %

                                 self.op.instance_name)

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

                                 self.op.instance_name)

    remote_info = self.rpc.call_instance_info(instance.primary_node,

                                 self.op.instance_name)

    _CheckNodeOnline(self, instance.primary_node)

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

                                 self.op.instance_name)

    remote_info = self.rpc.call_instance_info(instance.primary_node,

        elif field == "snodes":

          val = list(instance.secondary_nodes)

        elif field == "admin_state":

        elif field == "oper_state":

          if instance.primary_node in bad_nodes:

            val = None

          else:

            running = bool(live_data.get(instance.name))

            if running:

                val = "running"

              else:

                val = "ERROR_up"

            else:

                val = "ERROR_down"

              else:

                val = "ADMIN_down"

    for dev in instance.disks:

      # for drbd, these are drbd over lvm

      if not _CheckDiskConsistency(self, dev, target_node, False):

          raise errors.OpExecError("Disk %s is degraded on target node,"

                                   " aborting failover." % dev.iv_name)

    self.cfg.Update(instance)

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

      feedback_fn("* activating the instance's disks on target node")

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

                   instance.name, target_node)

                           self.be_full[constants.BE_MEMORY],

                           self.op.hypervisor)

  def Exec(self, feedback_fn):

    """Create and add the instance to the cluster.

                            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,

    instance = self.instance

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

      _StartInstanceDisks(self, instance, True)

    if self.op.mode == constants.REPLACE_DISK_CHG:

    ret = fn(feedback_fn)

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

      _SafeShutdownInstanceDisks(self, instance)

    return ret

          remote_state = "down"

      else:

        remote_state = None

        config_state = "up"

      disks = [self._ComputeDiskStatus(instance, None, device)

               for device in instance.disks]

          snap_disks.append(new_dev)

    finally:

        result = self.rpc.call_instance_start(src_node, instance, None)

        msg = result.RemoteFailMsg()

        if msg:

          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

                  for n in iinfo.nics]

      pir = {

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

        "vcpus": beinfo[constants.BE_VCPUS],

        "memory": beinfo[constants.BE_MEMORY],

        "os": iinfo.os,

    """Set the instance's status to a given value.

    """

    if instance_name not in self._config_data.instances:

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

                                      instance_name)

    instance = self._config_data.instances[instance_name]

      instance.serial_no += 1

      self._WriteConfig()

    """Mark the instance status to up in the config.

    """

  @locking.ssynchronized(_config_lock)

  def RemoveInstance(self, instance_name):

    """Mark the status of an instance to down in the configuration.

    """

  def _UnlockedGetInstanceList(self):

    """Get the list of instances.

    "hypervisor",

    "hvparams",

    "beparams",

    "nics",

    "disks",

    "disk_template",