Package ganeti :: Package hypervisor :: Module hv_base
[hide private]
[frames] | no frames]

Source Code for Module ganeti.hypervisor.hv_base

  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 # nice wrappers for users 76 REQ_FILE_CHECK = (True, ) + _FILE_CHECK 77 OPT_FILE_CHECK = (False, ) + _FILE_CHECK 78 REQ_DIR_CHECK = (True, ) + _DIR_CHECK 79 OPT_DIR_CHECK = (False, ) + _DIR_CHECK 80 NET_PORT_CHECK = (True, lambda x: x > 0 and x < 65535, "invalid port number", 81 None, None) 82 OPT_CPU_MASK_CHECK = (False, ) + _CPU_MASK_CHECK 83 REQ_CPU_MASK_CHECK = (True, ) + _CPU_MASK_CHECK 84 85 # no checks at all 86 NO_CHECK = (False, None, None, None, None) 87 88 # required, but no other checks 89 REQUIRED_CHECK = (True, None, None, None, None) 90 91 # migration type 92 MIGRATION_MODE_CHECK = (True, lambda x: x in constants.HT_MIGRATION_MODES, 93 "invalid migration mode", None, None)
94 95 96 -def ParamInSet(required, my_set):
97 """Builds parameter checker for set membership. 98 99 @type required: boolean 100 @param required: whether this is a required parameter 101 @type my_set: tuple, list or set 102 @param my_set: allowed values set 103 104 """ 105 fn = lambda x: x in my_set 106 err = ("The value must be one of: %s" % utils.CommaJoin(my_set)) 107 return (required, fn, err, None, None)
108
109 110 -class BaseHypervisor(object):
111 """Abstract virtualisation technology interface 112 113 The goal is that all aspects of the virtualisation technology are 114 abstracted away from the rest of code. 115 116 @cvar PARAMETERS: a dict of parameter name: check type; the check type is 117 a five-tuple containing: 118 - the required flag (boolean) 119 - a function to check for syntax, that will be used in 120 L{CheckParameterSyntax}, in the master daemon process 121 - an error message for the above function 122 - a function to check for parameter validity on the remote node, 123 in the L{ValidateParameters} function 124 - an error message for the above function 125 @type CAN_MIGRATE: boolean 126 @cvar CAN_MIGRATE: whether this hypervisor can do migration (either 127 live or non-live) 128 129 """ 130 PARAMETERS = {} 131 ANCILLARY_FILES = [] 132 CAN_MIGRATE = False 133
134 - def __init__(self):
135 pass
136
137 - def StartInstance(self, instance, block_devices):
138 """Start an instance.""" 139 raise NotImplementedError
140
141 - def StopInstance(self, instance, force=False, retry=False, name=None):
142 """Stop an instance 143 144 @type instance: L{objects.Instance} 145 @param instance: instance to stop 146 @type force: boolean 147 @param force: whether to do a "hard" stop (destroy) 148 @type retry: boolean 149 @param retry: whether this is just a retry call 150 @type name: string or None 151 @param name: if this parameter is passed, the the instance object 152 should not be used (will be passed as None), and the shutdown 153 must be done by name only 154 155 """ 156 raise NotImplementedError
157
158 - def CleanupInstance(self, instance_name):
159 """Cleanup after a stopped instance 160 161 This is an optional method, used by hypervisors that need to cleanup after 162 an instance has been stopped. 163 164 @type instance_name: string 165 @param instance_name: instance name to cleanup after 166 167 """ 168 pass
169
170 - def RebootInstance(self, instance):
171 """Reboot an instance.""" 172 raise NotImplementedError
173
174 - def ListInstances(self):
175 """Get the list of running instances.""" 176 raise NotImplementedError
177
178 - def GetInstanceInfo(self, instance_name):
179 """Get instance properties. 180 181 @type instance_name: string 182 @param instance_name: the instance name 183 184 @return: tuple (name, id, memory, vcpus, state, times) 185 186 """ 187 raise NotImplementedError
188
189 - def GetAllInstancesInfo(self):
190 """Get properties of all instances. 191 192 @return: list of tuples (name, id, memory, vcpus, stat, times) 193 194 """ 195 raise NotImplementedError
196
197 - def GetNodeInfo(self):
198 """Return information about the node. 199 200 @return: a dict with the following keys (values in MiB): 201 - memory_total: the total memory size on the node 202 - memory_free: the available memory on the node for instances 203 - memory_dom0: the memory used by the node itself, if available 204 205 """ 206 raise NotImplementedError
207 208 @classmethod
209 - def GetInstanceConsole(cls, instance, hvparams, beparams):
210 """Return information for connecting to the console of an instance. 211 212 """ 213 raise NotImplementedError
214 215 @classmethod
216 - def GetAncillaryFiles(cls):
217 """Return a list of ancillary files to be copied to all nodes as ancillary 218 configuration files. 219 220 @rtype: list of strings 221 @return: list of absolute paths of files to ship cluster-wide 222 223 """ 224 # By default we return a member variable, so that if an hypervisor has just 225 # a static list of files it doesn't have to override this function. 226 return cls.ANCILLARY_FILES
227
228 - def Verify(self):
229 """Verify the hypervisor. 230 231 """ 232 raise NotImplementedError
233
234 - def MigrationInfo(self, instance): # pylint: disable-msg=R0201,W0613
235 """Get instance information to perform a migration. 236 237 By default assume no information is needed. 238 239 @type instance: L{objects.Instance} 240 @param instance: instance to be migrated 241 @rtype: string/data (opaque) 242 @return: instance migration information - serialized form 243 244 """ 245 return ''
246
247 - def AcceptInstance(self, instance, info, target):
248 """Prepare to accept an instance. 249 250 By default assume no preparation is needed. 251 252 @type instance: L{objects.Instance} 253 @param instance: instance to be accepted 254 @type info: string/data (opaque) 255 @param info: migration information, from the source node 256 @type target: string 257 @param target: target host (usually ip), on this node 258 259 """ 260 pass
261
262 - def FinalizeMigration(self, instance, info, success):
263 """Finalized an instance migration. 264 265 Should finalize or revert any preparation done to accept the instance. 266 Since by default we do no preparation, we also don't have anything to do 267 268 @type instance: L{objects.Instance} 269 @param instance: instance whose migration is being finalized 270 @type info: string/data (opaque) 271 @param info: migration information, from the source node 272 @type success: boolean 273 @param success: whether the migration was a success or a failure 274 275 """ 276 pass
277
278 - def MigrateInstance(self, instance, target, live):
279 """Migrate an instance. 280 281 @type instance: L{objects.Instance} 282 @param instance: the instance to be migrated 283 @type target: string 284 @param target: hostname (usually ip) of the target node 285 @type live: boolean 286 @param live: whether to do a live or non-live migration 287 288 """ 289 raise NotImplementedError
290 291 @classmethod
292 - def CheckParameterSyntax(cls, hvparams):
293 """Check the given parameters for validity. 294 295 This should check the passed set of parameters for 296 validity. Classes should extend, not replace, this function. 297 298 @type hvparams: dict 299 @param hvparams: dictionary with parameter names/value 300 @raise errors.HypervisorError: when a parameter is not valid 301 302 """ 303 for key in hvparams: 304 if key not in cls.PARAMETERS: 305 raise errors.HypervisorError("Parameter '%s' is not supported" % key) 306 307 # cheap tests that run on the master, should not access the world 308 for name, (required, check_fn, errstr, _, _) in cls.PARAMETERS.items(): 309 if name not in hvparams: 310 raise errors.HypervisorError("Parameter '%s' is missing" % name) 311 value = hvparams[name] 312 if not required and not value: 313 continue 314 if not value: 315 raise errors.HypervisorError("Parameter '%s' is required but" 316 " is currently not defined" % (name, )) 317 if check_fn is not None and not check_fn(value): 318 raise errors.HypervisorError("Parameter '%s' fails syntax" 319 " check: %s (current value: '%s')" % 320 (name, errstr, value))
321 322 @classmethod
323 - def ValidateParameters(cls, hvparams):
324 """Check the given parameters for validity. 325 326 This should check the passed set of parameters for 327 validity. Classes should extend, not replace, this function. 328 329 @type hvparams: dict 330 @param hvparams: dictionary with parameter names/value 331 @raise errors.HypervisorError: when a parameter is not valid 332 333 """ 334 for name, (required, _, _, check_fn, errstr) in cls.PARAMETERS.items(): 335 value = hvparams[name] 336 if not required and not value: 337 continue 338 if check_fn is not None and not check_fn(value): 339 raise errors.HypervisorError("Parameter '%s' fails" 340 " validation: %s (current value: '%s')" % 341 (name, errstr, value))
342 343 @classmethod
344 - def PowercycleNode(cls):
345 """Hard powercycle a node using hypervisor specific methods. 346 347 This method should hard powercycle the node, using whatever 348 methods the hypervisor provides. Note that this means that all 349 instances running on the node must be stopped too. 350 351 """ 352 raise NotImplementedError
353 354 @staticmethod
355 - def GetLinuxNodeInfo():
356 """For linux systems, return actual OS information. 357 358 This is an abstraction for all non-hypervisor-based classes, where 359 the node actually sees all the memory and CPUs via the /proc 360 interface and standard commands. The other case if for example 361 xen, where you only see the hardware resources via xen-specific 362 tools. 363 364 @return: a dict with the following keys (values in MiB): 365 - memory_total: the total memory size on the node 366 - memory_free: the available memory on the node for instances 367 - memory_dom0: the memory used by the node itself, if available 368 369 """ 370 try: 371 data = utils.ReadFile("/proc/meminfo").splitlines() 372 except EnvironmentError, err: 373 raise errors.HypervisorError("Failed to list node info: %s" % (err,)) 374 375 result = {} 376 sum_free = 0 377 try: 378 for line in data: 379 splitfields = line.split(":", 1) 380 381 if len(splitfields) > 1: 382 key = splitfields[0].strip() 383 val = splitfields[1].strip() 384 if key == 'MemTotal': 385 result['memory_total'] = int(val.split()[0])/1024 386 elif key in ('MemFree', 'Buffers', 'Cached'): 387 sum_free += int(val.split()[0])/1024 388 elif key == 'Active': 389 result['memory_dom0'] = int(val.split()[0])/1024 390 except (ValueError, TypeError), err: 391 raise errors.HypervisorError("Failed to compute memory usage: %s" % 392 (err,)) 393 result['memory_free'] = sum_free 394 395 cpu_total = 0 396 try: 397 fh = open("/proc/cpuinfo") 398 try: 399 cpu_total = len(re.findall("(?m)^processor\s*:\s*[0-9]+\s*$", 400 fh.read())) 401 finally: 402 fh.close() 403 except EnvironmentError, err: 404 raise errors.HypervisorError("Failed to list node info: %s" % (err,)) 405 result['cpu_total'] = cpu_total 406 # FIXME: export correct data here 407 result['cpu_nodes'] = 1 408 result['cpu_sockets'] = 1 409 410 return result
411 412 @classmethod
413 - def LinuxPowercycle(cls):
414 """Linux-specific powercycle method. 415 416 """ 417 try: 418 fd = os.open("/proc/sysrq-trigger", os.O_WRONLY) 419 try: 420 os.write(fd, "b") 421 finally: 422 fd.close() 423 except OSError: 424 logging.exception("Can't open the sysrq-trigger file") 425 result = utils.RunCmd(["reboot", "-n", "-f"]) 426 if not result: 427 logging.error("Can't run shutdown: %s", result.output)
428