4 # Copyright (C) 2006, 2007, 2008, 2009, 2010 Google Inc.
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.
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.
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
22 """Base class for all hypervisors
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}.
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
45 from ganeti import errors
46 from ganeti import utils
47 from ganeti import constants
50 def _IsCpuMaskWellFormed(cpu_mask):
51 """Verifies if the given single CPU mask is valid
53 The single CPU mask should be in the form "a,b,c,d", where each
54 letter is a positive number or range.
58 cpu_list = utils.ParseCpuMask(cpu_mask)
59 except errors.ParseError, _:
61 return isinstance(cpu_list, list) and len(cpu_list) > 0
64 def _IsMultiCpuMaskWellFormed(cpu_mask):
65 """Verifies if the given multiple CPU mask is valid
67 A valid multiple CPU mask is in the form "a:b:c:d", where each
68 letter is a single CPU mask.
72 utils.ParseMultiCpuMask(cpu_mask)
73 except errors.ParseError, _:
79 # Read the BaseHypervisor.PARAMETERS docstring for the syntax of the
83 _FILE_CHECK = (utils.IsNormAbsPath, "must be an absolute normalized path",
84 os.path.isfile, "not found or not a file")
87 _DIR_CHECK = (utils.IsNormAbsPath, "must be an absolute normalized path",
88 os.path.isdir, "not found or not a directory")
90 # CPU mask must be well-formed
91 # TODO: implement node level check for the CPU mask
92 _CPU_MASK_CHECK = (_IsCpuMaskWellFormed,
93 "CPU mask definition is not well-formed",
96 # Multiple CPU mask must be well-formed
97 _MULTI_CPU_MASK_CHECK = (_IsMultiCpuMaskWellFormed,
98 "Multiple CPU mask definition is not well-formed",
101 # Check for validity of port number
102 _NET_PORT_CHECK = (lambda x: 0 < x < 65535, "invalid port number",
105 # nice wrappers for users
106 REQ_FILE_CHECK = (True, ) + _FILE_CHECK
107 OPT_FILE_CHECK = (False, ) + _FILE_CHECK
108 REQ_DIR_CHECK = (True, ) + _DIR_CHECK
109 OPT_DIR_CHECK = (False, ) + _DIR_CHECK
110 REQ_NET_PORT_CHECK = (True, ) + _NET_PORT_CHECK
111 OPT_NET_PORT_CHECK = (False, ) + _NET_PORT_CHECK
112 REQ_CPU_MASK_CHECK = (True, ) + _CPU_MASK_CHECK
113 OPT_CPU_MASK_CHECK = (False, ) + _CPU_MASK_CHECK
114 REQ_MULTI_CPU_MASK_CHECK = (True, ) + _MULTI_CPU_MASK_CHECK
115 OPT_MULTI_CPU_MASK_CHECK = (False, ) + _MULTI_CPU_MASK_CHECK
118 NO_CHECK = (False, None, None, None, None)
120 # required, but no other checks
121 REQUIRED_CHECK = (True, None, None, None, None)
124 MIGRATION_MODE_CHECK = (True, lambda x: x in constants.HT_MIGRATION_MODES,
125 "invalid migration mode", None, None)
128 def ParamInSet(required, my_set):
129 """Builds parameter checker for set membership.
131 @type required: boolean
132 @param required: whether this is a required parameter
133 @type my_set: tuple, list or set
134 @param my_set: allowed values set
137 fn = lambda x: x in my_set
138 err = ("The value must be one of: %s" % utils.CommaJoin(my_set))
139 return (required, fn, err, None, None)
142 class BaseHypervisor(object):
143 """Abstract virtualisation technology interface
145 The goal is that all aspects of the virtualisation technology are
146 abstracted away from the rest of code.
148 @cvar PARAMETERS: a dict of parameter name: check type; the check type is
149 a five-tuple containing:
150 - the required flag (boolean)
151 - a function to check for syntax, that will be used in
152 L{CheckParameterSyntax}, in the master daemon process
153 - an error message for the above function
154 - a function to check for parameter validity on the remote node,
155 in the L{ValidateParameters} function
156 - an error message for the above function
157 @type CAN_MIGRATE: boolean
158 @cvar CAN_MIGRATE: whether this hypervisor can do migration (either
164 ANCILLARY_FILES_OPT = []
170 def StartInstance(self, instance, block_devices, startup_paused):
171 """Start an instance."""
172 raise NotImplementedError
174 def StopInstance(self, instance, force=False, retry=False, name=None):
177 @type instance: L{objects.Instance}
178 @param instance: instance to stop
180 @param force: whether to do a "hard" stop (destroy)
182 @param retry: whether this is just a retry call
183 @type name: string or None
184 @param name: if this parameter is passed, the the instance object
185 should not be used (will be passed as None), and the shutdown
186 must be done by name only
189 raise NotImplementedError
191 def CleanupInstance(self, instance_name):
192 """Cleanup after a stopped instance
194 This is an optional method, used by hypervisors that need to cleanup after
195 an instance has been stopped.
197 @type instance_name: string
198 @param instance_name: instance name to cleanup after
203 def RebootInstance(self, instance):
204 """Reboot an instance."""
205 raise NotImplementedError
207 def ListInstances(self):
208 """Get the list of running instances."""
209 raise NotImplementedError
211 def GetInstanceInfo(self, instance_name):
212 """Get instance properties.
214 @type instance_name: string
215 @param instance_name: the instance name
217 @return: tuple (name, id, memory, vcpus, state, times)
220 raise NotImplementedError
222 def GetAllInstancesInfo(self):
223 """Get properties of all instances.
225 @return: list of tuples (name, id, memory, vcpus, stat, times)
228 raise NotImplementedError
230 def GetNodeInfo(self):
231 """Return information about the node.
233 @return: a dict with the following keys (values in MiB):
234 - memory_total: the total memory size on the node
235 - memory_free: the available memory on the node for instances
236 - memory_dom0: the memory used by the node itself, if available
239 raise NotImplementedError
242 def GetInstanceConsole(cls, instance, hvparams, beparams):
243 """Return information for connecting to the console of an instance.
246 raise NotImplementedError
249 def GetAncillaryFiles(cls):
250 """Return a list of ancillary files to be copied to all nodes as ancillary
253 @rtype: (list of absolute paths, list of absolute paths)
254 @return: (all files, optional files)
257 # By default we return a member variable, so that if an hypervisor has just
258 # a static list of files it doesn't have to override this function.
259 assert set(cls.ANCILLARY_FILES).issuperset(cls.ANCILLARY_FILES_OPT), \
260 "Optional ancillary files must be a subset of ancillary files"
262 return (cls.ANCILLARY_FILES, cls.ANCILLARY_FILES_OPT)
265 """Verify the hypervisor.
268 raise NotImplementedError
270 def MigrationInfo(self, instance): # pylint: disable=R0201,W0613
271 """Get instance information to perform a migration.
273 By default assume no information is needed.
275 @type instance: L{objects.Instance}
276 @param instance: instance to be migrated
277 @rtype: string/data (opaque)
278 @return: instance migration information - serialized form
283 def AcceptInstance(self, instance, info, target):
284 """Prepare to accept an instance.
286 By default assume no preparation is needed.
288 @type instance: L{objects.Instance}
289 @param instance: instance to be accepted
290 @type info: string/data (opaque)
291 @param info: migration information, from the source node
293 @param target: target host (usually ip), on this node
298 def FinalizeMigrationDst(self, instance, info, success):
299 """Finalize the instance migration on the target node.
301 Should finalize or revert any preparation done to accept the instance.
302 Since by default we do no preparation, we also don't have anything to do
304 @type instance: L{objects.Instance}
305 @param instance: instance whose migration is being finalized
306 @type info: string/data (opaque)
307 @param info: migration information, from the source node
308 @type success: boolean
309 @param success: whether the migration was a success or a failure
314 def MigrateInstance(self, instance, target, live):
315 """Migrate an instance.
317 @type instance: L{objects.Instance}
318 @param instance: the instance to be migrated
320 @param target: hostname (usually ip) of the target node
322 @param live: whether to do a live or non-live migration
325 raise NotImplementedError
327 def FinalizeMigrationSource(self, instance, success, live):
328 """Finalize the instance migration on the source node.
330 @type instance: L{objects.Instance}
331 @param instance: the instance that was migrated
333 @param success: whether the migration succeeded or not
335 @param live: whether the user requested a live migration or not
340 def GetMigrationStatus(self, instance):
341 """Get the migration status
343 @type instance: L{objects.Instance}
344 @param instance: the instance that is being migrated
345 @rtype: L{objects.MigrationStatus}
346 @return: the status of the current migration (one of
347 L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
348 progress info that can be retrieved from the hypervisor
351 raise NotImplementedError
354 def CheckParameterSyntax(cls, hvparams):
355 """Check the given parameters for validity.
357 This should check the passed set of parameters for
358 validity. Classes should extend, not replace, this function.
361 @param hvparams: dictionary with parameter names/value
362 @raise errors.HypervisorError: when a parameter is not valid
366 if key not in cls.PARAMETERS:
367 raise errors.HypervisorError("Parameter '%s' is not supported" % key)
369 # cheap tests that run on the master, should not access the world
370 for name, (required, check_fn, errstr, _, _) in cls.PARAMETERS.items():
371 if name not in hvparams:
372 raise errors.HypervisorError("Parameter '%s' is missing" % name)
373 value = hvparams[name]
374 if not required and not value:
377 raise errors.HypervisorError("Parameter '%s' is required but"
378 " is currently not defined" % (name, ))
379 if check_fn is not None and not check_fn(value):
380 raise errors.HypervisorError("Parameter '%s' fails syntax"
381 " check: %s (current value: '%s')" %
382 (name, errstr, value))
385 def ValidateParameters(cls, hvparams):
386 """Check the given parameters for validity.
388 This should check the passed set of parameters for
389 validity. Classes should extend, not replace, this function.
392 @param hvparams: dictionary with parameter names/value
393 @raise errors.HypervisorError: when a parameter is not valid
396 for name, (required, _, _, check_fn, errstr) in cls.PARAMETERS.items():
397 value = hvparams[name]
398 if not required and not value:
400 if check_fn is not None and not check_fn(value):
401 raise errors.HypervisorError("Parameter '%s' fails"
402 " validation: %s (current value: '%s')" %
403 (name, errstr, value))
406 def PowercycleNode(cls):
407 """Hard powercycle a node using hypervisor specific methods.
409 This method should hard powercycle the node, using whatever
410 methods the hypervisor provides. Note that this means that all
411 instances running on the node must be stopped too.
414 raise NotImplementedError
417 def GetLinuxNodeInfo():
418 """For linux systems, return actual OS information.
420 This is an abstraction for all non-hypervisor-based classes, where
421 the node actually sees all the memory and CPUs via the /proc
422 interface and standard commands. The other case if for example
423 xen, where you only see the hardware resources via xen-specific
426 @return: a dict with the following keys (values in MiB):
427 - memory_total: the total memory size on the node
428 - memory_free: the available memory on the node for instances
429 - memory_dom0: the memory used by the node itself, if available
433 data = utils.ReadFile("/proc/meminfo").splitlines()
434 except EnvironmentError, err:
435 raise errors.HypervisorError("Failed to list node info: %s" % (err,))
441 splitfields = line.split(":", 1)
443 if len(splitfields) > 1:
444 key = splitfields[0].strip()
445 val = splitfields[1].strip()
446 if key == "MemTotal":
447 result["memory_total"] = int(val.split()[0]) / 1024
448 elif key in ("MemFree", "Buffers", "Cached"):
449 sum_free += int(val.split()[0]) / 1024
450 elif key == "Active":
451 result["memory_dom0"] = int(val.split()[0]) / 1024
452 except (ValueError, TypeError), err:
453 raise errors.HypervisorError("Failed to compute memory usage: %s" %
455 result["memory_free"] = sum_free
459 fh = open("/proc/cpuinfo")
461 cpu_total = len(re.findall("(?m)^processor\s*:\s*[0-9]+\s*$",
465 except EnvironmentError, err:
466 raise errors.HypervisorError("Failed to list node info: %s" % (err,))
467 result["cpu_total"] = cpu_total
468 # FIXME: export correct data here
469 result["cpu_nodes"] = 1
470 result["cpu_sockets"] = 1
475 def LinuxPowercycle(cls):
476 """Linux-specific powercycle method.
480 fd = os.open("/proc/sysrq-trigger", os.O_WRONLY)
486 logging.exception("Can't open the sysrq-trigger file")
487 result = utils.RunCmd(["reboot", "-n", "-f"])
489 logging.error("Can't run shutdown: %s", result.output)