Synnefo » snf-ganeti » ganeti-local

  ShareAll, GetDefaultIAllocator, CheckInstanceNodeGroups, \

  LoadNodeEvacResult, CheckIAllocatorOrNode, CheckParamsNotGlobal, \

  IsExclusiveStorageEnabledNode, CheckHVParams, CheckOSParams, \

  ComputeIPolicySpecViolation, CheckInstanceState, ExpandNodeUuidAndName

from ganeti.cmdlib.instance_storage import CreateDisks, \

  CheckNodesFreeDiskPerVG, WipeDisks, WipeOrCleanupDisks, WaitForSync, \

    # instance name verification

    if self.op.name_check:

      # used in CheckPrereq for ip ping check

    else:

      self.check_ip = None

    # this is just a preventive check, but someone might still add this

    # instance in the meantime, and creation will fail at lock-add time

      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %

                                 self.op.instance_name, errors.ECODE_EXISTS)

    else:

      network_port = None

    # This is ugly but we got a chicken-egg problem here

    # We can only take the group disk parameters, as the instance

    # has no disks yet (we are generating them right here).

    nodegroup = self.cfg.GetNodeGroup(self.pnode.group)

    disks = GenerateDiskTemplate(self,

                                 self.op.disk_template,

                                 self.secondaries,

                                 self.disks,

                                 self.instance_file_storage_dir,

                                 feedback_fn,

                                 self.cfg.GetGroupDiskParams(nodegroup))

                            primary_node=self.pnode.uuid,

                            nics=self.nics, disks=disks,

                            disk_template=self.op.disk_template,

    if disk_abort:

      RemoveDisks(self, iobj)

      # Make sure the instance lock gets removed

      self.remove_locks[locking.LEVEL_INSTANCE] = iobj.name

      raise errors.OpExecError("There are some degraded disks for"

    This checks that the instance is in the cluster and is not running.

    """

    assert instance is not None

    CheckNodeOnline(self, instance.primary_node)

    CheckInstanceState(self, instance, INSTANCE_NOT_RUNNING,

                                   (hostname.ip, new_name),

                                   errors.ECODE_NOTUNIQUE)

      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %

                                 new_name, errors.ECODE_EXISTS)

                               self.instance.disks[0].logical_id[1])

      rename_file_storage = True

    # Change the instance lock. This is definitely safe while we hold the BGL.

    # Otherwise the new lock would have to be added in acquired mode.

    assert self.REQ_BGL

    self.glm.add(locking.LEVEL_INSTANCE, self.op.new_name)

    # re-read the instance from the configuration after rename

    if rename_file_storage:

      new_file_storage_dir = os.path.dirname(

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

      CreateDisks(self, self.instance, target_node_uuid=target_node.uuid)

    except errors.OpExecError:

      self.LogWarning("Device creation failed")

      raise

    cluster_name = self.cfg.GetClusterInfo().cluster_name

      try:

        RemoveDisks(self, self.instance, target_node_uuid=target_node.uuid)

      finally:

        raise errors.OpExecError("Errors during disk copy: %s" %

                                 (",".join(errs),))

      # Acquire locks for the instance's nodegroups optimistically. Needs

      # to be verified in CheckPrereq

      self.needed_locks[locking.LEVEL_NODEGROUP] = \

    elif level == locking.LEVEL_NODE:

      self._LockInstancesNodes()

      if self.op.disk_template and self.op.remote_node:

    """

    assert self.op.instance_name in self.owned_locks(locking.LEVEL_INSTANCE)

    self.cluster = self.cfg.GetClusterInfo()

    assert self.instance is not None, \

                  constants.IDISK_NAME: d.name}

                 for d in self.instance.disks]

    new_disks = GenerateDiskTemplate(self, self.op.disk_template,

                                     [snode_uuid], disk_info, None, None, 0,

                                     feedback_fn, self.diskparams)

    anno_disks = rpc.AnnotateDiskParams(constants.DT_DRBD8, new_disks,

    disk = \

      GenerateDiskTemplate(self, self.instance.disk_template,

                           self.instance.secondary_nodes, [params], file_path,

                           file_driver, idx, self.Log, self.diskparams)[0]

      try:

        self._DISK_CONVERSIONS[mode](self, feedback_fn)

      except:

        raise

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

      pass

    elif self.op.offline:

      # Mark instance as offline

      result.append(("admin_state", constants.ADMINST_OFFLINE))

    else:

      # Mark instance as online, but stopped

      result.append(("admin_state", constants.ADMINST_DOWN))

    self.cfg.Update(self.instance, feedback_fn, self.proc.GetECId())

        # Lock all groups used by instance optimistically; this requires going

        # via the node before it's locked, requiring verification later on

        lock_groups.update(instance_groups)

      else:

        # No target groups, need to lock all of them

        # Lock all nodes in all potential target groups

        lock_groups = (frozenset(self.owned_locks(locking.LEVEL_NODEGROUP)) -

        member_nodes = [node_uuid

                        for group in lock_groups

                        for node_uuid in self.cfg.GetNodeGroup(group).members]

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

  def CheckPrereq(self):

    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))

    owned_nodes = frozenset(self.owned_locks(locking.LEVEL_NODE))

    assert (self.req_target_uuids is None or

            owned_groups.issuperset(self.req_target_uuids))

    # Get instance information

    # Check if node groups for locked instance are still correct

    assert owned_nodes.issuperset(self.instance.all_nodes), \

      ("Instance %s's nodes changed while we kept the lock" %

       self.op.instance_name)

                                          owned_groups)

    if self.req_target_uuids: