Synnefo » snf-ganeti » ganeti-local

from ganeti.cmdlib.common import CheckParamsNotGlobal, \

  MergeAndVerifyHvState, MergeAndVerifyDiskState, \

  IsExclusiveStorageEnabledNode, CheckNodePVs, \

  CheckInstanceState, INSTANCE_DOWN, GetUpdatedParams, \

  AdjustCandidatePool, CheckIAllocatorOrNode, LoadNodeEvacResult, \

  GetWantedNodes, MapInstanceDisksToNodes, RunPostHook, \

  @type lu: L{LogicalUnit}

  @param lu: the LU on behalf of which we make the check

  @param node: the node to check

  @type secondary_ip: string

  @param secondary_ip: the ip to check

  @type prereq: boolean

  @param prereq: whether to throw a prerequisite or an execute error

  @raise errors.OpExecError: if the node doesn't have the ip, and prereq=False

  """

               prereq=prereq, ecode=errors.ECODE_ENVIRON)

  if not result.payload:

    msg = ("Node claims it doesn't have the secondary ip you gave (%s),"

                                         family=self.primary_ip_family)

    self.op.node_name = self.hostname.name

      raise errors.OpPrereqError("Cannot readd the master node",

                                 errors.ECODE_STATE)

    """Build hooks nodes.

    """

  def CheckPrereq(self):

    """Check prerequisites.

    """

    cfg = self.cfg

    hostname = self.hostname

    primary_ip = self.op.primary_ip = hostname.ip

    if self.op.secondary_ip is None:

      if self.primary_ip_family == netutils.IP6Address.family:

      raise errors.OpPrereqError("Secondary IP (%s) needs to be a valid IPv4"

                                 " address" % secondary_ip, errors.ECODE_INVAL)

      raise errors.OpPrereqError("Node %s is already in the configuration" %

    self.changed_primary_ip = False

        if existing_node.secondary_ip != secondary_ip:

          raise errors.OpPrereqError("Readded node doesn't have the same IP"

                                     " address configuration as before",

    # After this 'if' block, None is no longer a valid value for the

    # _capable op attributes

    if self.op.readd:

      for attr in self._NFLAGS:

        if getattr(self.op, attr) is None:

    else:

      for attr in self._NFLAGS:

        if getattr(self.op, attr) is None:

          setattr(self.op, attr, True)

    if self.op.readd and not self.op.vm_capable:

      if pri or sec:

        raise errors.OpPrereqError("Node %s being re-added with vm_capable"

                                   " flag set to false, but it already holds"

                                   errors.ECODE_STATE)

    # check that the type of the node (single versus dual homed) is the

                                   errors.ECODE_ENVIRON)

    if self.op.readd:

    else:

      exceptions = []

      self.master_candidate = False

    if self.op.readd:

    else:

      node_group = cfg.LookupNodeGroup(self.op.group)

                                   primary_ip=primary_ip,

                                   secondary_ip=secondary_ip,

                                   master_candidate=self.master_candidate,

    # TODO: If we need to have multiple DnsOnlyRunner we probably should make

    #       it a property on the base class.

    rpcrunner = rpc.DnsOnlyRunner()

    if constants.PROTOCOL_VERSION == result.payload:

      logging.info("Communication to node %s fine, sw version %s match",

    else:

      raise errors.OpPrereqError("Version mismatch master version %s,"

                                 " node version %s" %

      excl_stor = IsExclusiveStorageEnabledNode(cfg, self.new_node)

      cname = self.cfg.GetClusterName()

      result = rpcrunner.call_node_verify_light(

      (errmsgs, _) = CheckNodePVs(result.payload, excl_stor)

      if errmsgs:

        raise errors.OpPrereqError("Checks on node PVs failed: %s" %

    """

    new_node = self.new_node

    assert locking.BGL in self.owned_locks(locking.LEVEL_CLUSTER), \

      "Not owning BGL"

    # Add node to our /etc/hosts, and add key to known_hosts

    if self.cfg.GetClusterInfo().modify_etc_hosts:

      master_node = self.cfg.GetMasterNode()

      result.Raise("Can't update hosts file with new host data")

    if new_node.secondary_ip != new_node.primary_ip:

    node_verify_param = {

      # TODO: do a node-net-test as well?

    }

      result[verifier].Raise("Cannot communicate with node %s" % verifier)

      nl_payload = result[verifier].payload[constants.NV_NODELIST]

      if nl_payload:

        raise errors.OpExecError("ssh/hostname verification failed")

    if self.op.readd:

      self.context.ReaddNode(new_node)

      # make sure we redistribute the config

      self.cfg.Update(new_node, feedback_fn)

      # and make sure the new node will not have old files around

      if not new_node.master_candidate:

        result.Warn("Node failed to demote itself from master candidate status",

                    self.LogWarning)

    else:

      self.context.AddNode(new_node, self.proc.GetECId())

