Synnefo » snf-ganeti » ganeti-local

#

#

# 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, \

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

    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

        self.opportunistic_locks[locking.LEVEL_NODE_RES] = 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 _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[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