Synnefo » snf-ganeti » ganeti-local

    assert self.op.power_delay >= 0.0

    if self.op.node_names:

    else:

      self.op.node_names = self.cfg.GetNodeList()

      if self.op.command in self._SKIP_MASTER:

                                     self.op.timeout)

      if result.fail_msg:

                        node.name, result.fail_msg)

        node_entry.append((constants.RS_NODATA, None))

      else:

        try:

          self._CheckPayload(result)

        except errors.OpExecError, err:

                          node.name, err)

          node_entry.append((constants.RS_NODATA, None))

        else:

            for item, status in result.payload:

              if status in [constants.OOB_STATUS_WARNING,

                            constants.OOB_STATUS_CRITICAL]:

          if self.op.command == constants.OOB_POWER_ON:

            node.powered = True

    masternode = self.cfg.GetMasterNode()

    if node.name == masternode:

    for instance_name in instance_list:

      instance = self.cfg.GetInstanceInfo(instance_name)

      if node.name in instance.all_nodes:

        raise errors.OpPrereqError("Instance %s is still running on the node,"

                                   errors.ECODE_INVAL)

    self.op.node_name = node.name

    self.node = node

    self.old_flags = old_flags = (node.master_candidate,

                                  node.drained, node.offline)

    self.old_role = old_role = self._F2R[old_flags]

    # Check for ineffective changes

    if _SupportsOob(self.cfg, node):

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

                                           self.op.powered == True):

                                   self.op.node_name)

    elif self.op.powered is not None:

      raise errors.OpPrereqError(("Unable to change powered state for node %s"

                                  " handling") % self.op.node_name)

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

    else:

      for idx in self.op.disks:

        if idx >= len(instance.disks):

                                     errors.ECODE_INVAL)

    self.instance = instance

    """

    if self.op.ip_check and not self.op.name_check:

      # TODO: make the ip check more flexible and not depend on the name check

                                 errors.ECODE_INVAL)

  def BuildHooksEnv(self):

    if runningon_source and runningon_target:

      raise errors.OpExecError("Instance seems to be running on two nodes,"

                               " to ensure manually that it runs only on one"

    if not (runningon_source or runningon_target):

                               " running 'gnt-instance stop' to ensure disk"

    if runningon_target:

      # the migration has actually succeeded, we need to update the config

      self._GoReconnect(False)

      self._WaitUntilSync()

    except errors.OpExecError, err:

  def _AbortMigration(self):

    """Call the hypervisor code to abort a started migration.

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

        raise errors.OpExecError("Disk %s is degraded or not fully"

                                 " synchronized on target node,"

    # First get the migration information from the remote node

    result = self.rpc.call_migration_info(source_node, instance)

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

          if not self.ignore_consistency:

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

    else:

      self.feedback_fn("* not checking disk consistency as instance is not"

                       " running")

    msg = result.fail_msg

    if msg:

      if self.ignore_consistency or primary_node.offline:

                           instance.name, source_node, source_node, msg)

      else:

        raise errors.OpExecError("Could not shutdown instance %s on"

    for idx, success in enumerate(result.payload):

      if not success:

        logging.warn("resume-sync of instance %s for disks %d failed",

                     instance.name, idx)

    if self.op.ip_check and not self.op.name_check:

      # TODO: make the ip check more flexible and not depend on the name check

    # check nics' parameter names

    for nic in self.op.nics:

        self.op.src_node = None

        if os.path.isabs(src_path):

          raise errors.OpPrereqError("Importing an instance from an absolute"

                                     errors.ECODE_INVAL)

      else:

        self.op.src_node = src_node = _ExpandNodeName(self.cfg, src_node)

    if self.op.disk_template in constants.DTS_INT_MIRROR:

      if self.op.snode == pnode.name:

        raise errors.OpPrereqError("The secondary node cannot be the"

      _CheckNodeOnline(self, self.op.snode)

      _CheckNodeNotDrained(self, self.op.snode)

      _CheckNodeVmCapable(self, self.op.snode)

    if remote_node == self.instance.primary_node:

      raise errors.OpPrereqError("The specified node is the primary node of"

    if remote_node == secondary_node:

      raise errors.OpPrereqError("The specified node is already the"

                                 errors.ECODE_INVAL)

    if self.disks and self.mode in (constants.REPLACE_DISK_AUTO,

    if instance.disk_template not in constants.DTS_GROWABLE:

      raise errors.OpPrereqError("Instance's disk layout does not support"

    self.disk = instance.FindDisk(self.op.disk)

    if self.op.wait_for_sync:

      disk_abort = not _WaitForSync(self, instance, disks=[disk])

      if disk_abort:

      if not instance.admin_up:

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

    elif not instance.admin_up:

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

                           " not supposed to be running because no wait for"

class LUInstanceQueryData(NoHooksLU):