class LUNodeSetParams(LogicalUnit):

  _FLAGS = ["master_candidate", "drained", "offline"]

  def CheckArguments(self):

    all_mods = [self.op.offline, self.op.master_candidate, self.op.drained,

                self.op.master_capable, self.op.vm_capable,

                self.op.secondary_ip, self.op.ndparams, self.op.hv_state,

    """

    return (instance.disk_template in constants.DTS_INT_MIRROR and

  def ExpandNames(self):

    if self.lock_all:

        }

    else:

      self.needed_locks = {

        }

    # Since modifying a node can have severe effects on currently running

    """Build hooks nodes.

    """

    return (nl, nl)

  def CheckPrereq(self):

    This only checks the instance list against the existing names.

    """

    if self.lock_instances:

      affected_instances = \

        self.cfg.GetInstancesInfoByFilter(self._InstanceFilter)

                                   " secondary IP address have changed since"

                                   " locks were acquired, wanted '%s', have"

                                   " '%s'; retry the operation" %

                                    utils.CommaJoin(wanted_instances),

                                    utils.CommaJoin(owned_instances)),

                                   errors.ECODE_STATE)

        self.op.drained is not None or

        self.op.offline is not None):

      # we can't change the master's node flags

        raise errors.OpPrereqError("The master role can be changed"

                                   " only via master-failover",

                                   errors.ECODE_INVAL)

                                 errors.ECODE_STATE)

    if self.op.vm_capable is False:

      if ipri or isec:

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

                                   " the vm_capable flag" % node.name,

      # check if after removing the current node, we're missing master

      # candidates

      (mc_remaining, mc_should, _) = \

      if mc_remaining < mc_should:

        raise errors.OpPrereqError("Not enough master candidates, please"

                                   " pass auto promote option to allow"

    # 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)

    if old_role == self._ROLE_OFFLINE and new_role != old_role:

      # Trying to transition out of offline status

      if result.fail_msg:

        raise errors.OpPrereqError("Node %s is being de-offlined but fails"

                                   " to report its version: %s" %

      master = self.cfg.GetNodeInfo(self.cfg.GetMasterNode())

      master_singlehomed = master.secondary_ip == master.primary_ip

      if master_singlehomed and self.op.secondary_ip != node.primary_ip:

          self.LogWarning("Transitioning from single-homed to multi-homed"

                          " cluster; all nodes will require a secondary IP"

                          " address")

                                     " target node to be the master",

                                     errors.ECODE_INVAL)

      elif not master_singlehomed and self.op.secondary_ip == node.primary_ip:

          self.LogWarning("Transitioning from multi-homed to single-homed"

                          " cluster; secondary IP addresses will have to be"

                          " removed")

          CheckInstanceState(self, instance, INSTANCE_DOWN,

                             msg="cannot change secondary ip")

          # check reachability from master secondary ip to new secondary ip

          if not netutils.TcpPing(self.op.secondary_ip,

                                  constants.DEFAULT_NODED_PORT,

                                       errors.ECODE_ENVIRON)

    if self.op.ndparams:

      utils.ForceDictType(new_ndparams, constants.NDS_PARAMETER_TYPES)

      CheckParamsNotGlobal(self.op.ndparams, constants.NDC_GLOBALS, "node",

                           "node", "cluster or group")

    if self.op.hv_state:

      self.new_hv_state = MergeAndVerifyHvState(self.op.hv_state,

    if self.op.disk_state:

      self.new_disk_state = \

  def Exec(self, feedback_fn):

    """Modifies a node.

    """

    old_role = self.old_role

    new_role = self.new_role

      # we locked all nodes, we adjust the CP before updating this node

      if self.lock_all:

    if self.op.secondary_ip:

      node.secondary_ip = self.op.secondary_ip

  REQ_BGL = False

  def CheckArguments(self):

      raise errors.OpPrereqError("The node is the master and the force"

                                 " parameter was not set",

                                 errors.ECODE_INVAL)

    """

    default_hypervisor = self.cfg.GetHypervisorType()

    hvparams = self.cfg.GetClusterInfo().hvparams[default_hypervisor]

                                           default_hypervisor,

                                           hvparams)

    result.Raise("Failed to schedule the reboot")

  return [i for i in cfg.GetAllInstancesInfo().values() if fn(i)]

  """Returns primary instances on a node.

  """

  return _GetNodeInstancesInner(cfg,

  """Returns secondary instances on a node.

  """

  return _GetNodeInstancesInner(cfg,

  """Returns a list of all primary and secondary instances on a node.

  """

class LUNodeEvacuate(NoHooksLU):

    CheckIAllocatorOrNode(self, "iallocator", "remote_node")

  def ExpandNames(self):

    if self.op.remote_node is not None:

      assert self.op.remote_node

        raise errors.OpPrereqError("Can not use evacuated node as a new"

                                   " secondary node", errors.ECODE_INVAL)

    self.lock_nodes = self._DetermineNodes()

  def _DetermineNodes(self):

    """

    if self.op.remote_node is None:

      # Iallocator will choose any node(s) in the same group

    else:

    # Determine nodes to be locked

  def _DetermineInstances(self):

    """Builds list of instances to operate on.

                                 " instances",

                                 errors.ECODE_INVAL)

  def DeclareLocks(self, level):

    if level == locking.LEVEL_INSTANCE:

    if self.op.remote_node is not None:

      for i in self.instances:

          raise errors.OpPrereqError("Node %s is the primary node of"

                                     " instance %s, cannot use it as"

                                     " secondary" %

    pass

  def ExpandNames(self):

    self.share_locks = ShareAll()

    self.needed_locks = {

      }

  def BuildHooksEnv(self):

                                 target_node=self.op.target_node,

                                 allow_runtime_changes=allow_runtime_changes,

                                 ignore_ipolicy=self.op.ignore_ipolicy)]

    # TODO: Run iallocator in this opcode and pass correct placement options to

    # OpInstanceMigrate. Since other jobs can modify the cluster between

  REQ_BGL = False

  def CheckArguments(self):

    storage_type = self.op.storage_type

  def ExpandNames(self):

    self.needed_locks = {

      }

  def Exec(self, feedback_fn):

    """

    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)

                                          self.op.storage_type, st_args,

                                          self.op.name, self.op.changes)

    result.Raise("Failed to modify storage unit '%s' on %s" %

    lu.share_locks = ShareAll()

    if self.names:

    else:

      self.wanted = locking.ALL_SET

    """

    all_info = lu.cfg.GetAllNodesInfo()

    # Gather data as requested

    if query.NQ_LIVE in self.requested_data:

      # filter out non-vm_capable nodes

      # FIXME: This currently maps everything to lvm, this should be more

      # flexible

      vg_req = rpc.BuildVgInfoQuery(lu.cfg)

      default_hypervisor = lu.cfg.GetHypervisorType()

      hvparams = lu.cfg.GetClusterInfo().hvparams[default_hypervisor]

      hvspecs = [(default_hypervisor, hvparams)]

                                        hvspecs, es_flags)

                       if not nresult.fail_msg and nresult.payload)

    else:

      live_data = None

    if query.NQ_INST in self.requested_data:

      inst_data = lu.cfg.GetAllInstancesInfo()

      node_to_secondary = None

    if query.NQ_OOB in self.requested_data:

    else:

      oob_support = None

    else:

      groups = {}

                               live_data, lu.cfg.GetMasterNode(),

                               node_to_primary, node_to_secondary, groups,

                               oob_support, lu.cfg.GetClusterInfo())

    if self.op.nodes:

      self.needed_locks = {

        }

    else:

      self.needed_locks = {

    """Computes the list of nodes and their attributes.

    """

    ilist = self.cfg.GetAllInstancesInfo()

    vol2inst = MapInstanceDisksToNodes(ilist.values())

    output = []

      if nresult.offline:

        continue

      msg = nresult.fail_msg

      if msg:

        continue

      node_vols = sorted(nresult.payload,

        node_output = []

        for field in self.op.output_fields:

          if field == "node":

          elif field == "phys":

            val = vol["dev"]

          elif field == "vg":

          elif field == "size":

            val = int(float(vol["size"]))

          elif field == "instance":

          else:

            raise errors.ParameterError(field)

          node_output.append(str(val))

    if self.op.nodes:

      self.needed_locks = {

        }

    else:

      self.needed_locks = {

    """Computes the list of nodes and their attributes.

    """

    # Always get name to sort by

    if constants.SF_NAME in self.op.output_fields:

    name_idx = field_idx[constants.SF_NAME]

    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)

                                      self.op.storage_type, st_args,

                                      self.op.name, fields)

    result = []

      if nresult.offline:

        continue

      msg = nresult.fail_msg

      if msg:

        continue

      rows = dict([(row[name_idx], row) for row in nresult.payload])

        for field in self.op.output_fields:

          if field == constants.SF_NODE:

          elif field == constants.SF_TYPE:

            val = self.op.storage_type

          elif field in field_idx:

    """

    all_nodes = self.cfg.GetNodeList()

    try:

    except ValueError:

      pass

    return (all_nodes, all_nodes)

    Any errors are signaled by raising errors.OpPrereqError.

    """

    assert node is not None

    masternode = self.cfg.GetMasterNode()

      raise errors.OpPrereqError("Node is the master node, failover to another"

                                 " node is required", errors.ECODE_INVAL)

    for instance_name, instance in self.cfg.GetAllInstancesInfo().items():

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

                                   " please remove first" % instance_name,

                                   errors.ECODE_INVAL)

      "Not owning BGL"

    # Promote nodes to master candidate as needed

    # Run post hooks on the node before it's removed

    RunPostHook(self, node.name)

    result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)

    msg = result.fail_msg

    if msg:

    # Remove node from our /etc/hosts

    if self.cfg.GetClusterInfo().modify_etc_hosts:

                                              constants.ETC_HOSTS_REMOVE,

                                              node.name, None)

      result.Raise("Can't update hosts file with new host data")

  REQ_BGL = False

  def CheckArguments(self):

    storage_type = self.op.storage_type

  def ExpandNames(self):

    self.needed_locks = {

      }

    """Ensure faulty disks abort the opcode or at least warn."""

    try:

      if FindFaultyInstanceDisks(self.cfg, self.rpc, instance,

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

                                   errors.ECODE_STATE)

    except errors.OpPrereqError, err:

      if self.op.ignore_consistency:

    """

    # Check whether any instance on this node has faulty disks

      if not inst.disks_active:

        continue

      check_nodes = set(inst.all_nodes)

  def Exec(self, feedback_fn):

    feedback_fn("Repairing storage unit '%s' on %s ..." %

                (self.op.name, self.op.node_name))

    st_args = _GetStorageTypeArgs(self.cfg, self.op.storage_type)

                                           self.op.storage_type, st_args,

                                           self.op.name,

                                           constants.SO_FIX_CONSISTENCY)