Synnefo » snf-ganeti

#

#

# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Logical units dealing with instances."""

import OpenSSL

import copy

import logging

import os

from ganeti import compat

from ganeti import constants

from ganeti import errors

from ganeti import ht

from ganeti import hypervisor

from ganeti import locking

from ganeti.masterd import iallocator

from ganeti import masterd

from ganeti import netutils

from ganeti import objects

from ganeti import pathutils

import ganeti.rpc.node as rpc

from ganeti import utils

from ganeti.cmdlib.base import NoHooksLU, LogicalUnit, ResultWithJobs

from ganeti.cmdlib.common import INSTANCE_DOWN, \

  INSTANCE_NOT_RUNNING, CAN_CHANGE_INSTANCE_OFFLINE, CheckNodeOnline, \

  ShareAll, GetDefaultIAllocator, CheckInstanceNodeGroups, \

  LoadNodeEvacResult, CheckIAllocatorOrNode, CheckParamsNotGlobal, \

  IsExclusiveStorageEnabledNode, CheckHVParams, CheckOSParams, \

  AnnotateDiskParams, GetUpdatedParams, ExpandInstanceUuidAndName, \

  ComputeIPolicySpecViolation, CheckInstanceState, ExpandNodeUuidAndName, \

  CheckDiskTemplateEnabled, IsValidDiskAccessModeCombination

from ganeti.cmdlib.instance_storage import CreateDisks, \

  CheckNodesFreeDiskPerVG, WipeDisks, WipeOrCleanupDisks, WaitForSync, \

  IsExclusiveStorageEnabledNodeUuid, CreateSingleBlockDev, ComputeDisks, \

  CheckRADOSFreeSpace, ComputeDiskSizePerVG, GenerateDiskTemplate, \

  StartInstanceDisks, ShutdownInstanceDisks, AssembleInstanceDisks, \

  CheckSpindlesExclusiveStorage

from ganeti.cmdlib.instance_utils import BuildInstanceHookEnvByObject, \

  GetClusterDomainSecret, BuildInstanceHookEnv, NICListToTuple, \

  NICToTuple, CheckNodeNotDrained, RemoveInstance, CopyLockList, \

  ReleaseLocks, CheckNodeVmCapable, CheckTargetNodeIPolicy, \

  GetInstanceInfoText, RemoveDisks, CheckNodeFreeMemory, \

  CheckInstanceBridgesExist, CheckNicsBridgesExist, CheckNodeHasOS

import ganeti.masterd.instance

#: Type description for changes as returned by L{_ApplyContainerMods}'s

#: callbacks

_TApplyContModsCbChanges = \

  ht.TMaybeListOf(ht.TAnd(ht.TIsLength(2), ht.TItems([

    ht.TNonEmptyString,

    ht.TAny,

    ])))

def _CheckHostnameSane(lu, name):

  """Ensures that a given hostname resolves to a 'sane' name.

  The given name is required to be a prefix of the resolved hostname,

  to prevent accidental mismatches.

  @param lu: the logical unit on behalf of which we're checking

  @param name: the name we should resolve and check

  @return: the resolved hostname object

  """

  hostname = netutils.GetHostname(name=name)

  if hostname.name != name:

    lu.LogInfo("Resolved given name '%s' to '%s'", name, hostname.name)

  if not utils.MatchNameComponent(name, [hostname.name]):

    raise errors.OpPrereqError(("Resolved hostname '%s' does not look the"

                                " same as given hostname '%s'") %

                               (hostname.name, name), errors.ECODE_INVAL)

  return hostname

def _CheckOpportunisticLocking(op):

  """Generate error if opportunistic locking is not possible.

  """

  if op.opportunistic_locking and not op.iallocator:

    raise errors.OpPrereqError("Opportunistic locking is only available in"

                               " combination with an instance allocator",

                               errors.ECODE_INVAL)

def _CreateInstanceAllocRequest(op, disks, nics, beparams, node_name_whitelist):

  """Wrapper around IAReqInstanceAlloc.

  @param op: The instance opcode

  @param disks: The computed disks

  @param nics: The computed nics

  @param beparams: The full filled beparams

  @param node_name_whitelist: List of nodes which should appear as online to the

    allocator (unless the node is already marked offline)

  @returns: A filled L{iallocator.IAReqInstanceAlloc}

  """

  spindle_use = beparams[constants.BE_SPINDLE_USE]

  return iallocator.IAReqInstanceAlloc(name=op.instance_name,

                                       disk_template=op.disk_template,

                                       tags=op.tags,

                                       os=op.os_type,

                                       vcpus=beparams[constants.BE_VCPUS],

                                       memory=beparams[constants.BE_MAXMEM],

                                       spindle_use=spindle_use,

                                       disks=disks,

                                       nics=[n.ToDict() for n in nics],

                                       hypervisor=op.hypervisor,

                                       node_whitelist=node_name_whitelist)

def _ComputeFullBeParams(op, cluster):

  """Computes the full beparams.

  @param op: The instance opcode

  @param cluster: The cluster config object

  @return: The fully filled beparams

  """

  default_beparams = cluster.beparams[constants.PP_DEFAULT]

  for param, value in op.beparams.iteritems():

    if value == constants.VALUE_AUTO:

      op.beparams[param] = default_beparams[param]

  objects.UpgradeBeParams(op.beparams)

  utils.ForceDictType(op.beparams, constants.BES_PARAMETER_TYPES)

  return cluster.SimpleFillBE(op.beparams)

