1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
62
77
78
79
80
81
82
83 _FILE_CHECK = (utils.IsNormAbsPath, "must be an absolute normalized path",
84 os.path.isfile, "not found or not a file")
85
86
87 _DIR_CHECK = (utils.IsNormAbsPath, "must be an absolute normalized path",
88 os.path.isdir, "not found or not a directory")
89
90
91
92 _CPU_MASK_CHECK = (_IsCpuMaskWellFormed,
93 "CPU mask definition is not well-formed",
94 None, None)
95
96
97 _MULTI_CPU_MASK_CHECK = (_IsMultiCpuMaskWellFormed,
98 "Multiple CPU mask definition is not well-formed",
99 None, None)
100
101
102 _NET_PORT_CHECK = (lambda x: 0 < x < 65535, "invalid port number",
103 None, None)
104
105
106 _NONNEGATIVE_INT_CHECK = (lambda x: x >= 0, "cannot be negative", None, None)
107
108
109 REQ_FILE_CHECK = (True, ) + _FILE_CHECK
110 OPT_FILE_CHECK = (False, ) + _FILE_CHECK
111 REQ_DIR_CHECK = (True, ) + _DIR_CHECK
112 OPT_DIR_CHECK = (False, ) + _DIR_CHECK
113 REQ_NET_PORT_CHECK = (True, ) + _NET_PORT_CHECK
114 OPT_NET_PORT_CHECK = (False, ) + _NET_PORT_CHECK
115 REQ_CPU_MASK_CHECK = (True, ) + _CPU_MASK_CHECK
116 OPT_CPU_MASK_CHECK = (False, ) + _CPU_MASK_CHECK
117 REQ_MULTI_CPU_MASK_CHECK = (True, ) + _MULTI_CPU_MASK_CHECK
118 OPT_MULTI_CPU_MASK_CHECK = (False, ) + _MULTI_CPU_MASK_CHECK
119 REQ_NONNEGATIVE_INT_CHECK = (True, ) + _NONNEGATIVE_INT_CHECK
120 OPT_NONNEGATIVE_INT_CHECK = (False, ) + _NONNEGATIVE_INT_CHECK
121
122
123 NO_CHECK = (False, None, None, None, None)
124
125
126 REQUIRED_CHECK = (True, None, None, None, None)
127
128
129 MIGRATION_MODE_CHECK = (True, lambda x: x in constants.HT_MIGRATION_MODES,
130 "invalid migration mode", None, None)
134 """Builds parameter checker for set membership.
135
136 @type required: boolean
137 @param required: whether this is a required parameter
138 @type my_set: tuple, list or set
139 @param my_set: allowed values set
140
141 """
142 fn = lambda x: x in my_set
143 err = ("The value must be one of: %s" % utils.CommaJoin(my_set))
144 return (required, fn, err, None, None)
145
148 """Abstract virtualisation technology interface
149
150 The goal is that all aspects of the virtualisation technology are
151 abstracted away from the rest of code.
152
153 @cvar PARAMETERS: a dict of parameter name: check type; the check type is
154 a five-tuple containing:
155 - the required flag (boolean)
156 - a function to check for syntax, that will be used in
157 L{CheckParameterSyntax}, in the master daemon process
158 - an error message for the above function
159 - a function to check for parameter validity on the remote node,
160 in the L{ValidateParameters} function
161 - an error message for the above function
162 @type CAN_MIGRATE: boolean
163 @cvar CAN_MIGRATE: whether this hypervisor can do migration (either
164 live or non-live)
165
166 """
167 PARAMETERS = {}
168 ANCILLARY_FILES = []
169 ANCILLARY_FILES_OPT = []
170 CAN_MIGRATE = False
171
172 - def StartInstance(self, instance, block_devices, startup_paused):
173 """Start an instance."""
174 raise NotImplementedError
175
176 - def StopInstance(self, instance, force=False, retry=False, name=None):
177 """Stop an instance
178
179 @type instance: L{objects.Instance}
180 @param instance: instance to stop
181 @type force: boolean
182 @param force: whether to do a "hard" stop (destroy)
183 @type retry: boolean
184 @param retry: whether this is just a retry call
185 @type name: string or None
186 @param name: if this parameter is passed, the the instance object
187 should not be used (will be passed as None), and the shutdown
188 must be done by name only
189
190 """
191 raise NotImplementedError
192
194 """Cleanup after a stopped instance
195
196 This is an optional method, used by hypervisors that need to cleanup after
197 an instance has been stopped.
198
199 @type instance_name: string
200 @param instance_name: instance name to cleanup after
201
202 """
203 pass
204
206 """Reboot an instance."""
207 raise NotImplementedError
208
210 """Get the list of running instances."""
211 raise NotImplementedError
212
214 """Get instance properties.
215
216 @type instance_name: string
217 @param instance_name: the instance name
218
219 @return: tuple (name, id, memory, vcpus, state, times)
220
221 """
222 raise NotImplementedError
223
225 """Get properties of all instances.
226
227 @return: list of tuples (name, id, memory, vcpus, stat, times)
228
229 """
230 raise NotImplementedError
231
233 """Return information about the node.
234
235 @return: a dict with the following keys (values in MiB):
236 - memory_total: the total memory size on the node
237 - memory_free: the available memory on the node for instances
238 - memory_dom0: the memory used by the node itself, if available
239
240 """
241 raise NotImplementedError
242
243 @classmethod
245 """Return information for connecting to the console of an instance.
246
247 """
248 raise NotImplementedError
249
250 @classmethod
252 """Return a list of ancillary files to be copied to all nodes as ancillary
253 configuration files.
254
255 @rtype: (list of absolute paths, list of absolute paths)
256 @return: (all files, optional files)
257
258 """
259
260
261 assert set(cls.ANCILLARY_FILES).issuperset(cls.ANCILLARY_FILES_OPT), \
262 "Optional ancillary files must be a subset of ancillary files"
263
264 return (cls.ANCILLARY_FILES, cls.ANCILLARY_FILES_OPT)
265
267 """Verify the hypervisor.
268
269 @return: Problem description if something is wrong, C{None} otherwise
270
271 """
272 raise NotImplementedError
273
275 """Get instance information to perform a migration.
276
277 By default assume no information is needed.
278
279 @type instance: L{objects.Instance}
280 @param instance: instance to be migrated
281 @rtype: string/data (opaque)
282 @return: instance migration information - serialized form
283
284 """
285 return ""
286
288 """Prepare to accept an instance.
289
290 By default assume no preparation is needed.
291
292 @type instance: L{objects.Instance}
293 @param instance: instance to be accepted
294 @type info: string/data (opaque)
295 @param info: migration information, from the source node
296 @type target: string
297 @param target: target host (usually ip), on this node
298
299 """
300 pass
301
303 """Balloon an instance memory to a certain value.
304
305 @type instance: L{objects.Instance}
306 @param instance: instance to be accepted
307 @type mem: int
308 @param mem: actual memory size to use for instance runtime
309
310 """
311 raise NotImplementedError
312
314 """Finalize the instance migration on the target node.
315
316 Should finalize or revert any preparation done to accept the instance.
317 Since by default we do no preparation, we also don't have anything to do
318
319 @type instance: L{objects.Instance}
320 @param instance: instance whose migration is being finalized
321 @type info: string/data (opaque)
322 @param info: migration information, from the source node
323 @type success: boolean
324 @param success: whether the migration was a success or a failure
325
326 """
327 pass
328
330 """Migrate an instance.
331
332 @type instance: L{objects.Instance}
333 @param instance: the instance to be migrated
334 @type target: string
335 @param target: hostname (usually ip) of the target node
336 @type live: boolean
337 @param live: whether to do a live or non-live migration
338
339 """
340 raise NotImplementedError
341
343 """Finalize the instance migration on the source node.
344
345 @type instance: L{objects.Instance}
346 @param instance: the instance that was migrated
347 @type success: bool
348 @param success: whether the migration succeeded or not
349 @type live: bool
350 @param live: whether the user requested a live migration or not
351
352 """
353 pass
354
356 """Get the migration status
357
358 @type instance: L{objects.Instance}
359 @param instance: the instance that is being migrated
360 @rtype: L{objects.MigrationStatus}
361 @return: the status of the current migration (one of
362 L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
363 progress info that can be retrieved from the hypervisor
364
365 """
366 raise NotImplementedError
367
369 """Get the correct startup memory for an instance
370
371 This function calculates how much memory an instance should be started
372 with, making sure it's a value between the minimum and the maximum memory,
373 but also trying to use no more than the current free memory on the node.
374
375 @type instance: L{objects.Instance}
376 @param instance: the instance that is being started
377 @rtype: integer
378 @return: memory the instance should be started with
379
380 """
381 free_memory = self.GetNodeInfo()["memory_free"]
382 max_start_mem = min(instance.beparams[constants.BE_MAXMEM], free_memory)
383 start_mem = max(instance.beparams[constants.BE_MINMEM], max_start_mem)
384 return start_mem
385
386 @classmethod
388 """Check the given parameters for validity.
389
390 This should check the passed set of parameters for
391 validity. Classes should extend, not replace, this function.
392
393 @type hvparams: dict
394 @param hvparams: dictionary with parameter names/value
395 @raise errors.HypervisorError: when a parameter is not valid
396
397 """
398 for key in hvparams:
399 if key not in cls.PARAMETERS:
400 raise errors.HypervisorError("Parameter '%s' is not supported" % key)
401
402
403 for name, (required, check_fn, errstr, _, _) in cls.PARAMETERS.items():
404 if name not in hvparams:
405 raise errors.HypervisorError("Parameter '%s' is missing" % name)
406 value = hvparams[name]
407 if not required and not value:
408 continue
409 if not value:
410 raise errors.HypervisorError("Parameter '%s' is required but"
411 " is currently not defined" % (name, ))
412 if check_fn is not None and not check_fn(value):
413 raise errors.HypervisorError("Parameter '%s' fails syntax"
414 " check: %s (current value: '%s')" %
415 (name, errstr, value))
416
417 @classmethod
419 """Check the given parameters for validity.
420
421 This should check the passed set of parameters for
422 validity. Classes should extend, not replace, this function.
423
424 @type hvparams: dict
425 @param hvparams: dictionary with parameter names/value
426 @raise errors.HypervisorError: when a parameter is not valid
427
428 """
429 for name, (required, _, _, check_fn, errstr) in cls.PARAMETERS.items():
430 value = hvparams[name]
431 if not required and not value:
432 continue
433 if check_fn is not None and not check_fn(value):
434 raise errors.HypervisorError("Parameter '%s' fails"
435 " validation: %s (current value: '%s')" %
436 (name, errstr, value))
437
438 @classmethod
440 """Hard powercycle a node using hypervisor specific methods.
441
442 This method should hard powercycle the node, using whatever
443 methods the hypervisor provides. Note that this means that all
444 instances running on the node must be stopped too.
445
446 """
447 raise NotImplementedError
448
449 @staticmethod
451 """For linux systems, return actual OS information.
452
453 This is an abstraction for all non-hypervisor-based classes, where
454 the node actually sees all the memory and CPUs via the /proc
455 interface and standard commands. The other case if for example
456 xen, where you only see the hardware resources via xen-specific
457 tools.
458
459 @return: a dict with the following keys (values in MiB):
460 - memory_total: the total memory size on the node
461 - memory_free: the available memory on the node for instances
462 - memory_dom0: the memory used by the node itself, if available
463
464 """
465 try:
466 data = utils.ReadFile("/proc/meminfo").splitlines()
467 except EnvironmentError, err:
468 raise errors.HypervisorError("Failed to list node info: %s" % (err,))
469
470 result = {}
471 sum_free = 0
472 try:
473 for line in data:
474 splitfields = line.split(":", 1)
475
476 if len(splitfields) > 1:
477 key = splitfields[0].strip()
478 val = splitfields[1].strip()
479 if key == "MemTotal":
480 result["memory_total"] = int(val.split()[0]) / 1024
481 elif key in ("MemFree", "Buffers", "Cached"):
482 sum_free += int(val.split()[0]) / 1024
483 elif key == "Active":
484 result["memory_dom0"] = int(val.split()[0]) / 1024
485 except (ValueError, TypeError), err:
486 raise errors.HypervisorError("Failed to compute memory usage: %s" %
487 (err,))
488 result["memory_free"] = sum_free
489
490 cpu_total = 0
491 try:
492 fh = open("/proc/cpuinfo")
493 try:
494 cpu_total = len(re.findall("(?m)^processor\s*:\s*[0-9]+\s*$",
495 fh.read()))
496 finally:
497 fh.close()
498 except EnvironmentError, err:
499 raise errors.HypervisorError("Failed to list node info: %s" % (err,))
500 result["cpu_total"] = cpu_total
501
502 result["cpu_nodes"] = 1
503 result["cpu_sockets"] = 1
504
505 return result
506
507 @classmethod
509 """Linux-specific powercycle method.
510
511 """
512 try:
513 fd = os.open("/proc/sysrq-trigger", os.O_WRONLY)
514 try:
515 os.write(fd, "b")
516 finally:
517 fd.close()
518 except OSError:
519 logging.exception("Can't open the sysrq-trigger file")
520 result = utils.RunCmd(["reboot", "-n", "-f"])
521 if not result:
522 logging.error("Can't run shutdown: %s", result.output)
523
524 @staticmethod
537