Synnefo » snf-ganeti

                 opts.master_capable, opts.vm_capable, opts.secondary_ip]

                               secondary_ip=opts.secondary_ip,

     CAPAB_MASTER_OPT, CAPAB_VM_OPT, SECONDARY_IP_OPT,

def _CheckNodeHasSecondaryIP(lu, node, secondary_ip, prereq):

  """Ensure that a node has the given secondary ip.

  @type lu: L{LogicalUnit}

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

  @type node: string

  @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.OpPrereqError: if the node doesn't have the ip, and prereq=True

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

  """

  result = lu.rpc.call_node_has_ip_address(node, secondary_ip)

  result.Raise("Failure checking secondary ip on node %s" % node,

               prereq=prereq, ecode=errors.ECODE_ENVIRON)

  if not result.payload:

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

           " please fix and re-run this command" % secondary_ip)

    if prereq:

      raise errors.OpPrereqError(msg, errors.ECODE_ENVIRON)

    else:

      raise errors.OpExecError(msg)

                                   " based ping to node daemon port",

      _CheckNodeHasSecondaryIP(self, new_node.name, new_node.secondary_ip,

                               False)

    ("secondary_ip", None, ht.TMaybeString),

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

                self.op.secondary_ip]

    if self.op.secondary_ip:

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

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

                                   " address" % self.op.secondary_ip,

                                   errors.ECODE_INVAL)

    self.lock_instances = self.op.secondary_ip is not None

    if self.lock_instances:

      self.needed_locks[locking.LEVEL_INSTANCE] = locking.ALL_SET

  def DeclareLocks(self, level):

    # If we have locked all instances, before waiting to lock nodes, release

    # all the ones living on nodes unrelated to the current operation.

    if level == locking.LEVEL_NODE and self.lock_instances:

      instances_release = []

      instances_keep = []

      self.affected_instances = []

      if self.needed_locks[locking.LEVEL_NODE] is not locking.ALL_SET:

        for instance_name in self.acquired_locks[locking.LEVEL_INSTANCE]:

          instance = self.context.cfg.GetInstanceInfo(instance_name)

          i_mirrored = instance.disk_template in constants.DTS_NET_MIRROR

          if i_mirrored and self.op.node_name in instance.all_nodes:

            instances_keep.append(instance_name)

            self.affected_instances.append(instance)

          else:

            instances_release.append(instance_name)

        if instances_release:

          self.context.glm.release(locking.LEVEL_INSTANCE, instances_release)

          self.acquired_locks[locking.LEVEL_INSTANCE] = instances_keep

    if self.op.secondary_ip:

      # Ok even without locking, because this can't be changed by any LU

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

      master_singlehomed = master.secondary_ip == master.primary_ip

      if master_singlehomed and self.op.secondary_ip:

        raise errors.OpPrereqError("Cannot change the secondary ip on a single"

                                   " homed cluster", errors.ECODE_INVAL)

      if node.offline:

        if self.affected_instances:

          raise errors.OpPrereqError("Cannot change secondary ip: offline"

                                     " node has instances (%s) configured"

                                     " to use it" % self.affected_instances)

      else:

        # On online nodes, check that no instances are running, and that

        # the node has the new ip and we can reach it.

        for instance in self.affected_instances:

          _CheckInstanceDown(self, instance, "cannot change secondary ip")

        _CheckNodeHasSecondaryIP(self, node.name, self.op.secondary_ip, True)

        if master.name != node.name:

          # check reachability from master secondary ip to new secondary ip

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

                                  constants.DEFAULT_NODED_PORT,

                                  source=master.secondary_ip):

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

                                       " based ping to node daemon port",

                                       errors.ECODE_ENVIRON)

    if self.op.secondary_ip:

      node.secondary_ip = self.op.secondary_ip

      result.append(("secondary_ip", self.op.secondary_ip))

    "secondary_ip",

        <arg>-s <replaceable>secondary_ip</replaceable></arg>

      <para>

        The <option>-s</option> can be used to change the node's secondary ip.

        No drbd instances can be running on the node, while this operation is

        taking place.

      </para>