def _ComputeNics(op, cluster, default_ip, cfg, ec_id):

  """Computes the nics.

  @param op: The instance opcode

  @param cluster: Cluster configuration object

  @param default_ip: The default ip to assign

  @param cfg: An instance of the configuration object

  @param ec_id: Execution context ID

  @returns: The build up nics

  """

  nics = []

  for nic in op.nics:

    nic_mode_req = nic.get(constants.INIC_MODE, None)

    nic_mode = nic_mode_req

    if nic_mode is None or nic_mode == constants.VALUE_AUTO:

      nic_mode = cluster.nicparams[constants.PP_DEFAULT][constants.NIC_MODE]

    net = nic.get(constants.INIC_NETWORK, None)

    link = nic.get(constants.NIC_LINK, None)

    ip = nic.get(constants.INIC_IP, None)

    vlan = nic.get(constants.INIC_VLAN, None)

    if net is None or net.lower() == constants.VALUE_NONE:

      net = None

    else:

      if nic_mode_req is not None or link is not None:

        raise errors.OpPrereqError("If network is given, no mode or link"

                                   " is allowed to be passed",

                                   errors.ECODE_INVAL)

    # ip validity checks

    if ip is None or ip.lower() == constants.VALUE_NONE:

      nic_ip = None

    elif ip.lower() == constants.VALUE_AUTO:

      if not op.name_check:

        raise errors.OpPrereqError("IP address set to auto but name checks"

                                   " have been skipped",

                                   errors.ECODE_INVAL)

      nic_ip = default_ip

    else:

      # We defer pool operations until later, so that the iallocator has

      # filled in the instance's node(s) dimara

      if ip.lower() == constants.NIC_IP_POOL:

        if net is None:

          raise errors.OpPrereqError("if ip=pool, parameter network"

                                     " must be passed too",

                                     errors.ECODE_INVAL)

      elif not netutils.IPAddress.IsValid(ip):

        raise errors.OpPrereqError("Invalid IP address '%s'" % ip,

                                   errors.ECODE_INVAL)

      nic_ip = ip

    # TODO: check the ip address for uniqueness

    if nic_mode == constants.NIC_MODE_ROUTED and not nic_ip:

      raise errors.OpPrereqError("Routed nic mode requires an ip address",

                                 errors.ECODE_INVAL)

    # MAC address verification

    mac = nic.get(constants.INIC_MAC, constants.VALUE_AUTO)

    if mac not in (constants.VALUE_AUTO, constants.VALUE_GENERATE):

      mac = utils.NormalizeAndValidateMac(mac)

      try:

        # TODO: We need to factor this out

        cfg.ReserveMAC(mac, ec_id)

      except errors.ReservationError:

        raise errors.OpPrereqError("MAC address %s already in use"

                                   " in cluster" % mac,

                                   errors.ECODE_NOTUNIQUE)

    #  Build nic parameters

    nicparams = {}

    if nic_mode_req:

      nicparams[constants.NIC_MODE] = nic_mode

    if link:

      nicparams[constants.NIC_LINK] = link

    if vlan:

      nicparams[constants.NIC_VLAN] = vlan

    check_params = cluster.SimpleFillNIC(nicparams)

    objects.NIC.CheckParameterSyntax(check_params)

    net_uuid = cfg.LookupNetwork(net)

    name = nic.get(constants.INIC_NAME, None)

    if name is not None and name.lower() == constants.VALUE_NONE:

      name = None

    nic_obj = objects.NIC(mac=mac, ip=nic_ip, name=name,

                          network=net_uuid, nicparams=nicparams)

    nic_obj.uuid = cfg.GenerateUniqueID(ec_id)

    nics.append(nic_obj)

  return nics

def _CheckForConflictingIp(lu, ip, node_uuid):

  """In case of conflicting IP address raise error.

  @type ip: string

  @param ip: IP address

  @type node_uuid: string

  @param node_uuid: node UUID

  """

  (conf_net, _) = lu.cfg.CheckIPInNodeGroup(ip, node_uuid)

  if conf_net is not None:

    raise errors.OpPrereqError(("The requested IP address (%s) belongs to"

                                " network %s, but the target NIC does not." %

                                (ip, conf_net)),

                               errors.ECODE_STATE)

  return (None, None)

def _ComputeIPolicyInstanceSpecViolation(

  ipolicy, instance_spec, disk_template,

  _compute_fn=ComputeIPolicySpecViolation):

  """Compute if instance specs meets the specs of ipolicy.

  @type ipolicy: dict

  @param ipolicy: The ipolicy to verify against

  @param instance_spec: dict

  @param instance_spec: The instance spec to verify

  @type disk_template: string

  @param disk_template: the disk template of the instance

  @param _compute_fn: The function to verify ipolicy (unittest only)

  @see: L{ComputeIPolicySpecViolation}

  """

  mem_size = instance_spec.get(constants.ISPEC_MEM_SIZE, None)

  cpu_count = instance_spec.get(constants.ISPEC_CPU_COUNT, None)

  disk_count = instance_spec.get(constants.ISPEC_DISK_COUNT, 0)

  disk_sizes = instance_spec.get(constants.ISPEC_DISK_SIZE, [])

  nic_count = instance_spec.get(constants.ISPEC_NIC_COUNT, 0)

  spindle_use = instance_spec.get(constants.ISPEC_SPINDLE_USE, None)

  return _compute_fn(ipolicy, mem_size, cpu_count, disk_count, nic_count,

                     disk_sizes, spindle_use, disk_template)

