Synnefo » snf-ganeti

    """

    self.needed_locks = {}

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

    if self.op.iallocator:

      # TODO: Find a solution to not lock all nodes in the cluster, e.g. by

    """

    assert self.op.mode == constants.INSTANCE_IMPORT

      locked_nodes = self.owned_locks(locking.LEVEL_NODE)

      exp_list = self.rpc.call_export_list(locked_nodes)

      found = False

      for node in exp_list:

        if exp_list[node].fail_msg:

          continue

          found = True

          self.op.src_node = node

          break

      if not found:

        raise errors.OpPrereqError("No export found for relative path %s" %

    export_info = objects.SerializableConfigParser.Loads(str(result.payload))

    if not export_info.has_section(constants.INISECT_EXP):

    """Create and add the instance to the cluster.

    """

    assert not (self.owned_locks(locking.LEVEL_NODE_RES) -

                self.owned_locks(locking.LEVEL_NODE)), \

      "Node locks differ from node resource locks"

    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,

        CreateDisks(self, iobj)

      except errors.OpExecError:

        self.LogWarning("Device creation failed")

        raise

    self.cfg.AddInstance(iobj, self.proc.GetECId())

            for idx, success in enumerate(result.payload):

              if not success:

                logging.warn("pause-sync of instance %s for disk %d failed",

          feedback_fn("* running the instance OS create scripts...")

          # FIXME: pass debug option from opcode to backend

            for idx, success in enumerate(result.payload):

              if not success:

                logging.warn("resume-sync of instance %s for disk %d failed",

          os_add_result.Raise("Could not add os for instance %s"

      else:

        if self.op.mode == constants.INSTANCE_IMPORT:

                                                  iobj, transfers)

          if not compat.all(import_result):

            self.LogWarning("Some disks for instance %s on node %s were not"

          rename_from = self._old_instance_name

            # TODO: Should the instance still be started, even if some disks

            # failed to import (valid for local imports, too)?

            self.LogWarning("Some disks for instance %s on node %s were not"

          rename_from = self.source_instance_name

                                       % self.op.mode)

        # Run rename script on newly imported instance

        result = self.rpc.call_instance_run_rename(self.pnode.uuid, iobj,

                                                   rename_from,

                                                   self.op.debug_level)

        result.Warn("Failed to run rename script for %s on node %s" %

    assert not self.owned_locks(locking.LEVEL_NODE_RES)

    if self.op.start:

      iobj.admin_state = constants.ADMINST_UP

      self.cfg.Update(iobj, feedback_fn)

      feedback_fn("* starting instance...")

      result = self.rpc.call_instance_start(self.pnode.uuid, (iobj, None, None),

                                            False, self.op.reason)

    """Rename the instance.

    """

    rename_file_storage = False

      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:

                                                     old_file_storage_dir,

                                                     new_file_storage_dir)

      result.Raise("Could not rename on node %s directory '%s' to '%s'"

                   " (but the instance has been renamed in Ganeti)" %

                    old_file_storage_dir, new_file_storage_dir))

    # update info on disks

        self.cfg.SetDiskID(disk, node_uuid)

        result = self.rpc.call_blockdev_setinfo(node_uuid, disk, info)

        result.Warn("Error setting info on node %s for disk %s" %

                    (self.cfg.GetNodeName(node_uuid), idx), self.LogWarning)

    try:

      result.Warn("Could not run OS rename script for instance %s on node %s"

                  " (but the instance has been renamed in Ganeti)" %

                  self.LogWarning)

    finally:

class LUInstanceRemove(LogicalUnit):

    """Remove the instance.

    """

                                             self.op.shutdown_timeout,

                                             self.op.reason)

    if self.op.ignore_failures:

      result.Warn("Warning: can't shutdown instance", feedback_fn)

    else:

      result.Raise("Could not shutdown instance %s on node %s" %

    assert (self.owned_locks(locking.LEVEL_NODE) ==

            self.owned_locks(locking.LEVEL_NODE_RES))

                self.owned_locks(locking.LEVEL_NODE)), \

      "Not owning correct locks"

class LUInstanceMove(LogicalUnit):

    This checks that the instance is in the cluster.

    """

    assert self.instance is not None, \

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

      raise errors.OpPrereqError("Disk template %s not suitable for copying" %

    target_node = self.cfg.GetNodeInfo(self.op.target_node_uuid)

    assert target_node is not None, \

      "Cannot retrieve locked node %s" % self.op.target_node

    self.target_node_uuid = target_node.uuid

      raise errors.OpPrereqError("Instance %s is already on the node %s" %

                                 errors.ECODE_STATE)

      if dsk.dev_type not in (constants.LD_LV, constants.LD_FILE):

        raise errors.OpPrereqError("Instance disk %d has a complex layout,"

                                   " cannot copy" % idx, errors.ECODE_STATE)

    cluster = self.cfg.GetClusterInfo()

    group_info = self.cfg.GetNodeGroup(target_node.group)

    ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster, group_info)

                           ignore=self.op.ignore_ipolicy)

      # check memory requirements on the secondary node

      CheckNodeFreeMemory(

          self, target_node.uuid, "failing over instance %s" %

    else:

      self.LogInfo("Not checking memory on the secondary node as"

                   " instance will not be started")

    # check bridge existance

  def Exec(self, feedback_fn):

    """Move an instance.

    the data over (slow) and starting it on the new node.

    """

    target_node = self.cfg.GetNodeInfo(self.target_node_uuid)

    self.LogInfo("Shutting down instance %s on source node %s",

    assert (self.owned_locks(locking.LEVEL_NODE) ==

            self.owned_locks(locking.LEVEL_NODE_RES))

                                             self.op.shutdown_timeout,

                                             self.op.reason)

    if self.op.ignore_consistency:

      result.Warn("Could not shutdown instance %s on node %s. Proceeding"

                  " anyway. Please make sure node %s is down. Error details" %

                  self.LogWarning)

    else:

      result.Raise("Could not shutdown instance %s on node %s" %

    # create the target disks

    try:

    except errors.OpExecError:

      self.LogWarning("Device creation failed")

      raise

    cluster_name = self.cfg.GetClusterInfo().cluster_name

    errs = []

    # activate, get path, copy the data over

      self.LogInfo("Copying data for disk %d", idx)

      if result.fail_msg:

        self.LogWarning("Can't assemble newly created disk %d: %s",

                        idx, result.fail_msg)

        errs.append(result.fail_msg)

        break

      dev_path = result.payload

                                             target_node.name, dev_path,

                                             cluster_name)

      if result.fail_msg:

    if errs:

      self.LogWarning("Some disks failed to copy, aborting")

      try:

      finally:

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

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

    self.LogInfo("Removing the disks on the original node")

    # Only start the instance if it's marked as up

      self.LogInfo("Starting instance %s on node %s",

                                          ignore_secondaries=True)

      if not disks_ok:

        raise errors.OpExecError("Can't activate the instance's disks")

      result = self.rpc.call_instance_start(target_node.uuid,

                                            self.op.reason)

      msg = result.fail_msg

      if msg:

        raise errors.OpExecError("Could not start instance %s on node %s: %s" %

class LUInstanceMultiAlloc(NoHooksLU):

  def _PreCheckDiskTemplate(self, pnode_info):

    """CheckPrereq checks related to a new disk template."""

    # Arguments are passed to avoid configuration lookups

      raise errors.OpPrereqError("Instance already has disk template %s" %

        self.op.disk_template) not in self._DISK_CONVERSIONS:

      raise errors.OpPrereqError("Unsupported disk template conversion from"

                                                self.op.disk_template),

                                 errors.ECODE_INVAL)

                       msg="cannot change disk template")

    if self.op.disk_template in constants.DTS_INT_MIRROR:

      if self.op.remote_node_uuid == pnode_uuid:

      CheckNodeOnline(self, self.op.remote_node_uuid)

      CheckNodeNotDrained(self, self.op.remote_node_uuid)

      # FIXME: here we assume that the old instance type is DT_PLAIN

      disks = [{constants.IDISK_SIZE: d.size,

                constants.IDISK_VG: d.logical_id[0]}

      required = ComputeDiskSizePerVG(self.op.disk_template, disks)

      CheckNodesFreeDiskPerVG(self, [self.op.remote_node_uuid], required)

      snode_info = self.cfg.GetNodeInfo(self.op.remote_node_uuid)

      snode_group = self.cfg.GetNodeGroup(snode_info.group)

                                                              snode_group)

                             ignore=self.op.ignore_ipolicy)

      if pnode_info.group != snode_info.group:

        self.LogWarning("The primary and secondary nodes are in two"

      has_es = lambda n: IsExclusiveStorageEnabledNode(self.cfg, n)

      if compat.any(map(has_es, nodes)):

        errmsg = ("Cannot convert disk template from %s to %s when exclusive"

                                           self.op.disk_template))

        raise errors.OpPrereqError(errmsg, errors.ECODE_STATE)

    @param ispec: instance specs to be updated with the new disks

    """

    excl_stor = compat.any(

      )

    # Check disk modifications. This is done here and not in CheckArguments

    # (as with NICs), because we need to know the instance's disk template

    ver_fn = lambda op, par: self._VerifyDiskModification(op, par, excl_stor)

      self._CheckMods("disk", self.op.disks, {}, ver_fn)

    else:

      self._CheckMods("disk", self.op.disks, constants.IDISK_PARAMS_TYPES,

    self.diskmod = _PrepareContainerMods(self.op.disks, None)

    # Check the validity of the `provider' parameter

      for mod in self.diskmod:

        ext_provider = mod[2].get(constants.IDISK_PROVIDER, None)

        if mod[0] == constants.DDM_ADD:

                                      constants.DT_EXT),

                                     errors.ECODE_INVAL)

      raise errors.OpPrereqError("Disk operations not supported for"

                                 " diskless instances", errors.ECODE_INVAL)

      disk.name = params.get(constants.IDISK_NAME, None)

    # Verify disk changes (operating on a copy)

    _ApplyContainerMods("disk", disks, None, self.diskmod, None,

                        _PrepareDiskMod, None)

    utils.ValidateDeviceNames("disk", disks)

      raise errors.OpPrereqError("Instance has too many disks (%d), cannot add"

                                 " more" % constants.MAX_DISKS,

                                 errors.ECODE_STATE)

    disk_sizes.extend(params["size"] for (op, idx, params, private) in

                      self.diskmod if op == constants.DDM_ADD)

    ispec[constants.ISPEC_DISK_COUNT] = len(disk_sizes)

    ispec[constants.ISPEC_DISK_SIZE] = disk_sizes

    if self.op.offline is not None and self.op.offline:

                         msg="can't change to offline")

  def CheckPrereq(self):

    """

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

    assert self.instance is not None, \

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

    self.warn = []

        not self.op.force):

      # verify that the instance is not up

      instance_info = self.rpc.call_instance_info(

      if instance_info.fail_msg:

        self.warn.append("Can't get instance runtime information: %s" %

                         instance_info.fail_msg)

                                   errors.ECODE_STATE)

    assert pnode_uuid in self.owned_locks(locking.LEVEL_NODE)

    pnode_info = self.cfg.GetNodeInfo(pnode_uuid)

    #_CheckInstanceNodeGroups(self.cfg, self.op.instance_name, owned_groups)

    # OS change

    if self.op.os_name and not self.op.force:

                     self.op.force_variant)

      instance_os = self.op.os_name

    else:

    assert not (self.op.disk_template and self.op.disks), \

      "Can't modify disk template and apply disk changes at the same time"

    # hvparams processing

    if self.op.hvparams:

      utils.ForceDictType(i_hvdict, constants.HVS_PARAMETER_TYPES)

      # local check

      hypervisor.GetHypervisorClass(hv_type).CheckParameterSyntax(hv_new)

      self.hv_proposed = self.hv_new = hv_new # the new actual values

      self.hv_inst = i_hvdict # the new dict (without defaults)

    else:

      self.hv_new = self.hv_inst = {}

    # beparams processing

    if self.op.beparams:

                                  use_none=True)

      objects.UpgradeBeParams(i_bedict)

      utils.ForceDictType(i_bedict, constants.BES_PARAMETER_TYPES)

      self.be_proposed = self.be_new = be_new # the new actual values

      self.be_inst = i_bedict # the new dict (without defaults)

    else:

      self.be_new = self.be_inst = {}

    # CPU param validation -- checking every time a parameter is

    # changed to cover all cases where either CPU mask or vcpus have

        max_requested_cpu = max(map(max, cpu_list))

        # Check that all of the instance's nodes have enough physical CPUs to

        # satisfy the requested CPU mask

                                max_requested_cpu + 1,

                                hvspecs)

    # osparams processing

    if self.op.osparams:

      CheckOSParams(self, True, node_uuids, instance_os, i_osdict)

      self.os_inst = i_osdict # the new dict (without defaults)

    else:

      mem_check_list = [pnode_uuid]

      if be_new[constants.BE_AUTO_BALANCE]:

        # either we changed auto_balance to yes or it was from before

      instance_info = self.rpc.call_instance_info(

      nodeinfo = self.rpc.call_node_info(mem_check_list, None,

                                         hvspecs, False)

      pninfo = nodeinfo[pnode_uuid]

      if be_new[constants.BE_AUTO_BALANCE]:

        for node_uuid, nres in nodeinfo.items():

            continue

          nres.Raise("Can't get info from secondary node %s" %

                     self.cfg.GetNodeName(node_uuid), prereq=True,

    if self.op.runtime_mem:

      remote_info = self.rpc.call_instance_info(

      remote_info.Raise("Error checking node %s" %

      if not remote_info.payload: # not running already

        raise errors.OpPrereqError("Instance %s is not running" %

      current_memory = remote_info.payload["memory"]

      if (not self.op.force and

        raise errors.OpPrereqError("Instance %s must have memory between %d"

                                   " and %d MB of memory unless --force is"

                                   " given" %

                                    self.be_proposed[constants.BE_MINMEM],

                                    self.be_proposed[constants.BE_MAXMEM]),

                                   errors.ECODE_INVAL)

      delta = self.op.runtime_mem - current_memory

      if delta > 0:

        CheckNodeFreeMemory(

    def _PrepareNicCreate(_, params, private):

      self._PrepareNicModification(params, private, None, None,

        self.cfg.ReleaseIp(net, ip, self.proc.GetECId())

    # Verify NIC changes (operating on copy)

    _ApplyContainerMods("NIC", nics, None, self.nicmod,

                        _PrepareNicCreate, _PrepareNicMod, _PrepareNicRemove)

    if len(nics) > constants.MAX_NICS:

    self._nic_chgdesc = []

    if self.nicmod:

      # Operate on copies as this is still in prereq

      _ApplyContainerMods("NIC", nics, self._nic_chgdesc, self.nicmod,

                          self._CreateNewNic, self._ApplyNicMods, None)

      # Verify that NIC names are unique and valid

      ispec[constants.ISPEC_NIC_COUNT] = len(self._new_nics)

    else:

      self._new_nics = None

    if not self.op.ignore_ipolicy:

                                                              group_info)

      # Fill ispec with backend parameters

      if self.op.disk_template:

        new_disk_template = self.op.disk_template

      else:

      ispec_max = ispec.copy()

      ispec_max[constants.ISPEC_MEM_SIZE] = \

        self.be_new.get(constants.BE_MAXMEM, None)

    """

    feedback_fn("Converting template to drbd")

    snode_uuid = self.op.remote_node_uuid

    # create a fake disk info for _GenerateDiskTemplate

    disk_info = [{constants.IDISK_SIZE: d.size, constants.IDISK_MODE: d.mode,

                  constants.IDISK_VG: d.logical_id[0],

                  constants.IDISK_NAME: d.name}

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

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

                                        self.diskparams)

    p_excl_stor = IsExclusiveStorageEnabledNodeUuid(self.cfg, pnode_uuid)

    s_excl_stor = IsExclusiveStorageEnabledNodeUuid(self.cfg, snode_uuid)

    feedback_fn("Creating additional volumes...")

    # first, create the missing data and meta devices

    for disk in anno_disks:

      # unfortunately this is... not too nice

                           info, True, p_excl_stor)

      for child in disk.children:

                             s_excl_stor)

    # at this stage, all new LVs have been created, we can rename the

    # old ones

    feedback_fn("Renaming original volumes...")

    rename_list = [(o, n.children[0].logical_id)

    result = self.rpc.call_blockdev_rename(pnode_uuid, rename_list)

    result.Raise("Failed to rename original LVs")

        for (node_uuid, excl_stor) in [(pnode_uuid, p_excl_stor),

                                       (snode_uuid, s_excl_stor)]:

          f_create = node_uuid == pnode_uuid

    except errors.GenericError, e:

      feedback_fn("Initializing of DRBD devices failed;"

                  " renaming back original volumes...")

      for disk in new_disks:

        self.cfg.SetDiskID(disk, pnode_uuid)

      rename_back_list = [(n.children[0], o.logical_id)

      result = self.rpc.call_blockdev_rename(pnode_uuid, rename_back_list)

      result.Raise("Failed to rename LVs back after error %s" % str(e))

      raise

    # at this point, the instance has been modified

    # Release node locks while waiting for sync

    ReleaseLocks(self, locking.LEVEL_NODE)

    # disks are created, waiting for sync

                                 oneshot=not self.op.wait_for_sync)

    if disk_abort:

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

    """Converts an instance from drbd to plain.

    """

    feedback_fn("Converting template to plain")

    # copy over size, mode and name

    for parent, child in zip(old_disks, new_disks):

      self.cfg.AddTcpUdpPort(tcp_port)

    # update instance structure

    # Release locks in case removing disks takes a while

    ReleaseLocks(self, locking.LEVEL_NODE)

    """Creates a new disk.

    """

    # add a new disk

      file_path = os.path.dirname(file_path)

    else:

      file_driver = file_path = None

    disk = \

    if self.cluster.prealloc_wipe_disks:

      # Wipe new disk

                         disks=[(idx, disk, 0)],

                         cleanup=new_disks)

      "Not owning any node resource locks"

    result = []

    # New primary node

    if self.op.pnode_uuid:

    # runtime memory

    if self.op.runtime_mem:

                                                     self.op.runtime_mem)

      rpcres.Raise("Cannot modify instance runtime memory")

      result.append(("runtime_memory", self.op.runtime_mem))

    # Apply disk changes

                        self._CreateNewDisk, self._ModifyDisk,

                        self._RemoveDisk)

    if self.op.disk_template:

      if __debug__:

        if self.op.remote_node_uuid:

          check_nodes.add(self.op.remote_node_uuid)

        for level in [locking.LEVEL_NODE, locking.LEVEL_NODE_RES]:

            ("Not owning the correct locks, owning %r, expected at least %r" %

             (owned, check_nodes))

      if not r_shut:

        raise errors.OpExecError("Cannot shutdown instance disks, unable to"

                                 " proceed with disk template conversion")

      try:

        self._DISK_CONVERSIONS[mode](self, feedback_fn)

      except:

        raise

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

        ("Expected disk template '%s', found '%s'" %

    # Release node and resource locks if there are any (they might already have

    # been released during disk conversion)

    # Apply NIC changes

    if self._new_nics is not None:

      result.extend(self._nic_chgdesc)

    # hvparams changes

    if self.op.hvparams:

      for key, val in self.op.hvparams.iteritems():

        result.append(("hv/%s" % key, val))

    # beparams changes

    if self.op.beparams:

      for key, val in self.op.beparams.iteritems():

        result.append(("be/%s" % key, val))

    # OS change

    if self.op.os_name:

    # osparams changes

    if self.op.osparams:

      for key, val in self.op.osparams.iteritems():

        result.append(("os/%s" % key, val))

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

    assert not (self.owned_locks(locking.LEVEL_NODE_RES) or

                self.owned_locks(locking.LEVEL_NODE)), \