iallocator: get rid of MakeLegacyNodeInfo

[ganeti-local] / lib / backend.py

diff --git a/lib/backend.py b/lib/backend.py
index cbcf4dd..a89c55a 100644 (file)
--- a/lib/backend.py
+++ b/lib/backend.py
@@ -56,6 +56,7 @@ from ganeti import hypervisor
 from ganeti import constants
 from ganeti.storage import bdev
 from ganeti.storage import drbd
 from ganeti import constants
 from ganeti.storage import bdev
 from ganeti.storage import drbd

+from ganeti.storage import filestorage

 from ganeti import objects
 from ganeti import ssconf
 from ganeti import serializer
 from ganeti import objects
 from ganeti import ssconf
 from ganeti import serializer

@@ -586,9 +587,10 @@ def _GetVgInfo(name, excl_stor):
     vg_size = None
 
   return {
     vg_size = None
 
   return {

+    "type": constants.ST_LVM_VG,

     "name": name,
     "name": name,

-    "vg_free": vg_free,
-    "vg_size": vg_size,
+    "storage_free": vg_free,
+    "storage_size": vg_size,

     }
 
 
     }
 
 

@@ -610,13 +612,14 @@ def _GetVgSpindlesInfo(name, excl_stor):
     vg_free = 0
     vg_size = 0
   return {
     vg_free = 0
     vg_size = 0
   return {

+    "type": constants.ST_LVM_PV,

     "name": name,
     "name": name,

-    "vg_free": vg_free,
-    "vg_size": vg_size,
+    "storage_free": vg_free,
+    "storage_size": vg_size,

     }
 
 
     }
 
 

-def _GetHvInfo(name):
+def _GetHvInfo(name, hvparams, get_hv_fn=hypervisor.GetHypervisor):

   """Retrieves node information from a hypervisor.
 
   The information returned depends on the hypervisor. Common items:
   """Retrieves node information from a hypervisor.
 
   The information returned depends on the hypervisor. Common items:

@@ -628,8 +631,29 @@ def _GetHvInfo(name):
     - memory_total is the total number of ram in MiB
     - hv_version: the hypervisor version, if available
 
     - memory_total is the total number of ram in MiB
     - hv_version: the hypervisor version, if available
 

+  @type hvparams: dict of string
+  @param hvparams: the hypervisor's hvparams
+
+  """
+  return get_hv_fn(name).GetNodeInfo(hvparams=hvparams)
+
+
+def _GetHvInfoAll(hv_specs, get_hv_fn=hypervisor.GetHypervisor):
+  """Retrieves node information for all hypervisors.
+
+  See C{_GetHvInfo} for information on the output.
+
+  @type hv_specs: list of pairs (string, dict of strings)
+  @param hv_specs: list of pairs of a hypervisor's name and its hvparams
+

   """
   """

-  return hypervisor.GetHypervisor(name).GetNodeInfo()
+  if hv_specs is None:
+    return None
+
+  result = []
+  for hvname, hvparams in hv_specs:
+    result.append(_GetHvInfo(hvname, hvparams, get_hv_fn))
+  return result

 
 
 def _GetNamedNodeInfo(names, fn):
 
 
 def _GetNamedNodeInfo(names, fn):

@@ -644,15 +668,15 @@ def _GetNamedNodeInfo(names, fn):
     return map(fn, names)
 
 
     return map(fn, names)
 
 

-def GetNodeInfo(storage_units, hv_names, excl_stor):
+def GetNodeInfo(storage_units, hv_specs, excl_stor):

   """Gives back a hash with different information about the node.
 
   @type storage_units: list of pairs (string, string)
   @param storage_units: List of pairs (storage unit, identifier) to ask for disk
                         space information. In case of lvm-vg, the identifier is
                         the VG name.
   """Gives back a hash with different information about the node.
 
   @type storage_units: list of pairs (string, string)
   @param storage_units: List of pairs (storage unit, identifier) to ask for disk
                         space information. In case of lvm-vg, the identifier is
                         the VG name.