def _CheckOSVariant(os_obj, name):

  """Check whether an OS name conforms to the os variants specification.

  @type os_obj: L{objects.OS}

  @param os_obj: OS object to check

  @type name: string

  @param name: OS name passed by the user, to check for validity

  """

  variant = objects.OS.GetVariant(name)

  if not os_obj.supported_variants:

    if variant:

      raise errors.OpPrereqError("OS '%s' doesn't support variants ('%s'"

                                 " passed)" % (os_obj.name, variant),

                                 errors.ECODE_INVAL)

    return

  if not variant:

    raise errors.OpPrereqError("OS name must include a variant",

                               errors.ECODE_INVAL)

  if variant not in os_obj.supported_variants:

    raise errors.OpPrereqError("Unsupported OS variant", errors.ECODE_INVAL)

class LUInstanceCreate(LogicalUnit):

  """Create an instance.

  """

  HPATH = "instance-add"

  HTYPE = constants.HTYPE_INSTANCE

  REQ_BGL = False

  def _CheckDiskTemplateValid(self):

    """Checks validity of disk template.

    """

    cluster = self.cfg.GetClusterInfo()

    if self.op.disk_template is None:

      # FIXME: It would be better to take the default disk template from the

      # ipolicy, but for the ipolicy we need the primary node, which we get from

      # the iallocator, which wants the disk template as input. To solve this

      # chicken-and-egg problem, it should be possible to specify just a node

      # group from the iallocator and take the ipolicy from that.

      self.op.disk_template = cluster.enabled_disk_templates[0]

    CheckDiskTemplateEnabled(cluster, self.op.disk_template)

  def _CheckDiskArguments(self):

    """Checks validity of disk-related arguments.

    """

    # check that disk's names are unique and valid

    utils.ValidateDeviceNames("disk", self.op.disks)

    self._CheckDiskTemplateValid()

    # check disks. parameter names and consistent adopt/no-adopt strategy

    has_adopt = has_no_adopt = False

    for disk in self.op.disks:

      if self.op.disk_template != constants.DT_EXT:

        utils.ForceDictType(disk, constants.IDISK_PARAMS_TYPES)

      if constants.IDISK_ADOPT in disk:

        has_adopt = True

      else:

        has_no_adopt = True

    if has_adopt and has_no_adopt:

      raise errors.OpPrereqError("Either all disks are adopted or none is",

                                 errors.ECODE_INVAL)

    if has_adopt:

      if self.op.disk_template not in constants.DTS_MAY_ADOPT:

        raise errors.OpPrereqError("Disk adoption is not supported for the"

                                   " '%s' disk template" %

                                   self.op.disk_template,

                                   errors.ECODE_INVAL)

      if self.op.iallocator is not None:

        raise errors.OpPrereqError("Disk adoption not allowed with an"

                                   " iallocator script", errors.ECODE_INVAL)

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

        raise errors.OpPrereqError("Disk adoption not allowed for"

                                   " instance import", errors.ECODE_INVAL)

    else:

      if self.op.disk_template in constants.DTS_MUST_ADOPT:

        raise errors.OpPrereqError("Disk template %s requires disk adoption,"

                                   " but no 'adopt' parameter given" %

                                   self.op.disk_template,

                                   errors.ECODE_INVAL)

    self.adopt_disks = has_adopt

  def _CheckVLANArguments(self):

    """ Check validity of VLANs if given

    """

    for nic in self.op.nics:

      vlan = nic.get(constants.INIC_VLAN, None)

      if vlan:

        if vlan[0] == ".":

          # vlan starting with dot means single untagged vlan,

          # might be followed by trunk (:)

          if not vlan[1:].isdigit():

            vlanlist = vlan[1:].split(':')

            for vl in vlanlist:

              if not vl.isdigit():

                raise errors.OpPrereqError("Specified VLAN parameter is "

                                           "invalid : %s" % vlan,

                                             errors.ECODE_INVAL)

        elif vlan[0] == ":":

          # Trunk - tagged only

          vlanlist = vlan[1:].split(':')

          for vl in vlanlist:

            if not vl.isdigit():

              raise errors.OpPrereqError("Specified VLAN parameter is invalid"

                                           " : %s" % vlan, errors.ECODE_INVAL)

        elif vlan.isdigit():

          # This is the simplest case. No dots, only single digit

          # -> Create untagged access port, dot needs to be added

          nic[constants.INIC_VLAN] = "." + vlan

        else:

          raise errors.OpPrereqError("Specified VLAN parameter is invalid"

                                       " : %s" % vlan, errors.ECODE_INVAL)

  def CheckArguments(self):

    """Check arguments.

    """

    # do not require name_check to ease forward/backward compatibility

    # for tools

    if self.op.no_install and self.op.start:

      self.LogInfo("No-installation mode selected, disabling startup")

      self.op.start = False

    # validate/normalize the instance name

    self.op.instance_name = \

      netutils.Hostname.GetNormalizedName(self.op.instance_name)

    if self.op.ip_check and not self.op.name_check:

      # TODO: make the ip check more flexible and not depend on the name check

      raise errors.OpPrereqError("Cannot do IP address check without a name"

                                 " check", errors.ECODE_INVAL)

    # add nic for instance communication

    if self.op.instance_communication:

      nic_name = "%s%s" % (constants.INSTANCE_COMMUNICATION_NIC_PREFIX,

                           self.op.instance_name)

      communication_network = constants.INSTANCE_COMMUNICATION_NETWORK

      self.op.nics.append({constants.INIC_NAME: nic_name,

                           constants.INIC_MAC: constants.VALUE_GENERATE,

                           constants.INIC_IP: constants.NIC_IP_POOL,

                           constants.INIC_NETWORK: communication_network})

    # check nics' parameter names

    for nic in self.op.nics:

      utils.ForceDictType(nic, constants.INIC_PARAMS_TYPES)

    # check that NIC's parameters names are unique and valid

    utils.ValidateDeviceNames("NIC", self.op.nics)

    self._CheckVLANArguments()

    self._CheckDiskArguments()

    assert self.op.disk_template is not None

    # instance name verification

    if self.op.name_check:

      self.hostname = _CheckHostnameSane(self, self.op.instance_name)

      self.op.instance_name = self.hostname.name

      # used in CheckPrereq for ip ping check

      self.check_ip = self.hostname.ip

    else:

      self.check_ip = None

    # file storage checks

    if (self.op.file_driver and

        not self.op.file_driver in constants.FILE_DRIVER):

      raise errors.OpPrereqError("Invalid file driver name '%s'" %

                                 self.op.file_driver, errors.ECODE_INVAL)

    # set default file_driver if unset and required

    if (not self.op.file_driver and

        self.op.disk_template in constants.DTS_FILEBASED):

      self.op.file_driver = constants.FD_LOOP

    ### Node/iallocator related checks

    CheckIAllocatorOrNode(self, "iallocator", "pnode")

    if self.op.pnode is not None:

      if self.op.disk_template in constants.DTS_INT_MIRROR:

        if self.op.snode is None:

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

                                     " a mirror node", errors.ECODE_INVAL)

      elif self.op.snode:

        self.LogWarning("Secondary node will be ignored on non-mirrored disk"

                        " template")

        self.op.snode = None

    _CheckOpportunisticLocking(self.op)

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

      # On import force_variant must be True, because if we forced it at

      # initial install, our only chance when importing it back is that it

      # works again!

      self.op.force_variant = True

      if self.op.no_install:

        self.LogInfo("No-installation mode has no effect during import")

    elif self.op.mode == constants.INSTANCE_CREATE:

      if self.op.os_type is None:

        raise errors.OpPrereqError("No guest OS specified",

                                   errors.ECODE_INVAL)

      if self.op.os_type in self.cfg.GetClusterInfo().blacklisted_os:

        raise errors.OpPrereqError("Guest OS '%s' is not allowed for"

                                   " installation" % self.op.os_type,

                                   errors.ECODE_STATE)

    elif self.op.mode == constants.INSTANCE_REMOTE_IMPORT:

      self._cds = GetClusterDomainSecret()

      # Check handshake to ensure both clusters have the same domain secret

      src_handshake = self.op.source_handshake

      if not src_handshake:

        raise errors.OpPrereqError("Missing source handshake",

                                   errors.ECODE_INVAL)

      errmsg = masterd.instance.CheckRemoteExportHandshake(self._cds,

                                                           src_handshake)

      if errmsg:

        raise errors.OpPrereqError("Invalid handshake: %s" % errmsg,

                                   errors.ECODE_INVAL)

      # Load and check source CA

      self.source_x509_ca_pem = self.op.source_x509_ca

      if not self.source_x509_ca_pem:

        raise errors.OpPrereqError("Missing source X509 CA",

                                   errors.ECODE_INVAL)

      try:

        (cert, _) = utils.LoadSignedX509Certificate(self.source_x509_ca_pem,

                                                    self._cds)

      except OpenSSL.crypto.Error, err:

        raise errors.OpPrereqError("Unable to load source X509 CA (%s)" %

                                   (err, ), errors.ECODE_INVAL)

      (errcode, msg) = utils.VerifyX509Certificate(cert, None, None)

      if errcode is not None:

        raise errors.OpPrereqError("Invalid source X509 CA (%s)" % (msg, ),

                                   errors.ECODE_INVAL)

      self.source_x509_ca = cert

      src_instance_name = self.op.source_instance_name

      if not src_instance_name:

        raise errors.OpPrereqError("Missing source instance name",

                                   errors.ECODE_INVAL)

      self.source_instance_name = \

        netutils.GetHostname(name=src_instance_name).name

    else:

      raise errors.OpPrereqError("Invalid instance creation mode %r" %

                                 self.op.mode, errors.ECODE_INVAL)

  def ExpandNames(self):

    """ExpandNames for CreateInstance.

    Figure out the right locks for instance creation.

    """

    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

    if self.op.instance_name in\

      [inst.name for inst in self.cfg.GetAllInstancesInfo().values()]:

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

                                 self.op.instance_name, errors.ECODE_EXISTS)

    self.add_locks[locking.LEVEL_INSTANCE] = self.op.instance_name

    if self.op.iallocator:

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

      # specifying a group on instance creation and then selecting nodes from

      # that group

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

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

      if self.op.opportunistic_locking:

        self.opportunistic_locks[locking.LEVEL_NODE] = True

    else:

      (self.op.pnode_uuid, self.op.pnode) = \

        ExpandNodeUuidAndName(self.cfg, self.op.pnode_uuid, self.op.pnode)

      nodelist = [self.op.pnode_uuid]

      if self.op.snode is not None:

        (self.op.snode_uuid, self.op.snode) = \

          ExpandNodeUuidAndName(self.cfg, self.op.snode_uuid, self.op.snode)

        nodelist.append(self.op.snode_uuid)

      self.needed_locks[locking.LEVEL_NODE] = nodelist

    # in case of import lock the source node too

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

      src_node = self.op.src_node

      src_path = self.op.src_path

      if src_path is None:

        self.op.src_path = src_path = self.op.instance_name

      if src_node is None:

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

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

        self.op.src_node = None

        if os.path.isabs(src_path):

          raise errors.OpPrereqError("Importing an instance from a path"

                                     " requires a source node option",

                                     errors.ECODE_INVAL)

      else:

        (self.op.src_node_uuid, self.op.src_node) = (_, src_node) = \

          ExpandNodeUuidAndName(self.cfg, self.op.src_node_uuid, src_node)

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

          self.needed_locks[locking.LEVEL_NODE].append(self.op.src_node_uuid)

        if not os.path.isabs(src_path):

          self.op.src_path = \

            utils.PathJoin(pathutils.EXPORT_DIR, src_path)

    self.needed_locks[locking.LEVEL_NODE_RES] = \

      CopyLockList(self.needed_locks[locking.LEVEL_NODE])

    # Optimistically acquire shared group locks (we're reading the

    # configuration).  We can't just call GetInstanceNodeGroups, because the

    # instance doesn't exist yet. Therefore we lock all node groups of all

    # nodes we have.

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

      # In the case we lock all nodes for opportunistic allocation, we have no

      # choice than to lock all groups, because they're allocated before nodes.

      # This is sad, but true. At least we release all those we don't need in

      # CheckPrereq later.

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

    else:

      self.needed_locks[locking.LEVEL_NODEGROUP] = \

        list(self.cfg.GetNodeGroupsFromNodes(

          self.needed_locks[locking.LEVEL_NODE]))

    self.share_locks[locking.LEVEL_NODEGROUP] = 1

  def DeclareLocks(self, level):

    if level == locking.LEVEL_NODE_RES and \

      self.opportunistic_locks[locking.LEVEL_NODE]:

      # Even when using opportunistic locking, we require the same set of

      # NODE_RES locks as we got NODE locks

      self.needed_locks[locking.LEVEL_NODE_RES] = \

        self.owned_locks(locking.LEVEL_NODE)

  def _RunAllocator(self):

    """Run the allocator based on input opcode.

    """

    if self.op.opportunistic_locking:

      # Only consider nodes for which a lock is held

      node_name_whitelist = self.cfg.GetNodeNames(

        self.owned_locks(locking.LEVEL_NODE))

    else:

      node_name_whitelist = None

    req = _CreateInstanceAllocRequest(self.op, self.disks,

                                      self.nics, self.be_full,

                                      node_name_whitelist)

    ial = iallocator.IAllocator(self.cfg, self.rpc, req)

    ial.Run(self.op.iallocator)

    if not ial.success:

      # When opportunistic locks are used only a temporary failure is generated

      if self.op.opportunistic_locking:

        ecode = errors.ECODE_TEMP_NORES

      else:

        ecode = errors.ECODE_NORES

      raise errors.OpPrereqError("Can't compute nodes using"

                                 " iallocator '%s': %s" %

                                 (self.op.iallocator, ial.info),

                                 ecode)

    (self.op.pnode_uuid, self.op.pnode) = \

      ExpandNodeUuidAndName(self.cfg, None, ial.result[0])

    self.LogInfo("Selected nodes for instance %s via iallocator %s: %s",

                 self.op.instance_name, self.op.iallocator,

                 utils.CommaJoin(ial.result))

    assert req.RequiredNodes() in (1, 2), "Wrong node count from iallocator"

    if req.RequiredNodes() == 2:

      (self.op.snode_uuid, self.op.snode) = \

        ExpandNodeUuidAndName(self.cfg, None, ial.result[1])

  def BuildHooksEnv(self):

    """Build hooks env.

    This runs on master, primary and secondary nodes of the instance.

    """

    env = {

      "ADD_MODE": self.op.mode,

      }

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

      env["SRC_NODE"] = self.op.src_node

      env["SRC_PATH"] = self.op.src_path

      env["SRC_IMAGES"] = self.src_images

    env.update(BuildInstanceHookEnv(

      name=self.op.instance_name,

      primary_node_name=self.op.pnode,

      secondary_node_names=self.cfg.GetNodeNames(self.secondaries),

      status=self.op.start,

      os_type=self.op.os_type,

      minmem=self.be_full[constants.BE_MINMEM],

      maxmem=self.be_full[constants.BE_MAXMEM],

      vcpus=self.be_full[constants.BE_VCPUS],

      nics=NICListToTuple(self, self.nics),

      disk_template=self.op.disk_template,

      disks=[(d[constants.IDISK_NAME], d.get("uuid", ""),

              d[constants.IDISK_SIZE], d[constants.IDISK_MODE])

             for d in self.disks],

      bep=self.be_full,

      hvp=self.hv_full,

      hypervisor_name=self.op.hypervisor,

      tags=self.op.tags,

      ))

    return env

  def BuildHooksNodes(self):

    """Build hooks nodes.

    """

    nl = [self.cfg.GetMasterNode(), self.op.pnode_uuid] + self.secondaries

    return nl, nl

  def _ReadExportInfo(self):

    """Reads the export information from disk.

    It will override the opcode source node and path with the actual

    information, if these two were not specified before.

    @return: the export information

    """

    assert self.op.mode == constants.INSTANCE_IMPORT

    if self.op.src_node_uuid is None:

      locked_nodes = self.owned_locks(locking.LEVEL_NODE)

      exp_list = self.rpc.call_export_list(locked_nodes)

      found = False

      for node_uuid in exp_list:

        if exp_list[node_uuid].fail_msg:

          continue

        if self.op.src_path in exp_list[node_uuid].payload:

          found = True

          self.op.src_node = self.cfg.GetNodeInfo(node_uuid).name

          self.op.src_node_uuid = node_uuid

          self.op.src_path = utils.PathJoin(pathutils.EXPORT_DIR,

                                            self.op.src_path)

          break

      if not found:

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

                                   self.op.src_path, errors.ECODE_INVAL)

    CheckNodeOnline(self, self.op.src_node_uuid)

    result = self.rpc.call_export_info(self.op.src_node_uuid, self.op.src_path)

    result.Raise("No export or invalid export found in dir %s" %

                 self.op.src_path)

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

    if not export_info.has_section(constants.INISECT_EXP):

      raise errors.ProgrammerError("Corrupted export config",

                                   errors.ECODE_ENVIRON)

    ei_version = export_info.get(constants.INISECT_EXP, "version")

    if int(ei_version) != constants.EXPORT_VERSION:

      raise errors.OpPrereqError("Wrong export version %s (wanted %d)" %

                                 (ei_version, constants.EXPORT_VERSION),

                                 errors.ECODE_ENVIRON)

    return export_info

  def _ReadExportParams(self, einfo):

    """Use export parameters as defaults.

    In case the opcode doesn't specify (as in override) some instance

    parameters, then try to use them from the export information, if

    that declares them.

    """

    self.op.os_type = einfo.get(constants.INISECT_EXP, "os")

    if not self.op.disks:

      disks = []

      # TODO: import the disk iv_name too

      for idx in range(constants.MAX_DISKS):

        if einfo.has_option(constants.INISECT_INS, "disk%d_size" % idx):

          disk_sz = einfo.getint(constants.INISECT_INS, "disk%d_size" % idx)

          disks.append({constants.IDISK_SIZE: disk_sz})

      self.op.disks = disks

      if not disks and self.op.disk_template != constants.DT_DISKLESS:

        raise errors.OpPrereqError("No disk info specified and the export"

                                   " is missing the disk information",

                                   errors.ECODE_INVAL)

    if not self.op.nics:

      nics = []

      for idx in range(constants.MAX_NICS):

        if einfo.has_option(constants.INISECT_INS, "nic%d_mac" % idx):

          ndict = {}

          for name in list(constants.NICS_PARAMETERS) + ["ip", "mac"]:

            nic_param_name = "nic%d_%s" % (idx, name)

            if einfo.has_option(constants.INISECT_INS, nic_param_name):

              v = einfo.get(constants.INISECT_INS, nic_param_name)

              ndict[name] = v

          nics.append(ndict)

        else:

          break

      self.op.nics = nics

    if not self.op.tags and einfo.has_option(constants.INISECT_INS, "tags"):

      self.op.tags = einfo.get(constants.INISECT_INS, "tags").split()

    if (self.op.hypervisor is None and

        einfo.has_option(constants.INISECT_INS, "hypervisor")):

      self.op.hypervisor = einfo.get(constants.INISECT_INS, "hypervisor")

    if einfo.has_section(constants.INISECT_HYP):

      # use the export parameters but do not override the ones

      # specified by the user

      for name, value in einfo.items(constants.INISECT_HYP):

        if name not in self.op.hvparams:

          self.op.hvparams[name] = value

    if einfo.has_section(constants.INISECT_BEP):

      # use the parameters, without overriding

      for name, value in einfo.items(constants.INISECT_BEP):

        if name not in self.op.beparams:

          self.op.beparams[name] = value

        # Compatibility for the old "memory" be param

        if name == constants.BE_MEMORY:

          if constants.BE_MAXMEM not in self.op.beparams:

            self.op.beparams[constants.BE_MAXMEM] = value

          if constants.BE_MINMEM not in self.op.beparams:

            self.op.beparams[constants.BE_MINMEM] = value

    else:

      # try to read the parameters old style, from the main section

      for name in constants.BES_PARAMETERS:

        if (name not in self.op.beparams and

            einfo.has_option(constants.INISECT_INS, name)):

          self.op.beparams[name] = einfo.get(constants.INISECT_INS, name)

    if einfo.has_section(constants.INISECT_OSP):

      # use the parameters, without overriding

      for name, value in einfo.items(constants.INISECT_OSP):

        if name not in self.op.osparams:

          self.op.osparams[name] = value

  def _RevertToDefaults(self, cluster):

    """Revert the instance parameters to the default values.

    """

    # hvparams

    hv_defs = cluster.SimpleFillHV(self.op.hypervisor, self.op.os_type, {})

    for name in self.op.hvparams.keys():

      if name in hv_defs and hv_defs[name] == self.op.hvparams[name]:

        del self.op.hvparams[name]

    # beparams

    be_defs = cluster.SimpleFillBE({})

    for name in self.op.beparams.keys():

      if name in be_defs and be_defs[name] == self.op.beparams[name]:

        del self.op.beparams[name]

    # nic params

    nic_defs = cluster.SimpleFillNIC({})

    for nic in self.op.nics:

      for name in constants.NICS_PARAMETERS:

        if name in nic and name in nic_defs and nic[name] == nic_defs[name]:

          del nic[name]

    # osparams

    os_defs = cluster.SimpleFillOS(self.op.os_type, {})

    for name in self.op.osparams.keys():

      if name in os_defs and os_defs[name] == self.op.osparams[name]:

        del self.op.osparams[name]

  def _CalculateFileStorageDir(self):

    """Calculate final instance file storage dir.

    """

    # file storage dir calculation/check

    self.instance_file_storage_dir = None

    if self.op.disk_template in constants.DTS_FILEBASED:

      # build the full file storage dir path

      joinargs = []

      cfg_storage = None

      if self.op.disk_template == constants.DT_FILE:

        cfg_storage = self.cfg.GetFileStorageDir()

      elif self.op.disk_template == constants.DT_SHARED_FILE:

        cfg_storage = self.cfg.GetSharedFileStorageDir()

      elif self.op.disk_template == constants.DT_GLUSTER:

        cfg_storage = self.cfg.GetGlusterStorageDir()

      if not cfg_storage:

        raise errors.OpPrereqError(

          "Cluster file storage dir for {tpl} storage type not defined".format(

            tpl=repr(self.op.disk_template)

          ),

          errors.ECODE_STATE

      )

      joinargs.append(cfg_storage)

      if self.op.file_storage_dir is not None:

        joinargs.append(self.op.file_storage_dir)

      if self.op.disk_template != constants.DT_GLUSTER:

        joinargs.append(self.op.instance_name)

      if len(joinargs) > 1:

        # pylint: disable=W0142

        self.instance_file_storage_dir = utils.PathJoin(*joinargs)

      else:

        self.instance_file_storage_dir = joinargs[0]

  def CheckPrereq(self): # pylint: disable=R0914

    """Check prerequisites.

    """

    # Check that the optimistically acquired groups are correct wrt the

    # acquired nodes

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

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

    cur_groups = list(self.cfg.GetNodeGroupsFromNodes(owned_nodes))

    if not owned_groups.issuperset(cur_groups):

      raise errors.OpPrereqError("New instance %s's node groups changed since"

                                 " locks were acquired, current groups are"

                                 " are '%s', owning groups '%s'; retry the"

                                 " operation" %

                                 (self.op.instance_name,

                                  utils.CommaJoin(cur_groups),

                                  utils.CommaJoin(owned_groups)),

                                 errors.ECODE_STATE)

    self._CalculateFileStorageDir()

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

      export_info = self._ReadExportInfo()

      self._ReadExportParams(export_info)

      self._old_instance_name = export_info.get(constants.INISECT_INS, "name")

    else:

      self._old_instance_name = None

    if (not self.cfg.GetVGName() and

        self.op.disk_template not in constants.DTS_NOT_LVM):

      raise errors.OpPrereqError("Cluster does not support lvm-based"

                                 " instances", errors.ECODE_STATE)

    if (self.op.hypervisor is None or

        self.op.hypervisor == constants.VALUE_AUTO):

      self.op.hypervisor = self.cfg.GetHypervisorType()

    cluster = self.cfg.GetClusterInfo()

    enabled_hvs = cluster.enabled_hypervisors

    if self.op.hypervisor not in enabled_hvs:

      raise errors.OpPrereqError("Selected hypervisor (%s) not enabled in the"

                                 " cluster (%s)" %

                                 (self.op.hypervisor, ",".join(enabled_hvs)),

                                 errors.ECODE_STATE)

    # Check tag validity

    for tag in self.op.tags:

      objects.TaggableObject.ValidateTag(tag)

    # check hypervisor parameter syntax (locally)

    utils.ForceDictType(self.op.hvparams, constants.HVS_PARAMETER_TYPES)

    filled_hvp = cluster.SimpleFillHV(self.op.hypervisor, self.op.os_type,

                                      self.op.hvparams)

    hv_type = hypervisor.GetHypervisorClass(self.op.hypervisor)

    hv_type.CheckParameterSyntax(filled_hvp)

    self.hv_full = filled_hvp

    # check that we don't specify global parameters on an instance

    CheckParamsNotGlobal(self.op.hvparams, constants.HVC_GLOBALS, "hypervisor",

                         "instance", "cluster")

    # fill and remember the beparams dict

    self.be_full = _ComputeFullBeParams(self.op, cluster)

    # build os parameters

    self.os_full = cluster.SimpleFillOS(self.op.os_type, self.op.osparams)

    # now that hvp/bep are in final format, let's reset to defaults,

    # if told to do so

    if self.op.identify_defaults:

      self._RevertToDefaults(cluster)

    # NIC buildup

    self.nics = _ComputeNics(self.op, cluster, self.check_ip, self.cfg,

                             self.proc.GetECId())

    # disk checks/pre-build

    default_vg = self.cfg.GetVGName()

    self.disks = ComputeDisks(self.op, default_vg)

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

      disk_images = []

      for idx in range(len(self.disks)):

        option = "disk%d_dump" % idx

        if export_info.has_option(constants.INISECT_INS, option):

          # FIXME: are the old os-es, disk sizes, etc. useful?

          export_name = export_info.get(constants.INISECT_INS, option)

          image = utils.PathJoin(self.op.src_path, export_name)

          disk_images.append(image)

        else:

          disk_images.append(False)

      self.src_images = disk_images

      if self.op.instance_name == self._old_instance_name:

        for idx, nic in enumerate(self.nics):

          if nic.mac == constants.VALUE_AUTO:

            nic_mac_ini = "nic%d_mac" % idx

            nic.mac = export_info.get(constants.INISECT_INS, nic_mac_ini)

    # ENDIF: self.op.mode == constants.INSTANCE_IMPORT

    # ip ping checks (we use the same ip that was resolved in ExpandNames)

    if self.op.ip_check:

      if netutils.TcpPing(self.check_ip, constants.DEFAULT_NODED_PORT):

        raise errors.OpPrereqError("IP %s of instance %s already in use" %

                                   (self.check_ip, self.op.instance_name),

                                   errors.ECODE_NOTUNIQUE)

    #### mac address generation

    # By generating here the mac address both the allocator and the hooks get

    # the real final mac address rather than the 'auto' or 'generate' value.

    # There is a race condition between the generation and the instance object

    # creation, which means that we know the mac is valid now, but we're not

    # sure it will be when we actually add the instance. If things go bad

    # adding the instance will abort because of a duplicate mac, and the

    # creation job will fail.

    for nic in self.nics:

      if nic.mac in (constants.VALUE_AUTO, constants.VALUE_GENERATE):

        nic.mac = self.cfg.GenerateMAC(nic.network, self.proc.GetECId())

    #### allocator run

    if self.op.iallocator is not None:

      self._RunAllocator()

    # Release all unneeded node locks

    keep_locks = filter(None, [self.op.pnode_uuid, self.op.snode_uuid,

                               self.op.src_node_uuid])

    ReleaseLocks(self, locking.LEVEL_NODE, keep=keep_locks)

    ReleaseLocks(self, locking.LEVEL_NODE_RES, keep=keep_locks)

    ReleaseLocks(self, locking.LEVEL_NODE_ALLOC)

    # Release all unneeded group locks

    ReleaseLocks(self, locking.LEVEL_NODEGROUP,

                 keep=self.cfg.GetNodeGroupsFromNodes(keep_locks))

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

            self.owned_locks(locking.LEVEL_NODE_RES)), \

      "Node locks differ from node resource locks"

    #### node related checks

    # check primary node

    self.pnode = pnode = self.cfg.GetNodeInfo(self.op.pnode_uuid)

    assert self.pnode is not None, \

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

    if pnode.offline:

      raise errors.OpPrereqError("Cannot use offline primary node '%s'" %

                                 pnode.name, errors.ECODE_STATE)

    if pnode.drained:

      raise errors.OpPrereqError("Cannot use drained primary node '%s'" %

                                 pnode.name, errors.ECODE_STATE)

    if not pnode.vm_capable:

      raise errors.OpPrereqError("Cannot use non-vm_capable primary node"

                                 " '%s'" % pnode.name, errors.ECODE_STATE)

    self.secondaries = []

    # Fill in any IPs from IP pools. This must happen here, because we need to

    # know the nic's primary node, as specified by the iallocator

    for idx, nic in enumerate(self.nics):

      net_uuid = nic.network

      if net_uuid is not None:

        nobj = self.cfg.GetNetwork(net_uuid)

        netparams = self.cfg.GetGroupNetParams(net_uuid, self.pnode.uuid)

        if netparams is None:

          raise errors.OpPrereqError("No netparams found for network"

                                     " %s. Probably not connected to"

                                     " node's %s nodegroup" %

                                     (nobj.name, self.pnode.name),

                                     errors.ECODE_INVAL)

        self.LogInfo("NIC/%d inherits netparams %s" %

                     (idx, netparams.values()))

        nic.nicparams = dict(netparams)

        if nic.ip is not None:

          if nic.ip.lower() == constants.NIC_IP_POOL:

            try:

              nic.ip = self.cfg.GenerateIp(net_uuid, self.proc.GetECId())

            except errors.ReservationError:

              raise errors.OpPrereqError("Unable to get a free IP for NIC %d"

                                         " from the address pool" % idx,

                                         errors.ECODE_STATE)

            self.LogInfo("Chose IP %s from network %s", nic.ip, nobj.name)

          else:

            try:

              self.cfg.ReserveIp(net_uuid, nic.ip, self.proc.GetECId(),

                                 check=self.op.conflicts_check)

            except errors.ReservationError:

              raise errors.OpPrereqError("IP address %s already in use"

                                         " or does not belong to network %s" %

                                         (nic.ip, nobj.name),

                                         errors.ECODE_NOTUNIQUE)

      # net is None, ip None or given

      elif self.op.conflicts_check:

        _CheckForConflictingIp(self, nic.ip, self.pnode.uuid)

    # mirror node verification