Synnefo » snf-ganeti

                                   required_field, errors.ECODE_INVAL)

    # Validate special fields

    if spec['primary_node'] is not None:

          spec['secondary_node'] is None):

        raise errors.OpPrereqError('Template requires secondary node, but'

                                   ' there was no secondary provided.',

      disk_dict['size'] = utils.ParseUnit(disk_dict['size'])

  if (opts.disk_template and

      not opts.node):

    ToStderr("Changing the disk template to a mirrored one requires"

             " specifying a secondary node")

               utils.CommaJoin(inst_config.secondary_nodes),

               code=self.ETYPE_WARNING)

        pnode = inst_config.primary_node

        instance_nodes = utils.NiceSort(inst_config.all_nodes)

        instance_groups = {}

      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)

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

            instances_keep.append(instance_name)

            self.affected_instances.append(instance)

      "NEW_PRIMARY": self.op.target_node,

      }

      env["OLD_SECONDARY"] = instance.secondary_nodes[0]

      env["NEW_SECONDARY"] = source_node

    else:

        "NEW_PRIMARY": target_node,

        })

      env["OLD_SECONDARY"] = target_node

      env["NEW_SECONDARY"] = source_node

    else:

                       " primary node (%s)" % source_node)

      demoted_node = target_node

      self._EnsureSecondary(demoted_node)

      try:

        self._WaitUntilSync()

    self.source_node = self.instance.primary_node

    # FIXME: if we implement migrate-to-any in DRBD, this needs fixing

      self.target_node = self.instance.secondary_nodes[0]

      # Otherwise self.target_node has been populated either

      # directly, or through an iallocator.

    _CheckIAllocatorOrNode(self, "iallocator", "pnode")

    if self.op.pnode is not None:

        if self.op.snode is None:

          raise errors.OpPrereqError("The networked disk templates need"

                                     " a mirror node", errors.ECODE_INVAL)

    self.secondaries = []

    # mirror node verification

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

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

                                   " primary node.", errors.ECODE_INVAL)

    if self.op.wait_for_sync:

      disk_abort = not _WaitForSync(self, iobj)

      # make sure the disks are not degraded (still sync-ing is ok)

      time.sleep(15)

      feedback_fn("* checking mirrors status")

                                 errors.ECODE_INVAL)

    if (self.op.disk_template and

        self.op.remote_node is None):

      raise errors.OpPrereqError("Changing the disk template to a mirrored"

                                 " one requires specifying a secondary node",

                                                  self.op.disk_template),

                                   errors.ECODE_INVAL)

      _CheckInstanceDown(self, instance, "cannot change disk template")

        if self.op.remote_node == pnode:

          raise errors.OpPrereqError("Given new secondary node %s is the same"

                                     " as the primary node of the instance" %

    In particular, it returns information about newly split instances, and

    instances that were already split, and remain so after the change.

    considered.

    @type changes: list of (node_name, new_group_uuid) pairs.

      return [instance.primary_node] + list(instance.secondary_nodes)

    for inst in instance_data.values():

        continue

      instance_nodes = InstanceNodes(inst)

    """

    disk_space = _ComputeDiskSize(self.disk_template, self.disks)

      self.required_nodes = 2

    else:

      self.required_nodes = 1

      raise errors.OpPrereqError("Can't relocate non-mirrored instances",

                                 errors.ECODE_INVAL)

        len(instance.secondary_nodes) != 1:

      raise errors.OpPrereqError("Instance has not exactly one secondary node",

                                 errors.ECODE_STATE)

DT_BLOCK = "blockdev"

# the set of network-mirrored disk templates

# the set of externally-mirrored disk templates (e.g. SAN, NAS)

DTS_EXT_MIRROR = frozenset([DT_SHARED_FILE, DT_BLOCK])

DTS_MUST_ADOPT = frozenset([DT_BLOCK])

# the set of disk templates that allow migrations

# logical disk types

      if self.opts.iallocator:

        pnode = snode = None

        msg = "with iallocator %s" % self.opts.iallocator

        snode = None

        msg = "on %s" % pnode

      else:

        import_log_msg = ("import from %s"

                          " with iallocator %s" %

                          (enode, self.opts.iallocator))

        snode = None

        import_log_msg = ("import from %s to %s" %

                          (enode, pnode))

    has_err = True

    try:

      self.BurnCreateInstances()

        self.BurnReplaceDisks1D8()

      if (opts.do_replace2 and len(self.nodes) > 2 and

        self.BurnReplaceDisks2()

      if (opts.disk_template in constants.DTS_GROWABLE and