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

  ComputeIPolicySpecViolation, CheckInstanceState, ExpandNodeUuidAndName, \

  CheckDiskTemplateEnabled

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)

    if vlan is not None and nic_mode != constants.NIC_MODE_OVS:

      raise errors.OpPrereqError("VLAN is given, but network mode is not"

                                 " openvswitch", 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)

    # 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.DT_FILE,

                                  constants.DT_SHARED_FILE]):

      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

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

  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: