Synnefo » snf-ganeti » ganeti-local

                     disk_sizes, spindle_use)

  """Compute if instance specs meets the specs of ipolicy.

  @type ipolicy: dict

      # Always depend on global verification

      depends_fn = lambda: [(-len(jobs), [])]

    # Fix up all parameters

    for op in itertools.chain(*jobs): # pylint: disable=W0142

    if drbd_helper:

      helper_result = nresult.get(constants.NV_DRBDHELPER, None)

      _ErrorIf(test, constants.CV_ENODEDRBDHELPER, node,

               "no drbd usermode helper returned")

      if helper_result:

    res_instances = set()

    res_missing = {}

    if nv_dict:

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

    files_mc.add(constants.CLUSTER_CONF_FILE)

  # Files which should only be on VM-capable nodes

    for hv_name in cluster.enabled_hypervisors

    for filename in hypervisor.GetHypervisor(hv_name).GetAncillaryFiles()[0])

    for hv_name in cluster.enabled_hypervisors

    for filename in hypervisor.GetHypervisor(hv_name).GetAncillaryFiles()[1])

                    type(result.payload))

    if self.op.command in [

      if result.payload is not None:

        errs.append("%s is expected to not return payload but got '%s'" %

                    (self.op.command, result.payload))

    if not newbie_singlehomed:

      # check reachability from my secondary ip to newbie's secondary ip

      if not netutils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,

        raise errors.OpPrereqError("Node secondary ip not reachable by TCP"

                                   " based ping to node daemon port",

                                   errors.ECODE_ENVIRON)

                                 errors.ECODE_INVAL)

    # Boolean value that tells us whether we might be demoting from MC

    if self.op.secondary_ip:

      if not netutils.IP4Address.IsValid(self.op.secondary_ip):

                                 " it a master candidate" % node.name,

                                 errors.ECODE_STATE)

      (ipri, isec) = self.cfg.GetNodeInstances(self.op.node_name)

      if ipri or isec:

        raise errors.OpPrereqError("Node %s hosts instances, cannot unset"

    # Check for ineffective changes

    for attr in self._FLAGS:

        self.LogInfo("Ignoring request to unset flag %s, already unset", attr)

        setattr(self.op, attr, None)

    # TODO: We might query the real power state if it supports OOB

    if _SupportsOob(self.cfg, node):

      if self.op.offline is False and not (node.powered or

        raise errors.OpPrereqError(("Node %s needs to be turned on before its"

                                    " offline status can be reset") %

                                   self.op.node_name, errors.ECODE_STATE)

                                 errors.ECODE_STATE)

    # If we're being deofflined/drained, we'll MC ourself if needed

        (self.op.master_capable and not node.master_capable)):

      if _DecideSelfPromotion(self):

        self.op.master_candidate = True

        self.LogInfo("Auto-promoting node to master candidate")

    # If we're no longer master capable, we'll demote ourselves from MC

      self.LogInfo("Demoting from master candidate")

      self.op.master_candidate = False

                                  ial.required_nodes), errors.ECODE_FAULT)

    self.target_node = ial.result[0]

    self.lu.LogInfo("Selected nodes for instance %s via iallocator %s: %s",

  def _WaitUntilSync(self):

    """Poll with custom rpc for disk sync.

      # Don't raise an exception here, as we stil have to try to revert the

      # disk status, even if this step failed.

    abort_msg = abort_result.fail_msg

    if abort_msg:

      logging.error("Aborting migration failed on source node %s: %s",

  }

  """Generate the entire disk layout for a given template type.

  """

    enabled_hvs = cluster.enabled_hypervisors

    if self.op.hypervisor not in enabled_hvs:

      raise errors.OpPrereqError("Selected hypervisor (%s) not enabled in the"

                                 errors.ECODE_STATE)

    # Check tag validity

        assert not self.needed_locks[locking.LEVEL_NODE]

        # Lock member nodes of all locked groups

      else:

        self._LockInstancesNodes()

    elif level == locking.LEVEL_NODE_RES:

    if self.op.hvparams:

      _CheckGlobalHvParams(self.op.hvparams)

    # Check disk modifications

    self._CheckMods("disk", self.op.disks, constants.IDISK_PARAMS_TYPES,

                           " free memory information" % pnode)

        elif instance_info.fail_msg:

          self.warn.append("Can't get instance runtime information: %s" %

        else:

          if instance_info.payload:

            current_mem = int(instance_info.payload["memory"])

            self.op.runtime_mem < self.be_proposed[constants.BE_MINMEM])):

        raise errors.OpPrereqError("Instance %s must have memory between %d"

                                   " and %d MB of memory unless --force is"

                                    self.be_proposed[constants.BE_MINMEM],

                                    self.be_proposed[constants.BE_MAXMEM]),

                                   errors.ECODE_INVAL)

                       ht.TItems([ht.TNonEmptyString,

                                  ht.TNonEmptyString,

                                  ht.TListOf(ht.TNonEmptyString),

  _NEVAC_FAILED = \

    ht.TListOf(ht.TAnd(ht.TIsLength(2),

                       ht.TItems([ht.TNonEmptyString,

                                  ht.TMaybeString,

  _NEVAC_RESULT = ht.TAnd(ht.TIsLength(3),

                          ht.TItems([_NEVAC_MOVED, _NEVAC_FAILED, _JOB_LIST]))