Synnefo » snf-ganeti

    Any errors are signaled by raising errors.OpPrereqError.

    """

    if self.op.secondary_ip is None:

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

        raise errors.OpPrereqError("When using a IPv6 primary address, a valid"

                                   " IPv4 address must be given as secondary",

                                   errors.ECODE_INVAL)

    secondary_ip = self.op.secondary_ip

    if not netutils.IP4Address.IsValid(secondary_ip):

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

                                 " address" % secondary_ip, errors.ECODE_INVAL)

    if not self.op.readd and existing_node_info is not None:

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

                                 node_name, errors.ECODE_EXISTS)

    self.changed_primary_ip = False

      if self.op.readd and node_name == existing_node.name:

        if existing_node.secondary_ip != secondary_ip:

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

                                     " address configuration as before",

                                     errors.ECODE_INVAL)

          self.changed_primary_ip = True

        continue

          existing_node.primary_ip == secondary_ip or

          existing_node.secondary_ip == secondary_ip):

        raise errors.OpPrereqError("New node ip address(es) conflict with"

          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"

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

    # same as for the master

    master_singlehomed = myself.secondary_ip == myself.primary_ip

    if master_singlehomed != newbie_singlehomed:

      if master_singlehomed:

        raise errors.OpPrereqError("The master has no secondary ip but the"

                                   errors.ECODE_INVAL)

    # checks reachability

      raise errors.OpPrereqError("Node not reachable by ping",

                                 errors.ECODE_ENVIRON)

    if self.op.readd:

      self.new_node = existing_node_info

    else:

      self.new_node = objects.Node(name=node_name,

                                   secondary_ip=secondary_ip,

                                   master_candidate=self.master_candidate,

                                   offline=False, drained=False,

                                 (constants.PROTOCOL_VERSION, result.payload),

                                 errors.ECODE_ENVIRON)

    if vg_name is not None:

      vparams = {constants.NV_PVLIST: [vg_name]}

      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" %

    """Adds the new node to the cluster.

    """

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

      "Not owning BGL"

    # We adding a new node so we assume it's powered

    # for re-adds, reset the offline/drained/master-candidate flags;

    # we need to reset here, otherwise offline would prevent RPC calls

    # later in the procedure; this also means that if the re-add

    # fails, we are left with a non-offlined, broken node

    if self.op.readd:

      self.LogInfo("Readding a node, the offline/drained flags were reset")

      # if we demote the node, we do cleanup later in the procedure

      if self.changed_primary_ip:

    # copy the master/vm_capable flags

    for attr in self._NFLAGS:

    # notify the user about any possible mc promotion

      self.LogInfo("Node will be a master candidate")

    if self.op.ndparams:

    else:

    if self.op.hv_state:

    if self.op.disk_state:

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

    if self.cfg.GetClusterInfo().modify_etc_hosts:

                 self.hostname.ip)

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

    node_verifier_uuids = [self.cfg.GetMasterNode()]

    node_verify_param = {

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

    }

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

    if self.op.readd:

      RedistributeAncillaryFiles(self)

      # make sure we redistribute the config

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

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

                    self.LogWarning)

    else:

      RedistributeAncillaryFiles(self)

    """

    node = self.cfg.GetNodeInfo(self.op.node_uuid)

    result = []

    if self.op.ndparams:

        setattr(node, attr, val)

        result.append((attr, str(val)))

      # Tell the node to demote itself, if no longer MC and not offline

        msg = self.rpc.call_node_demote_from_mc(node.name).fail_msg

        if msg:

          self.LogWarning("Node failed to demote itself: %s", msg)

      for of, nf, desc in zip(self.old_flags, new_flags, self._FLAGS):

        if of != nf:

          result.append((desc, str(nf)))

    # this will trigger job queue propagation or cleanup if the mc

    # flag changed

      self.context.ReaddNode(node)

    return result

  def Exec(self, feedback_fn):

    # Prepare jobs for migration instances

    jobs = [

      for inst in _GetNodePrimaryInstances(self.cfg, self.op.node_uuid)]

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

    """Removes the node from the cluster.

    """

    logging.info("Stopping the node daemon and removing configs from node %s",

    modify_ssh_setup = self.cfg.GetClusterInfo().modify_ssh_setup

      "Not owning BGL"

    # Promote nodes to master candidate as needed

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

    # we have to call this by name rather than by UUID, as the node is no longer

    # in the config

    msg = result.fail_msg

    if msg:

      self.LogWarning("Errors encountered on the remote node while leaving"

      master_node_uuid = self.cfg.GetMasterNode()

      result = self.rpc.call_etc_hosts_modify(master_node_uuid,

                                              constants.ETC_HOSTS_REMOVE,

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

      RedistributeAncillaryFiles(self)