code.grnet.gr Git - ganeti-local/blob - lib/hypervisor/hv_base.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2009, 2010 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """Base class for all hypervisors
  23
  24 The syntax for the _CHECK variables and the contents of the PARAMETERS
  25 dict is the same, see the docstring for L{BaseHypervisor.PARAMETERS}.
  26
  27 @var _FILE_CHECK: stub for file checks, without the required flag
  28 @var _DIR_CHECK: stub for directory checks, without the required flag
  29 @var REQ_FILE_CHECK: mandatory file parameter
  30 @var OPT_FILE_CHECK: optional file parameter
  31 @var REQ_DIR_CHECK: mandatory directory parametr
  32 @var OPT_DIR_CHECK: optional directory parameter
  33 @var NO_CHECK: parameter without any checks at all
  34 @var REQUIRED_CHECK: parameter required to exist (and non-false), but
  35     without other checks; beware that this can't be used for boolean
  36     parameters, where you should use NO_CHECK or a custom checker
  37
  38 """
  39
  40 import os
  41 import re
  42 import logging
  43
  44
  45 from ganeti import errors
  46 from ganeti import utils
  47 from ganeti import constants
  48
  49
  50 def _IsCpuMaskWellFormed(cpu_mask):
  51   try:
  52     cpu_list = utils.ParseCpuMask(cpu_mask)
  53   except errors.ParseError, _:
  54     return False
  55   return isinstance(cpu_list, list) and len(cpu_list) > 0
  56
  57
  58 # Read the BaseHypervisor.PARAMETERS docstring for the syntax of the
  59 # _CHECK values
  60
  61 # must be afile
  62 _FILE_CHECK = (utils.IsNormAbsPath, "must be an absolute normalized path",
  63               os.path.isfile, "not found or not a file")
  64
  65 # must be a directory
  66 _DIR_CHECK = (utils.IsNormAbsPath, "must be an absolute normalized path",
  67              os.path.isdir, "not found or not a directory")
  68
  69 # CPU mask must be well-formed
  70 # TODO: implement node level check for the CPU mask
  71 _CPU_MASK_CHECK = (_IsCpuMaskWellFormed,
  72                    "CPU mask definition is not well-formed",
  73                    None, None)
  74
  75 # Check for validity of port number
  76 _NET_PORT_CHECK = (lambda x: 0 < x < 65535, "invalid port number",
  77                    None, None)
  78
  79 # nice wrappers for users
  80 REQ_FILE_CHECK = (True, ) + _FILE_CHECK
  81 OPT_FILE_CHECK = (False, ) + _FILE_CHECK
  82 REQ_DIR_CHECK = (True, ) + _DIR_CHECK
  83 OPT_DIR_CHECK = (False, ) + _DIR_CHECK
  84 REQ_NET_PORT_CHECK = (True, ) + _NET_PORT_CHECK
  85 OPT_NET_PORT_CHECK = (False, ) + _NET_PORT_CHECK
  86 REQ_CPU_MASK_CHECK = (True, ) + _CPU_MASK_CHECK
  87 OPT_CPU_MASK_CHECK = (False, ) + _CPU_MASK_CHECK
  88
  89 # no checks at all
  90 NO_CHECK = (False, None, None, None, None)
  91
  92 # required, but no other checks
  93 REQUIRED_CHECK = (True, None, None, None, None)
  94
  95 # migration type
  96 MIGRATION_MODE_CHECK = (True, lambda x: x in constants.HT_MIGRATION_MODES,
  97                         "invalid migration mode", None, None)
  98
  99
 100 def ParamInSet(required, my_set):
 101   """Builds parameter checker for set membership.
 102
 103   @type required: boolean
 104   @param required: whether this is a required parameter
 105   @type my_set: tuple, list or set
 106   @param my_set: allowed values set
 107
 108   """
 109   fn = lambda x: x in my_set
 110   err = ("The value must be one of: %s" % utils.CommaJoin(my_set))
 111   return (required, fn, err, None, None)
 112
 113
 114 class BaseHypervisor(object):
 115   """Abstract virtualisation technology interface
 116
 117   The goal is that all aspects of the virtualisation technology are
 118   abstracted away from the rest of code.
 119
 120   @cvar PARAMETERS: a dict of parameter name: check type; the check type is
 121       a five-tuple containing:
 122           - the required flag (boolean)
 123           - a function to check for syntax, that will be used in
 124             L{CheckParameterSyntax}, in the master daemon process
 125           - an error message for the above function
 126           - a function to check for parameter validity on the remote node,
 127             in the L{ValidateParameters} function
 128           - an error message for the above function
 129   @type CAN_MIGRATE: boolean
 130   @cvar CAN_MIGRATE: whether this hypervisor can do migration (either
 131       live or non-live)
 132
 133   """
 134   PARAMETERS = {}
 135   ANCILLARY_FILES = []
 136   ANCILLARY_FILES_OPT = []
 137   CAN_MIGRATE = False
 138
 139   def __init__(self):
 140     pass
 141
 142   def StartInstance(self, instance, block_devices, startup_paused):
 143     """Start an instance."""
 144     raise NotImplementedError
 145
 146   def StopInstance(self, instance, force=False, retry=False, name=None):
 147     """Stop an instance
 148
 149     @type instance: L{objects.Instance}
 150     @param instance: instance to stop
 151     @type force: boolean
 152     @param force: whether to do a "hard" stop (destroy)
 153     @type retry: boolean
 154     @param retry: whether this is just a retry call
 155     @type name: string or None
 156     @param name: if this parameter is passed, the the instance object
 157         should not be used (will be passed as None), and the shutdown
 158         must be done by name only
 159
 160     """
 161     raise NotImplementedError
 162
 163   def CleanupInstance(self, instance_name):
 164     """Cleanup after a stopped instance
 165
 166     This is an optional method, used by hypervisors that need to cleanup after
 167     an instance has been stopped.
 168
 169     @type instance_name: string
 170     @param instance_name: instance name to cleanup after
 171
 172     """
 173     pass
 174
 175   def RebootInstance(self, instance):
 176     """Reboot an instance."""
 177     raise NotImplementedError
 178
 179   def ListInstances(self):
 180     """Get the list of running instances."""
 181     raise NotImplementedError
 182
 183   def GetInstanceInfo(self, instance_name):
 184     """Get instance properties.
 185
 186     @type instance_name: string
 187     @param instance_name: the instance name
 188
 189     @return: tuple (name, id, memory, vcpus, state, times)
 190
 191     """
 192     raise NotImplementedError
 193
 194   def GetAllInstancesInfo(self):
 195     """Get properties of all instances.
 196
 197     @return: list of tuples (name, id, memory, vcpus, stat, times)
 198
 199     """
 200     raise NotImplementedError
 201
 202   def GetNodeInfo(self):
 203     """Return information about the node.
 204
 205     @return: a dict with the following keys (values in MiB):
 206           - memory_total: the total memory size on the node
 207           - memory_free: the available memory on the node for instances
 208           - memory_dom0: the memory used by the node itself, if available
 209
 210     """
 211     raise NotImplementedError
 212
 213   @classmethod
 214   def GetInstanceConsole(cls, instance, hvparams, beparams):
 215     """Return information for connecting to the console of an instance.
 216
 217     """
 218     raise NotImplementedError
 219
 220   @classmethod
 221   def GetAncillaryFiles(cls):
 222     """Return a list of ancillary files to be copied to all nodes as ancillary
 223     configuration files.
 224
 225     @rtype: (list of absolute paths, list of absolute paths)
 226     @return: (all files, optional files)
 227
 228     """
 229     # By default we return a member variable, so that if an hypervisor has just
 230     # a static list of files it doesn't have to override this function.
 231     assert set(cls.ANCILLARY_FILES).issuperset(cls.ANCILLARY_FILES_OPT), \
 232       "Optional ancillary files must be a subset of ancillary files"
 233
 234     return (cls.ANCILLARY_FILES, cls.ANCILLARY_FILES_OPT)
 235
 236   def Verify(self):
 237     """Verify the hypervisor.
 238
 239     """
 240     raise NotImplementedError
 241
 242   def MigrationInfo(self, instance): # pylint: disable=R0201,W0613
 243     """Get instance information to perform a migration.
 244
 245     By default assume no information is needed.
 246
 247     @type instance: L{objects.Instance}
 248     @param instance: instance to be migrated
 249     @rtype: string/data (opaque)
 250     @return: instance migration information - serialized form
 251
 252     """
 253     return ""
 254
 255   def AcceptInstance(self, instance, info, target):
 256     """Prepare to accept an instance.
 257
 258     By default assume no preparation is needed.
 259
 260     @type instance: L{objects.Instance}
 261     @param instance: instance to be accepted
 262     @type info: string/data (opaque)
 263     @param info: migration information, from the source node
 264     @type target: string
 265     @param target: target host (usually ip), on this node
 266
 267     """
 268     pass
 269
 270   def FinalizeMigration(self, instance, info, success):
 271     """Finalized an instance migration.
 272
 273     Should finalize or revert any preparation done to accept the instance.
 274     Since by default we do no preparation, we also don't have anything to do
 275
 276     @type instance: L{objects.Instance}
 277     @param instance: instance whose migration is being finalized
 278     @type info: string/data (opaque)
 279     @param info: migration information, from the source node
 280     @type success: boolean
 281     @param success: whether the migration was a success or a failure
 282
 283     """
 284     pass
 285
 286   def MigrateInstance(self, instance, target, live):
 287     """Migrate an instance.
 288
 289     @type instance: L{objects.Instance}
 290     @param instance: the instance to be migrated
 291     @type target: string
 292     @param target: hostname (usually ip) of the target node
 293     @type live: boolean
 294     @param live: whether to do a live or non-live migration
 295
 296     """
 297     raise NotImplementedError
 298
 299   @classmethod
 300   def CheckParameterSyntax(cls, hvparams):
 301     """Check the given parameters for validity.
 302
 303     This should check the passed set of parameters for
 304     validity. Classes should extend, not replace, this function.
 305
 306     @type hvparams:  dict
 307     @param hvparams: dictionary with parameter names/value
 308     @raise errors.HypervisorError: when a parameter is not valid
 309
 310     """
 311     for key in hvparams:
 312       if key not in cls.PARAMETERS:
 313         raise errors.HypervisorError("Parameter '%s' is not supported" % key)
 314
 315     # cheap tests that run on the master, should not access the world
 316     for name, (required, check_fn, errstr, _, _) in cls.PARAMETERS.items():
 317       if name not in hvparams:
 318         raise errors.HypervisorError("Parameter '%s' is missing" % name)
 319       value = hvparams[name]
 320       if not required and not value:
 321         continue
 322       if not value:
 323         raise errors.HypervisorError("Parameter '%s' is required but"
 324                                      " is currently not defined" % (name, ))
 325       if check_fn is not None and not check_fn(value):
 326         raise errors.HypervisorError("Parameter '%s' fails syntax"
 327                                      " check: %s (current value: '%s')" %
 328                                      (name, errstr, value))
 329
 330   @classmethod
 331   def ValidateParameters(cls, hvparams):
 332     """Check the given parameters for validity.
 333
 334     This should check the passed set of parameters for
 335     validity. Classes should extend, not replace, this function.
 336
 337     @type hvparams:  dict
 338     @param hvparams: dictionary with parameter names/value
 339     @raise errors.HypervisorError: when a parameter is not valid
 340
 341     """
 342     for name, (required, _, _, check_fn, errstr) in cls.PARAMETERS.items():
 343       value = hvparams[name]
 344       if not required and not value:
 345         continue
 346       if check_fn is not None and not check_fn(value):
 347         raise errors.HypervisorError("Parameter '%s' fails"
 348                                      " validation: %s (current value: '%s')" %
 349                                      (name, errstr, value))
 350
 351   @classmethod
 352   def PowercycleNode(cls):
 353     """Hard powercycle a node using hypervisor specific methods.
 354
 355     This method should hard powercycle the node, using whatever
 356     methods the hypervisor provides. Note that this means that all
 357     instances running on the node must be stopped too.
 358
 359     """
 360     raise NotImplementedError
 361
 362   @staticmethod
 363   def GetLinuxNodeInfo():
 364     """For linux systems, return actual OS information.
 365
 366     This is an abstraction for all non-hypervisor-based classes, where
 367     the node actually sees all the memory and CPUs via the /proc
 368     interface and standard commands. The other case if for example
 369     xen, where you only see the hardware resources via xen-specific
 370     tools.
 371
 372     @return: a dict with the following keys (values in MiB):
 373           - memory_total: the total memory size on the node
 374           - memory_free: the available memory on the node for instances
 375           - memory_dom0: the memory used by the node itself, if available
 376
 377     """
 378     try:
 379       data = utils.ReadFile("/proc/meminfo").splitlines()
 380     except EnvironmentError, err:
 381       raise errors.HypervisorError("Failed to list node info: %s" % (err,))
 382
 383     result = {}
 384     sum_free = 0
 385     try:
 386       for line in data:
 387         splitfields = line.split(":", 1)
 388
 389         if len(splitfields) > 1:
 390           key = splitfields[0].strip()
 391           val = splitfields[1].strip()
 392           if key == "MemTotal":
 393             result["memory_total"] = int(val.split()[0]) / 1024
 394           elif key in ("MemFree", "Buffers", "Cached"):
 395             sum_free += int(val.split()[0]) / 1024
 396           elif key == "Active":
 397             result["memory_dom0"] = int(val.split()[0]) / 1024
 398     except (ValueError, TypeError), err:
 399       raise errors.HypervisorError("Failed to compute memory usage: %s" %
 400                                    (err,))
 401     result["memory_free"] = sum_free
 402
 403     cpu_total = 0
 404     try:
 405       fh = open("/proc/cpuinfo")
 406       try:
 407         cpu_total = len(re.findall("(?m)^processor\s*:\s*[0-9]+\s*$",
 408                                    fh.read()))
 409       finally:
 410         fh.close()
 411     except EnvironmentError, err:
 412       raise errors.HypervisorError("Failed to list node info: %s" % (err,))
 413     result["cpu_total"] = cpu_total
 414     # FIXME: export correct data here
 415     result["cpu_nodes"] = 1
 416     result["cpu_sockets"] = 1
 417
 418     return result
 419
 420   @classmethod
 421   def LinuxPowercycle(cls):
 422     """Linux-specific powercycle method.
 423
 424     """
 425     try:
 426       fd = os.open("/proc/sysrq-trigger", os.O_WRONLY)
 427       try:
 428         os.write(fd, "b")
 429       finally:
 430         fd.close()
 431     except OSError:
 432       logging.exception("Can't open the sysrq-trigger file")
 433       result = utils.RunCmd(["reboot", "-n", "-f"])
 434       if not result:
 435         logging.error("Can't run shutdown: %s", result.output)