-  @type hv_names: list of string
-  @param hv_names: Names of the hypervisors to ask for node information
+  @type hv_specs: list of pairs (string, dict of strings)
+  @param hv_specs: list of pairs of a hypervisor's name and its hvparams

   @type excl_stor: boolean
   @param excl_stor: Whether exclusive_storage is active
   @rtype: tuple; (string, None/dict, None/dict)
   @type excl_stor: boolean
   @param excl_stor: Whether exclusive_storage is active
   @rtype: tuple; (string, None/dict, None/dict)

@@ -666,17 +690,31 @@ def GetNodeInfo(storage_units, hv_names, excl_stor):
     (lambda storage_unit: _ApplyStorageInfoFunction(storage_unit[0],
                                                     storage_unit[1],
                                                     excl_stor)))
     (lambda storage_unit: _ApplyStorageInfoFunction(storage_unit[0],
                                                     storage_unit[1],
                                                     excl_stor)))

-  hv_info = _GetNamedNodeInfo(hv_names, _GetHvInfo)
-
+  hv_info = _GetHvInfoAll(hv_specs)

   return (bootid, storage_info, hv_info)
 
 
   return (bootid, storage_info, hv_info)
 
 

+# pylint: disable=W0613
+def _GetFileStorageSpaceInfo(path, *args):
+  """Wrapper around filestorage.GetSpaceInfo.
+
+  The purpose of this wrapper is to call filestorage.GetFileStorageSpaceInfo
+  and ignore the *args parameter to not leak it into the filestorage
+  module's code.
+
+  @see: C{filestorage.GetFileStorageSpaceInfo} for description of the
+    parameters.
+
+  """
+  return filestorage.GetFileStorageSpaceInfo(path)
+
+

 # FIXME: implement storage reporting for all missing storage types.
 _STORAGE_TYPE_INFO_FN = {
   constants.ST_BLOCK: None,
   constants.ST_DISKLESS: None,
   constants.ST_EXT: None,
 # FIXME: implement storage reporting for all missing storage types.
 _STORAGE_TYPE_INFO_FN = {
   constants.ST_BLOCK: None,
   constants.ST_DISKLESS: None,
   constants.ST_EXT: None,

-  constants.ST_FILE: None,
+  constants.ST_FILE: _GetFileStorageSpaceInfo,

   constants.ST_LVM_PV: _GetVgSpindlesInfo,
   constants.ST_LVM_VG: _GetVgInfo,
   constants.ST_RADOS: None,
   constants.ST_LVM_PV: _GetVgSpindlesInfo,
   constants.ST_LVM_VG: _GetVgInfo,
   constants.ST_RADOS: None,

@@ -726,7 +764,111 @@ def _CheckExclusivePvs(pvi_list):
   return res
 
 
   return res
 
 

-def VerifyNode(what, cluster_name):
+def _VerifyHypervisors(what, vm_capable, result, all_hvparams,
+                       get_hv_fn=hypervisor.GetHypervisor):
+  """Verifies the hypervisor. Appends the results to the 'results' list.
+
+  @type what: C{dict}
+  @param what: a dictionary of things to check
+  @type vm_capable: boolean
+  @param vm_capable: whether or not this node is vm capable
+  @type result: dict
+  @param result: dictionary of verification results; results of the
+    verifications in this function will be added here
+  @type all_hvparams: dict of dict of string
+  @param all_hvparams: dictionary mapping hypervisor names to hvparams
+  @type get_hv_fn: function
+  @param get_hv_fn: function to retrieve the hypervisor, to improve testability
+
+  """
+  if not vm_capable:
+    return
+
+  if constants.NV_HYPERVISOR in what:
+    result[constants.NV_HYPERVISOR] = {}
+    for hv_name in what[constants.NV_HYPERVISOR]:
+      hvparams = all_hvparams[hv_name]
+      try:
+        val = get_hv_fn(hv_name).Verify(hvparams=hvparams)
+      except errors.HypervisorError, err:
+        val = "Error while checking hypervisor: %s" % str(err)
+      result[constants.NV_HYPERVISOR][hv_name] = val
+
+
+def _VerifyHvparams(what, vm_capable, result,
+                    get_hv_fn=hypervisor.GetHypervisor):
+  """Verifies the hvparams. Appends the results to the 'results' list.
+
+  @type what: C{dict}
+  @param what: a dictionary of things to check
+  @type vm_capable: boolean
+  @param vm_capable: whether or not this node is vm capable
+  @type result: dict
+  @param result: dictionary of verification results; results of the
+    verifications in this function will be added here
+  @type get_hv_fn: function
+  @param get_hv_fn: function to retrieve the hypervisor, to improve testability
+
+  """
+  if not vm_capable:
+    return
+
+  if constants.NV_HVPARAMS in what:
+    result[constants.NV_HVPARAMS] = []
+    for source, hv_name, hvparms in what[constants.NV_HVPARAMS]:
+      try:
+        logging.info("Validating hv %s, %s", hv_name, hvparms)
+        get_hv_fn(hv_name).ValidateParameters(hvparms)
+      except errors.HypervisorError, err:
+        result[constants.NV_HVPARAMS].append((source, hv_name, str(err)))
+
+
+def _VerifyInstanceList(what, vm_capable, result, all_hvparams):
+  """Verifies the instance list.
+
+  @type what: C{dict}
+  @param what: a dictionary of things to check
+  @type vm_capable: boolean
+  @param vm_capable: whether or not this node is vm capable
+  @type result: dict
+  @param result: dictionary of verification results; results of the
+    verifications in this function will be added here
+  @type all_hvparams: dict of dict of string
+  @param all_hvparams: dictionary mapping hypervisor names to hvparams
+
+  """
+  if constants.NV_INSTANCELIST in what and vm_capable:
+    # GetInstanceList can fail
+    try:
+      val = GetInstanceList(what[constants.NV_INSTANCELIST],
+                            all_hvparams=all_hvparams)
+    except RPCFail, err:
+      val = str(err)
+    result[constants.NV_INSTANCELIST] = val
+
+
+def _VerifyNodeInfo(what, vm_capable, result, all_hvparams):
+  """Verifies the node info.
+
+  @type what: C{dict}
+  @param what: a dictionary of things to check
+  @type vm_capable: boolean
+  @param vm_capable: whether or not this node is vm capable
+  @type result: dict
+  @param result: dictionary of verification results; results of the
+    verifications in this function will be added here
+  @type all_hvparams: dict of dict of string
+  @param all_hvparams: dictionary mapping hypervisor names to hvparams
+
+  """
+  if constants.NV_HVINFO in what and vm_capable:
+    hvname = what[constants.NV_HVINFO]
+    hyper = hypervisor.GetHypervisor(hvname)
+    hvparams = all_hvparams[hvname]
+    result[constants.NV_HVINFO] = hyper.GetNodeInfo(hvparams=hvparams)
+
+
+def VerifyNode(what, cluster_name, all_hvparams):

   """Verify the status of the local node.
 
   Based on the input L{what} parameter, various checks are done on the
   """Verify the status of the local node.
 
   Based on the input L{what} parameter, various checks are done on the

@@ -750,6 +892,10 @@ def VerifyNode(what, cluster_name):
       - node-net-test: list of nodes we should check node daemon port
         connectivity with
       - hypervisor: list with hypervisors to run the verify for
       - node-net-test: list of nodes we should check node daemon port
         connectivity with
       - hypervisor: list with hypervisors to run the verify for

+  @type cluster_name: string
+  @param cluster_name: the cluster's name
+  @type all_hvparams: dict of dict of strings
+  @param all_hvparams: a dictionary mapping hypervisor names to hvparams

   @rtype: dict
   @return: a dictionary with the same keys as the input dict, and
       values representing the result of the checks
   @rtype: dict
   @return: a dictionary with the same keys as the input dict, and
       values representing the result of the checks

@@ -760,23 +906,8 @@ def VerifyNode(what, cluster_name):
   port = netutils.GetDaemonPort(constants.NODED)
   vm_capable = my_name not in what.get(constants.NV_VMNODES, [])
 
   port = netutils.GetDaemonPort(constants.NODED)
   vm_capable = my_name not in what.get(constants.NV_VMNODES, [])
 

-  if constants.NV_HYPERVISOR in what and vm_capable:
-    result[constants.NV_HYPERVISOR] = tmp = {}
-    for hv_name in what[constants.NV_HYPERVISOR]:
-      try:
-        val = hypervisor.GetHypervisor(hv_name).Verify()
-      except errors.HypervisorError, err:
-        val = "Error while checking hypervisor: %s" % str(err)
-      tmp[hv_name] = val
-
-  if constants.NV_HVPARAMS in what and vm_capable:
-    result[constants.NV_HVPARAMS] = tmp = []
-    for source, hv_name, hvparms in what[constants.NV_HVPARAMS]:
-      try:
-        logging.info("Validating hv %s, %s", hv_name, hvparms)
-        hypervisor.GetHypervisor(hv_name).ValidateParameters(hvparms)
-      except errors.HypervisorError, err:
-        tmp.append((source, hv_name, str(err)))
+  _VerifyHypervisors(what, vm_capable, result, all_hvparams)
+  _VerifyHvparams(what, vm_capable, result)

 
   if constants.NV_FILELIST in what:
     fingerprints = utils.FingerprintFiles(map(vcluster.LocalizeVirtualPath,
 
   if constants.NV_FILELIST in what:
     fingerprints = utils.FingerprintFiles(map(vcluster.LocalizeVirtualPath,

@@ -868,13 +999,7 @@ def VerifyNode(what, cluster_name):
       val = str(err)
     result[constants.NV_LVLIST] = val
 
       val = str(err)
     result[constants.NV_LVLIST] = val
 

-  if constants.NV_INSTANCELIST in what and vm_capable:
-    # GetInstanceList can fail
-    try:
-      val = GetInstanceList(what[constants.NV_INSTANCELIST])
-    except RPCFail, err:
-      val = str(err)
-    result[constants.NV_INSTANCELIST] = val
+  _VerifyInstanceList(what, vm_capable, result, all_hvparams)

 
   if constants.NV_VGLIST in what and vm_capable:
     result[constants.NV_VGLIST] = utils.ListVolumeGroups()
 
   if constants.NV_VGLIST in what and vm_capable:
     result[constants.NV_VGLIST] = utils.ListVolumeGroups()

@@ -895,9 +1020,7 @@ def VerifyNode(what, cluster_name):
     result[constants.NV_VERSION] = (constants.PROTOCOL_VERSION,
                                     constants.RELEASE_VERSION)
 
     result[constants.NV_VERSION] = (constants.PROTOCOL_VERSION,
                                     constants.RELEASE_VERSION)
 

-  if constants.NV_HVINFO in what and vm_capable:
-    hyper = hypervisor.GetHypervisor(what[constants.NV_HVINFO])
-    result[constants.NV_HVINFO] = hyper.GetNodeInfo()
+  _VerifyNodeInfo(what, vm_capable, result, all_hvparams)

 
   if constants.NV_DRBDVERSION in what and vm_capable:
     try:
 
   if constants.NV_DRBDVERSION in what and vm_capable:
     try:

@@ -1112,11 +1235,47 @@ def BridgesExist(bridges_list):
     _Fail("Missing bridges %s", utils.CommaJoin(missing))
 
 
     _Fail("Missing bridges %s", utils.CommaJoin(missing))
 
 

-def GetInstanceList(hypervisor_list):
+def GetInstanceListForHypervisor(hname, hvparams=None,
+                                 get_hv_fn=hypervisor.GetHypervisor):
+  """Provides a list of instances of the given hypervisor.
+
+  @type hname: string
+  @param hname: name of the hypervisor
+  @type hvparams: dict of strings
+  @param hvparams: hypervisor parameters for the given hypervisor
+  @type get_hv_fn: function
+  @param get_hv_fn: function that returns a hypervisor for the given hypervisor
+    name; optional parameter to increase testability
+
+  @rtype: list
+  @return: a list of all running instances on the current node
+    - instance1.example.com
+    - instance2.example.com
+
+  """
+  results = []
+  try:
+    hv = get_hv_fn(hname)
+    names = hv.ListInstances(hvparams=hvparams)
+    results.extend(names)
+  except errors.HypervisorError, err:
+    _Fail("Error enumerating instances (hypervisor %s): %s",
+          hname, err, exc=True)
+  return results
+
+
+def GetInstanceList(hypervisor_list, all_hvparams=None,
+                    get_hv_fn=hypervisor.GetHypervisor):

   """Provides a list of instances.
 
   @type hypervisor_list: list
   @param hypervisor_list: the list of hypervisors to query information
   """Provides a list of instances.
 
   @type hypervisor_list: list
   @param hypervisor_list: the list of hypervisors to query information

+  @type all_hvparams: dict of dict of strings
+  @param all_hvparams: a dictionary mapping hypervisor types to respective
+    cluster-wide hypervisor parameters
+  @type get_hv_fn: function
+  @param get_hv_fn: function that returns a hypervisor for the given hypervisor
+    name; optional parameter to increase testability

 
   @rtype: list
   @return: a list of all running instances on the current node
 
   @rtype: list
   @return: a list of all running instances on the current node

@@ -1126,23 +1285,21 @@ def GetInstanceList(hypervisor_list):
   """
   results = []
   for hname in hypervisor_list:
   """
   results = []
   for hname in hypervisor_list:

-    try:
-      names = hypervisor.GetHypervisor(hname).ListInstances()
-      results.extend(names)
-    except errors.HypervisorError, err:
-      _Fail("Error enumerating instances (hypervisor %s): %s",
-            hname, err, exc=True)
-
+    hvparams = all_hvparams[hname]
+    results.extend(GetInstanceListForHypervisor(hname, hvparams=hvparams,
+                                                get_hv_fn=get_hv_fn))

   return results
 
 
   return results
 
 

-def GetInstanceInfo(instance, hname):
+def GetInstanceInfo(instance, hname, hvparams=None):

   """Gives back the information about an instance as a dictionary.
 
   @type instance: string
   @param instance: the instance name
   @type hname: string
   @param hname: the hypervisor type of the instance
   """Gives back the information about an instance as a dictionary.
 
   @type instance: string
   @param instance: the instance name
   @type hname: string
   @param hname: the hypervisor type of the instance

+  @type hvparams: dict of strings
+  @param hvparams: the instance's hvparams

 
   @rtype: dict
   @return: dictionary with the following keys:
 
   @rtype: dict
   @return: dictionary with the following keys:

@@ -1154,7 +1311,8 @@ def GetInstanceInfo(instance, hname):
   """
   output = {}
 
   """
   output = {}
 

-  iinfo = hypervisor.GetHypervisor(hname).GetInstanceInfo(instance)
+  iinfo = hypervisor.GetHypervisor(hname).GetInstanceInfo(instance,
+                                                          hvparams=hvparams)

   if iinfo is not None:
     output["memory"] = iinfo[2]
     output["vcpus"] = iinfo[3]
   if iinfo is not None:
     output["memory"] = iinfo[2]
     output["vcpus"] = iinfo[3]

@@ -1165,7 +1323,7 @@ def GetInstanceInfo(instance, hname):
 
 
 def GetInstanceMigratable(instance):
 
 
 def GetInstanceMigratable(instance):

-  """Gives whether an instance can be migrated.
+  """Computes whether an instance can be migrated.

 
   @type instance: L{objects.Instance}
   @param instance: object representing the instance to be checked.
 
   @type instance: L{objects.Instance}
   @param instance: object representing the instance to be checked.

@@ -1178,7 +1336,7 @@ def GetInstanceMigratable(instance):
   """
   hyper = hypervisor.GetHypervisor(instance.hypervisor)
   iname = instance.name
   """
   hyper = hypervisor.GetHypervisor(instance.hypervisor)
   iname = instance.name

-  if iname not in hyper.ListInstances():
+  if iname not in hyper.ListInstances(instance.hvparams):

     _Fail("Instance %s is not running", iname)
 
   for idx in range(len(instance.disks)):
     _Fail("Instance %s is not running", iname)
 
   for idx in range(len(instance.disks)):

@@ -1188,7 +1346,7 @@ def GetInstanceMigratable(instance):
                       iname, link_name, idx)
 
 
                       iname, link_name, idx)
 
 

-def GetAllInstancesInfo(hypervisor_list):
+def GetAllInstancesInfo(hypervisor_list, all_hvparams):

   """Gather data about all instances.
 
   This is the equivalent of L{GetInstanceInfo}, except that it
   """Gather data about all instances.
 
   This is the equivalent of L{GetInstanceInfo}, except that it

@@ -1197,6 +1355,8 @@ def GetAllInstancesInfo(hypervisor_list):
 
   @type hypervisor_list: list
   @param hypervisor_list: list of hypervisors to query for instance data
 
   @type hypervisor_list: list
   @param hypervisor_list: list of hypervisors to query for instance data

+  @type all_hvparams: dict of dict of strings
+  @param all_hvparams: mapping of hypervisor names to hvparams

 
   @rtype: dict
   @return: dictionary of instance: data, with data having the following keys:
 
   @rtype: dict
   @return: dictionary of instance: data, with data having the following keys:

@@ -1209,7 +1369,8 @@ def GetAllInstancesInfo(hypervisor_list):
   output = {}
 
   for hname in hypervisor_list:
   output = {}
 
   for hname in hypervisor_list:

-    iinfo = hypervisor.GetHypervisor(hname).GetAllInstancesInfo()
+    hvparams = all_hvparams[hname]
+    iinfo = hypervisor.GetHypervisor(hname).GetAllInstancesInfo(hvparams)

     if iinfo:
       for name, _, memory, vcpus, state, times in iinfo:
         value = {
     if iinfo:
       for name, _, memory, vcpus, state, times in iinfo:
         value = {

@@ -1421,7 +1582,8 @@ def StartInstance(instance, startup_paused, reason, store_reason=True):
   @rtype: None
 
   """
   @rtype: None
 
   """

-  running_instances = GetInstanceList([instance.hypervisor])
+  running_instances = GetInstanceListForHypervisor(instance.hypervisor,
+                                                   instance.hvparams)

 
   if instance.name in running_instances:
     logging.info("Instance %s already running, not starting", instance.name)
 
   if instance.name in running_instances:
     logging.info("Instance %s already running, not starting", instance.name)

@@ -1460,7 +1622,7 @@ def InstanceShutdown(instance, timeout, reason, store_reason=True):
   hyper = hypervisor.GetHypervisor(hv_name)
   iname = instance.name
 
   hyper = hypervisor.GetHypervisor(hv_name)
   iname = instance.name
 

-  if instance.name not in hyper.ListInstances():
+  if instance.name not in hyper.ListInstances(instance.hvparams):

     logging.info("Instance %s not running, doing nothing", iname)
     return
 
     logging.info("Instance %s not running, doing nothing", iname)
     return
 

@@ -1469,7 +1631,7 @@ def InstanceShutdown(instance, timeout, reason, store_reason=True):
       self.tried_once = False
 
     def __call__(self):
       self.tried_once = False
 
     def __call__(self):

-      if iname not in hyper.ListInstances():
+      if iname not in hyper.ListInstances(instance.hvparams):

         return
 
       try:
         return
 
       try:

@@ -1477,7 +1639,7 @@ def InstanceShutdown(instance, timeout, reason, store_reason=True):
         if store_reason:
           _StoreInstReasonTrail(instance.name, reason)
       except errors.HypervisorError, err:
         if store_reason:
           _StoreInstReasonTrail(instance.name, reason)
       except errors.HypervisorError, err:

-        if iname not in hyper.ListInstances():
+        if iname not in hyper.ListInstances(instance.hvparams):

           # if the instance is no longer existing, consider this a
           # success and go to cleanup
           return
           # if the instance is no longer existing, consider this a
           # success and go to cleanup
           return

@@ -1497,14 +1659,14 @@ def InstanceShutdown(instance, timeout, reason, store_reason=True):
     try:
       hyper.StopInstance(instance, force=True)
     except errors.HypervisorError, err:
     try:
       hyper.StopInstance(instance, force=True)
     except errors.HypervisorError, err:

-      if iname in hyper.ListInstances():
+      if iname in hyper.ListInstances(instance.hvparams):

         # only raise an error if the instance still exists, otherwise
         # the error could simply be "instance ... unknown"!
         _Fail("Failed to force stop instance %s: %s", iname, err)
 
     time.sleep(1)
 
         # only raise an error if the instance still exists, otherwise
         # the error could simply be "instance ... unknown"!
         _Fail("Failed to force stop instance %s: %s", iname, err)
 
     time.sleep(1)
 

-    if iname in hyper.ListInstances():
+    if iname in hyper.ListInstances(instance.hvparams):

       _Fail("Could not shutdown instance %s even by destroy", iname)
 
   try:
       _Fail("Could not shutdown instance %s even by destroy", iname)
 
   try:

@@ -1538,7 +1700,8 @@ def InstanceReboot(instance, reboot_type, shutdown_timeout, reason):
   @rtype: None
 
   """
   @rtype: None
 
   """

-  running_instances = GetInstanceList([instance.hypervisor])
+  running_instances = GetInstanceListForHypervisor(instance.hypervisor,
+                                                   instance.hvparams)

 
   if instance.name not in running_instances:
     _Fail("Cannot reboot instance %s that is not running", instance.name)
 
   if instance.name not in running_instances:
     _Fail("Cannot reboot instance %s that is not running", instance.name)

@@ -1572,7 +1735,7 @@ def InstanceBalloonMemory(instance, memory):
 
   """
   hyper = hypervisor.GetHypervisor(instance.hypervisor)
 
   """
   hyper = hypervisor.GetHypervisor(instance.hypervisor)

-  running = hyper.ListInstances()
+  running = hyper.ListInstances(instance.hvparams)

   if instance.name not in running:
     logging.info("Instance %s is not running, cannot balloon", instance.name)
     return
   if instance.name not in running:
     logging.info("Instance %s is not running, cannot balloon", instance.name)
     return

@@ -1644,9 +1807,11 @@ def FinalizeMigrationDst(instance, info, success):
     _Fail("Failed to finalize migration on the target node: %s", err, exc=True)
 
 
     _Fail("Failed to finalize migration on the target node: %s", err, exc=True)
 
 

-def MigrateInstance(instance, target, live):
+def MigrateInstance(cluster_name, instance, target, live):

   """Migrates an instance to another node.
 
   """Migrates an instance to another node.
 

+  @type cluster_name: string
+  @param cluster_name: name of the cluster

   @type instance: L{objects.Instance}
   @param instance: the instance definition
   @type target: string
   @type instance: L{objects.Instance}
   @param instance: the instance definition
   @type target: string

@@ -1660,7 +1825,7 @@ def MigrateInstance(instance, target, live):
   hyper = hypervisor.GetHypervisor(instance.hypervisor)
 
   try:
   hyper = hypervisor.GetHypervisor(instance.hypervisor)
 
   try:

-    hyper.MigrateInstance(instance, target, live)
+    hyper.MigrateInstance(cluster_name, instance, target, live)

   except errors.HypervisorError, err:
     _Fail("Failed to migrate instance: %s", err, exc=True)
 
   except errors.HypervisorError, err:
     _Fail("Failed to migrate instance: %s", err, exc=True)
 

@@ -2603,6 +2768,9 @@ def OSEnvironment(instance, inst_os, debug=0):
     real_disk = _OpenRealBD(disk)
     result["DISK_%d_PATH" % idx] = real_disk.dev_path
     result["DISK_%d_ACCESS" % idx] = disk.mode
     real_disk = _OpenRealBD(disk)
     result["DISK_%d_PATH" % idx] = real_disk.dev_path
     result["DISK_%d_ACCESS" % idx] = disk.mode

+    result["DISK_%d_UUID" % idx] = disk.uuid
+    if disk.name:
+      result["DISK_%d_NAME" % idx] = disk.name

     if constants.HV_DISK_TYPE in instance.hvparams:
       result["DISK_%d_FRONTEND_TYPE" % idx] = \
         instance.hvparams[constants.HV_DISK_TYPE]
     if constants.HV_DISK_TYPE in instance.hvparams:
       result["DISK_%d_FRONTEND_TYPE" % idx] = \
         instance.hvparams[constants.HV_DISK_TYPE]

@@ -2615,6 +2783,9 @@ def OSEnvironment(instance, inst_os, debug=0):
   # NICs
   for idx, nic in enumerate(instance.nics):
     result["NIC_%d_MAC" % idx] = nic.mac
   # NICs
   for idx, nic in enumerate(instance.nics):
     result["NIC_%d_MAC" % idx] = nic.mac

+    result["NIC_%d_UUID" % idx] = nic.uuid
+    if nic.name:
+      result["NIC_%d_NAME" % idx] = nic.name

     if nic.ip:
       result["NIC_%d_IP" % idx] = nic.ip
     result["NIC_%d_MODE" % idx] = nic.nicparams[constants.NIC_MODE]
     if nic.ip:
       result["NIC_%d_IP" % idx] = nic.ip
     result["NIC_%d_MODE" % idx] = nic.nicparams[constants.NIC_MODE]

@@ -3630,14 +3801,13 @@ def CleanupImportExport(name):
   shutil.rmtree(status_dir, ignore_errors=True)
 
 
   shutil.rmtree(status_dir, ignore_errors=True)
 
 

-def _FindDisks(nodes_ip, disks):
+def _FindDisks(target_node_uuid, nodes_ip, disks):

   """Sets the physical ID on disks and returns the block devices.
 
   """
   # set the correct physical ID
   """Sets the physical ID on disks and returns the block devices.
 
   """
   # set the correct physical ID

-  my_name = netutils.Hostname.GetSysName()

   for cf in disks:
   for cf in disks:

-    cf.SetPhysicalID(my_name, nodes_ip)
+    cf.SetPhysicalID(target_node_uuid, nodes_ip)

 
   bdevs = []
 
 
   bdevs = []
 

@@ -3649,11 +3819,11 @@ def _FindDisks(nodes_ip, disks):
   return bdevs
 
 
   return bdevs
 
 

-def DrbdDisconnectNet(nodes_ip, disks):
+def DrbdDisconnectNet(target_node_uuid, nodes_ip, disks):

   """Disconnects the network on a list of drbd devices.
 
   """
   """Disconnects the network on a list of drbd devices.
 
   """

-  bdevs = _FindDisks(nodes_ip, disks)
+  bdevs = _FindDisks(target_node_uuid, nodes_ip, disks)

 
   # disconnect disks
   for rd in bdevs:
 
   # disconnect disks
   for rd in bdevs:

@@ -3664,11 +3834,12 @@ def DrbdDisconnectNet(nodes_ip, disks):
             err, exc=True)
 
 
             err, exc=True)
 
 

-def DrbdAttachNet(nodes_ip, disks, instance_name, multimaster):
+def DrbdAttachNet(target_node_uuid, nodes_ip, disks, instance_name,
+                  multimaster):

   """Attaches the network on a list of drbd devices.
 
   """
   """Attaches the network on a list of drbd devices.
 
   """

-  bdevs = _FindDisks(nodes_ip, disks)
+  bdevs = _FindDisks(target_node_uuid, nodes_ip, disks)

 
   if multimaster:
     for idx, rd in enumerate(bdevs):
 
   if multimaster:
     for idx, rd in enumerate(bdevs):

@@ -3726,7 +3897,7 @@ def DrbdAttachNet(nodes_ip, disks, instance_name, multimaster):
         _Fail("Can't change to primary mode: %s", err)
 
 
         _Fail("Can't change to primary mode: %s", err)
 
 

-def DrbdWaitSync(nodes_ip, disks):
+def DrbdWaitSync(target_node_uuid, nodes_ip, disks):

   """Wait until DRBDs have synchronized.
 
   """
   """Wait until DRBDs have synchronized.
 
   """

@@ -3736,7 +3907,7 @@ def DrbdWaitSync(nodes_ip, disks):
       raise utils.RetryAgain()
     return stats
 
       raise utils.RetryAgain()
     return stats
 

-  bdevs = _FindDisks(nodes_ip, disks)
+  bdevs = _FindDisks(target_node_uuid, nodes_ip, disks)

 
   min_resync = 100
   alldone = True
 
   min_resync = 100
   alldone = True

@@ -3766,7 +3937,7 @@ def GetDrbdUsermodeHelper():
     _Fail(str(err))
 
 
     _Fail(str(err))
 
 

-def PowercycleNode(hypervisor_type):
+def PowercycleNode(hypervisor_type, hvparams=None):

   """Hard-powercycle the node.
 
   Because we need to return first, and schedule the powercycle in the
   """Hard-powercycle the node.
 
   Because we need to return first, and schedule the powercycle in the

@@ -3787,7 +3958,7 @@ def PowercycleNode(hypervisor_type):
   except Exception: # pylint: disable=W0703
     pass
   time.sleep(5)
   except Exception: # pylint: disable=W0703
     pass
   time.sleep(5)

-  hyper.PowercycleNode()
+  hyper.PowercycleNode(hvparams=hvparams)

 
 
 def _VerifyRestrictedCmdName(cmd):
 
 
 def _VerifyRestrictedCmdName(cmd):