Synnefo » snf-ganeti » ganeti-local

  bep = cluster.FillBE(instance)

  hvp = cluster.FillHV(instance)

  args = {

  }

  if override:

    args.update(override)

          self._ErrorIf(test, self.ENODEHOOKS, node_name,

                        "Script %s failed, output:", script)

          if test:

            feedback_fn("%s" % output)

            lu_result = 0

          if field == "node":

            val = node

          elif field == "phys":

          elif field == "vg":

          elif field == "name":

          elif field == "size":

          elif field == "instance":

            val = vol2inst.get((node, vol["vg"] + "/" + vol["name"]), "-")

          else:

  nodeinfo = lu.rpc.call_node_info([node], None, hypervisor_name)

  nodeinfo[node].Raise("Can't get data from node %s" % node,

                       prereq=True, ecode=errors.ECODE_ENVIRON)

  if not isinstance(free_mem, int):

    raise errors.OpPrereqError("Can't compute free memory on node %s, result"

                               " was '%s'" % (node, free_mem),

      disk_images = []

      for idx in range(export_disks):

        if export_info.has_option(constants.INISECT_INS, option):

          # FIXME: are the old os-es, disk sizes, etc. useful?

          export_name = export_info.get(constants.INISECT_INS, option)

      self.src_images = disk_images

      try:

      except (TypeError, ValueError), err:

        raise errors.OpPrereqError("Invalid export file, nic_count is not"

                                   " an integer: %s" % str(err),

      if self.op.instance_name == old_name:

        for idx, nic in enumerate(self.nics):

          if nic.mac == constants.VALUE_AUTO and exp_nic_count >= idx:

            nic.mac = export_info.get(constants.INISECT_INS, nic_mac_ini)

    # ENDIF: self.op.mode == constants.INSTANCE_IMPORT

            raise errors.OpPrereqError("Invalid IP address '%s'" % nic_ip,

                                       errors.ECODE_INVAL)

      nic_link = nic_dict.get(constants.INIC_LINK, None)

      if nic_bridge and nic_link:

        raise errors.OpPrereqError("Cannot pass 'bridge' and 'link'"

                                   " at the same time", errors.ECODE_INVAL)

      elif nic_bridge and nic_bridge.lower() == constants.VALUE_NONE:

      elif nic_link and nic_link.lower() == constants.VALUE_NONE:

        nic_dict[constants.INIC_LINK] = None

    """

    args = dict()

    if constants.BE_MEMORY in self.be_new:

    if constants.BE_VCPUS in self.be_new:

    # TODO: export disk changes. Note: _BuildInstanceHookEnv* don't export disk

    # information at all.

    if self.op.nics:

      nic_override = dict(self.op.nics)

      for idx, nic in enumerate(self.instance.nics):

        if idx in nic_override:

          nicparams = self.cluster.SimpleFillNIC(nic.nicparams)

        mode = nicparams[constants.NIC_MODE]

        link = nicparams[constants.NIC_LINK]

      if constants.DDM_ADD in nic_override:

        ip = nic_override[constants.DDM_ADD].get(constants.INIC_IP, None)

        mac = nic_override[constants.DDM_ADD][constants.INIC_MAC]

        nicparams = self.nic_pnew[constants.DDM_ADD]

        mode = nicparams[constants.NIC_MODE]

        link = nicparams[constants.NIC_LINK]

      elif constants.DDM_REMOVE in nic_override:

    env = _BuildInstanceHookEnvByObject(self, self.instance, override=args)

    if self.op.disk_template:

        # Assume the primary node is unreachable and go ahead

        self.warn.append("Can't get info from primary node %s: %s" %

                         (pnode,  msg))

        self.warn.append("Node data from primary node %s doesn't contain"

                         " free memory information" % pnode)

      elif instance_info.fail_msg:

                        instance_info.fail_msg)

      else:

        if instance_info.payload:

        else:

          # Assume instance not running

          # (there is a slight race condition here, but it's not very probable,

          # and we have no other way to check)

          current_mem = 0

        miss_mem = (be_new[constants.BE_MEMORY] - current_mem -

        if miss_mem > 0:

          raise errors.OpPrereqError("This change will prevent the instance"

                                     " from starting, due to %d MB of memory"

            continue

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

                     prereq=True, ecode=errors.ECODE_STATE)

            raise errors.OpPrereqError("Secondary node %s didn't return free"

                                       " memory information" % node,

                                       errors.ECODE_STATE)

            raise errors.OpPrereqError("This change will prevent the instance"

                                       " from failover to its secondary node"

                                       " %s, due to not enough memory" % node,

                                 for key in constants.NICS_PARAMETERS

                                 if key in nic_dict])

      new_nic_params = _GetUpdatedParams(old_nic_params,

                                         update_params_dict)

        else:

          nic_ip = old_nic_ip

        if nic_ip is None:

      if constants.INIC_MAC in nic_dict:

        nic_mac = nic_dict[constants.INIC_MAC]

        if nic_mac is None:

                                     errors.ECODE_INVAL)

        elif nic_mac in (constants.VALUE_AUTO, constants.VALUE_GENERATE):

          # otherwise generate the mac

                                nname)

        remote_info = nresult.payload

          if attr not in remote_info:

            raise errors.OpExecError("Node '%s' didn't return attribute"

                                     " '%s'" % (nname, attr))

            if iinfo.name not in node_iinfo[nname].payload:

              i_used_mem = 0

            else:

            i_mem_diff = beinfo[constants.BE_MEMORY] - i_used_mem

            if iinfo.admin_up:

              i_p_up_mem += beinfo[constants.BE_MEMORY]

        # compute memory used by instances

        pnr_dyn = {

          "i_pri_memory": i_p_mem,

          "i_pri_up_memory": i_p_up_mem,

          }