Synnefo » snf-ganeti

#

#

# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 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 opcodes

from ganeti import pathutils

from ganeti import 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, ExpandInstanceName, \

  ComputeIPolicySpecViolation, CheckInstanceState, ExpandNodeName

from ganeti.cmdlib.instance_storage import CreateDisks, \

  CheckNodesFreeDiskPerVG, WipeDisks, WipeOrCleanupDisks, WaitForSync, \

  IsExclusiveStorageEnabledNodeName, CreateSingleBlockDev, ComputeDisks, \

  CheckRADOSFreeSpace, ComputeDiskSizePerVG, GenerateDiskTemplate, \

  StartInstanceDisks, ShutdownInstanceDisks, AssembleInstanceDisks

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

    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

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

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

  @type ip: string

  @param ip: IP address

  @type node: string

  @param node: node name

  """

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

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

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

    # check that disk's names are unique and valid

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

    cluster = self.cfg.GetClusterInfo()

    if not self.op.disk_template in cluster.enabled_disk_templates:

      raise errors.OpPrereqError("Cannot create an instance with disk template"

                                 " '%s', because it is not enabled in the"

                                 " cluster. Enabled disk templates are: %s." %

                                 (self.op.disk_template,

                                  ",".join(cluster.enabled_disk_templates)))

    # 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

    # instance name verification

    if self.op.name_check:

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

      self.op.instance_name = self.hostname1.name

      # used in CheckPrereq for ip ping check

      self.check_ip = self.hostname1.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.DT_FILE,

                                  constants.DT_SHARED_FILE]):

      self.op.file_driver = constants.FD_LOOP

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

      opcodes.RequireFileStorage()

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

      opcodes.RequireSharedFileStorage()

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

    self._cds = GetClusterDomainSecret()

    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)

      if self.op.disk_template is None:

        raise errors.OpPrereqError("No disk template specified",

                                   errors.ECODE_INVAL)

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

      # 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 = {}

    instance_name = self.op.instance_name

    # 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 instance_name in self.cfg.GetInstanceList():

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

                                 instance_name, errors.ECODE_EXISTS)

    self.add_locks[locking.LEVEL_INSTANCE] = 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 = ExpandNodeName(self.cfg, self.op.pnode)

      nodelist = [self.op.pnode]

      if self.op.snode is not None:

        self.op.snode = ExpandNodeName(self.cfg, self.op.snode)

        nodelist.append(self.op.snode)

      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 = src_node = ExpandNodeName(self.cfg, src_node)

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

          self.needed_locks[locking.LEVEL_NODE].append(src_node)

        if not os.path.isabs(src_path):

          self.op.src_path = src_path = \

            utils.PathJoin(pathutils.EXPORT_DIR, src_path)

    self.needed_locks[locking.LEVEL_NODE_RES] = \

      CopyLockList(self.needed_locks[locking.LEVEL_NODE])

  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_whitelist = list(self.owned_locks(locking.LEVEL_NODE))

    else:

      node_whitelist = None

    #TODO Export network to iallocator so that it chooses a pnode

    #     in a nodegroup that has the desired network connected to

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

                                      self.nics, self.be_full,

                                      node_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 = 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 = 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=self.op.pnode,

      secondary_nodes=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] + 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

    src_node = self.op.src_node

    src_path = self.op.src_path

    if src_node is None:

      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

        if src_path in exp_list[node].payload:

          found = True

          self.op.src_node = src_node = node

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

                                                       src_path)

          break

      if not found:

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

                                   src_path, errors.ECODE_INVAL)

    CheckNodeOnline(self, src_node)

    result = self.rpc.call_export_info(src_node, src_path)

    result.Raise("No export or invalid export found in dir %s" % 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 self.op.disk_template is None:

      if einfo.has_option(constants.INISECT_INS, "disk_template"):

        self.op.disk_template = einfo.get(constants.INISECT_INS,

                                          "disk_template")

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

          raise errors.OpPrereqError("Disk template specified in configuration"

                                     " file is not one of the allowed values:"

                                     " %s" %

                                     " ".join(constants.DISK_TEMPLATES),

                                     errors.ECODE_INVAL)

      else:

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

                                   " is missing the disk_template information",

                                   errors.ECODE_INVAL)

    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"]:

            v = einfo.get(constants.INISECT_INS, "nic%d_%s" % (idx, 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 = []

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

        get_fsd_fn = self.cfg.GetSharedFileStorageDir

      else:

        get_fsd_fn = self.cfg.GetFileStorageDir

      cfg_storagedir = get_fsd_fn()

      if not cfg_storagedir:

        raise errors.OpPrereqError("Cluster file storage dir not defined",

                                   errors.ECODE_STATE)

      joinargs.append(cfg_storagedir)

      if self.op.file_storage_dir is not None:

        joinargs.append(self.op.file_storage_dir)

      joinargs.append(self.op.instance_name)

      # pylint: disable=W0142

      self.instance_file_storage_dir = utils.PathJoin(*joinargs)

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

    """Check prerequisites.

    """

    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, self.op.snode, self.op.src_node])

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

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

    ReleaseLocks(self, locking.LEVEL_NODE_ALLOC)

    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)

    assert self.pnode is not None, \

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

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

        if netparams is None:

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

                                     " %s. Propably 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())

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

    # mirror node verification

    if self.op.disk_template in constants.DTS_INT_MIRROR:

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

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

                                   " primary node", errors.ECODE_INVAL)

      CheckNodeOnline(self, self.op.snode)

      CheckNodeNotDrained(self, self.op.snode)

      CheckNodeVmCapable(self, self.op.snode)

      self.secondaries.append(self.op.snode)

      snode = self.cfg.GetNodeInfo(self.op.snode)

      if pnode.group != snode.group:

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

                        " different node groups; the disk parameters"

                        " from the first disk's node group will be"

                        " used")

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

      nodes = [pnode]

      if self.op.disk_template in constants.DTS_INT_MIRROR:

        nodes.append(snode)

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

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

        raise errors.OpPrereqError("Disk template %s not supported with"

                                   " exclusive storage" % self.op.disk_template,

                                   errors.ECODE_STATE)

    nodenames = [pnode.name] + self.secondaries

    if not self.adopt_disks:

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

        # _CheckRADOSFreeSpace() is just a placeholder.

        # Any function that checks prerequisites can be placed here.

        # Check if there is enough space on the RADOS cluster.

        CheckRADOSFreeSpace()

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

        # FIXME: Function that checks prereqs if needed

        pass

      else:

        # Check lv size requirements, if not adopting

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

        CheckNodesFreeDiskPerVG(self, nodenames, req_sizes)

    elif self.op.disk_template == constants.DT_PLAIN: # Check the adoption data

      all_lvs = set(["%s/%s" % (disk[constants.IDISK_VG],

                                disk[constants.IDISK_ADOPT])

                     for disk in self.disks])

      if len(all_lvs) != len(self.disks):

        raise errors.OpPrereqError("Duplicate volume names given for adoption",

                                   errors.ECODE_INVAL)

      for lv_name in all_lvs:

        try:

          # FIXME: lv_name here is "vg/lv" need to ensure that other calls

          # to ReserveLV uses the same syntax

          self.cfg.ReserveLV(lv_name, self.proc.GetECId())

        except errors.ReservationError:

          raise errors.OpPrereqError("LV named %s used by another instance" %

                                     lv_name, errors.ECODE_NOTUNIQUE)

      vg_names = self.rpc.call_vg_list([pnode.name])[pnode.name]

      vg_names.Raise("Cannot get VG information from node %s" % pnode.name)

      node_lvs = self.rpc.call_lv_list([pnode.name],

                                       vg_names.payload.keys())[pnode.name]

      node_lvs.Raise("Cannot get LV information from node %s" % pnode.name)

      node_lvs = node_lvs.payload

      delta = all_lvs.difference(node_lvs.keys())

      if delta:

        raise errors.OpPrereqError("Missing logical volume(s): %s" %

                                   utils.CommaJoin(delta),

                                   errors.ECODE_INVAL)

      online_lvs = [lv for lv in all_lvs if node_lvs[lv][2]]

      if online_lvs:

        raise errors.OpPrereqError("Online logical volumes found, cannot"

                                   " adopt: %s" % utils.CommaJoin(online_lvs),

                                   errors.ECODE_STATE)

      # update the size of disk based on what is found

      for dsk in self.disks:

        dsk[constants.IDISK_SIZE] = \

          int(float(node_lvs["%s/%s" % (dsk[constants.IDISK_VG],

                                        dsk[constants.IDISK_ADOPT])][0]))

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

      # Normalize and de-duplicate device paths

      all_disks = set([os.path.abspath(disk[constants.IDISK_ADOPT])

                       for disk in self.disks])

      if len(all_disks) != len(self.disks):

        raise errors.OpPrereqError("Duplicate disk names given for adoption",