1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 """Functions used by the node daemon
23
24 @var _ALLOWED_UPLOAD_FILES: denotes which files are accepted in
25 the L{UploadFile} function
26 @var _ALLOWED_CLEAN_DIRS: denotes which directories are accepted
27 in the L{_CleanDirectory} function
28
29 """
30
31
32
33
34
35
36
37
38 import os
39 import os.path
40 import shutil
41 import time
42 import stat
43 import errno
44 import re
45 import random
46 import logging
47 import tempfile
48 import zlib
49 import base64
50 import signal
51
52 from ganeti import errors
53 from ganeti import utils
54 from ganeti import ssh
55 from ganeti import hypervisor
56 from ganeti import constants
57 from ganeti import bdev
58 from ganeti import objects
59 from ganeti import ssconf
60 from ganeti import serializer
61 from ganeti import netutils
62 from ganeti import runtime
63
64
65 _BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id"
66 _ALLOWED_CLEAN_DIRS = frozenset([
67 constants.DATA_DIR,
68 constants.JOB_QUEUE_ARCHIVE_DIR,
69 constants.QUEUE_DIR,
70 constants.CRYPTO_KEYS_DIR,
71 ])
72 _MAX_SSL_CERT_VALIDITY = 7 * 24 * 60 * 60
73 _X509_KEY_FILE = "key"
74 _X509_CERT_FILE = "cert"
75 _IES_STATUS_FILE = "status"
76 _IES_PID_FILE = "pid"
77 _IES_CA_FILE = "ca"
78
79
80 _LVSLINE_REGEX = re.compile("^ *([^|]+)\|([^|]+)\|([0-9.]+)\|([^|]{6})\|?$")
84 """Class denoting RPC failure.
85
86 Its argument is the error message.
87
88 """
89
90
91 -def _Fail(msg, *args, **kwargs):
92 """Log an error and the raise an RPCFail exception.
93
94 This exception is then handled specially in the ganeti daemon and
95 turned into a 'failed' return type. As such, this function is a
96 useful shortcut for logging the error and returning it to the master
97 daemon.
98
99 @type msg: string
100 @param msg: the text of the exception
101 @raise RPCFail
102
103 """
104 if args:
105 msg = msg % args
106 if "log" not in kwargs or kwargs["log"]:
107 if "exc" in kwargs and kwargs["exc"]:
108 logging.exception(msg)
109 else:
110 logging.error(msg)
111 raise RPCFail(msg)
112
115 """Simple wrapper to return a SimpleStore.
116
117 @rtype: L{ssconf.SimpleStore}
118 @return: a SimpleStore instance
119
120 """
121 return ssconf.SimpleStore()
122
125 """Simple wrapper to return an SshRunner.
126
127 @type cluster_name: str
128 @param cluster_name: the cluster name, which is needed
129 by the SshRunner constructor
130 @rtype: L{ssh.SshRunner}
131 @return: an SshRunner instance
132
133 """
134 return ssh.SshRunner(cluster_name)
135
138 """Unpacks data compressed by the RPC client.
139
140 @type data: list or tuple
141 @param data: Data sent by RPC client
142 @rtype: str
143 @return: Decompressed data
144
145 """
146 assert isinstance(data, (list, tuple))
147 assert len(data) == 2
148 (encoding, content) = data
149 if encoding == constants.RPC_ENCODING_NONE:
150 return content
151 elif encoding == constants.RPC_ENCODING_ZLIB_BASE64:
152 return zlib.decompress(base64.b64decode(content))
153 else:
154 raise AssertionError("Unknown data encoding")
155
158 """Removes all regular files in a directory.
159
160 @type path: str
161 @param path: the directory to clean
162 @type exclude: list
163 @param exclude: list of files to be excluded, defaults
164 to the empty list
165
166 """
167 if path not in _ALLOWED_CLEAN_DIRS:
168 _Fail("Path passed to _CleanDirectory not in allowed clean targets: '%s'",
169 path)
170
171 if not os.path.isdir(path):
172 return
173 if exclude is None:
174 exclude = []
175 else:
176
177 exclude = [os.path.normpath(i) for i in exclude]
178
179 for rel_name in utils.ListVisibleFiles(path):
180 full_name = utils.PathJoin(path, rel_name)
181 if full_name in exclude:
182 continue
183 if os.path.isfile(full_name) and not os.path.islink(full_name):
184 utils.RemoveFile(full_name)
185
209
210
211 _ALLOWED_UPLOAD_FILES = _BuildUploadFileList()
223
226 """Returns master information.
227
228 This is an utility function to compute master information, either
229 for consumption here or from the node daemon.
230
231 @rtype: tuple
232 @return: master_netdev, master_ip, master_name, primary_ip_family
233 @raise RPCFail: in case of errors
234
235 """
236 try:
237 cfg = _GetConfig()
238 master_netdev = cfg.GetMasterNetdev()
239 master_ip = cfg.GetMasterIP()
240 master_node = cfg.GetMasterNode()
241 primary_ip_family = cfg.GetPrimaryIPFamily()
242 except errors.ConfigurationError, err:
243 _Fail("Cluster configuration incomplete: %s", err, exc=True)
244 return (master_netdev, master_ip, master_node, primary_ip_family)
245
248 """Activate local node as master node.
249
250 The function will either try activate the IP address of the master
251 (unless someone else has it) or also start the master daemons, based
252 on the start_daemons parameter.
253
254 @type start_daemons: boolean
255 @param start_daemons: whether to start the master daemons
256 (ganeti-masterd and ganeti-rapi), or (if false) activate the
257 master ip
258 @type no_voting: boolean
259 @param no_voting: whether to start ganeti-masterd without a node vote
260 (if start_daemons is True), but still non-interactively
261 @rtype: None
262
263 """
264
265 master_netdev, master_ip, _, family = GetMasterInfo()
266
267 err_msgs = []
268
269 if start_daemons:
270 if no_voting:
271 masterd_args = "--no-voting --yes-do-it"
272 else:
273 masterd_args = ""
274
275 env = {
276 "EXTRA_MASTERD_ARGS": masterd_args,
277 }
278
279 result = utils.RunCmd([constants.DAEMON_UTIL, "start-master"], env=env)
280 if result.failed:
281 msg = "Can't start Ganeti master: %s" % result.output
282 logging.error(msg)
283 err_msgs.append(msg)
284
285 else:
286 if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):
287 if netutils.IPAddress.Own(master_ip):
288
289 logging.debug("Master IP already configured, doing nothing")
290 else:
291 msg = "Someone else has the master ip, not activating"
292 logging.error(msg)
293 err_msgs.append(msg)
294 else:
295 ipcls = netutils.IP4Address
296 if family == netutils.IP6Address.family:
297 ipcls = netutils.IP6Address
298
299 result = utils.RunCmd(["ip", "address", "add",
300 "%s/%d" % (master_ip, ipcls.iplen),
301 "dev", master_netdev, "label",
302 "%s:0" % master_netdev])
303 if result.failed:
304 msg = "Can't activate master IP: %s" % result.output
305 logging.error(msg)
306 err_msgs.append(msg)
307
308
309 if ipcls == netutils.IP4Address:
310 utils.RunCmd(["arping", "-q", "-U", "-c 3", "-I", master_netdev, "-s",
311 master_ip, master_ip])
312 elif ipcls == netutils.IP6Address:
313 try:
314 utils.RunCmd(["ndisc6", "-q", "-r 3", master_ip, master_netdev])
315 except errors.OpExecError:
316
317 logging.warning("Can't execute ndisc6, please install if missing")
318
319 if err_msgs:
320 _Fail("; ".join(err_msgs))
321
324 """Deactivate this node as master.
325
326 The function will always try to deactivate the IP address of the
327 master. It will also stop the master daemons depending on the
328 stop_daemons parameter.
329
330 @type stop_daemons: boolean
331 @param stop_daemons: whether to also stop the master daemons
332 (ganeti-masterd and ganeti-rapi)
333 @rtype: None
334
335 """
336
337
338
339
340 master_netdev, master_ip, _, family = GetMasterInfo()
341
342 ipcls = netutils.IP4Address
343 if family == netutils.IP6Address.family:
344 ipcls = netutils.IP6Address
345
346 result = utils.RunCmd(["ip", "address", "del",
347 "%s/%d" % (master_ip, ipcls.iplen),
348 "dev", master_netdev])
349 if result.failed:
350 logging.error("Can't remove the master IP, error: %s", result.output)
351
352
353 if stop_daemons:
354 result = utils.RunCmd([constants.DAEMON_UTIL, "stop-master"])
355 if result.failed:
356 logging.error("Could not stop Ganeti master, command %s had exitcode %s"
357 " and error %s",
358 result.cmd, result.exit_code, result.output)
359
362 """Modify a host entry in /etc/hosts.
363
364 @param mode: The mode to operate. Either add or remove entry
365 @param host: The host to operate on
366 @param ip: The ip associated with the entry
367
368 """
369 if mode == constants.ETC_HOSTS_ADD:
370 if not ip:
371 RPCFail("Mode 'add' needs 'ip' parameter, but parameter not"
372 " present")
373 utils.AddHostToEtcHosts(host, ip)
374 elif mode == constants.ETC_HOSTS_REMOVE:
375 if ip:
376 RPCFail("Mode 'remove' does not allow 'ip' parameter, but"
377 " parameter is present")
378 utils.RemoveHostFromEtcHosts(host)
379 else:
380 RPCFail("Mode not supported")
381
384 """Cleans up and remove the current node.
385
386 This function cleans up and prepares the current node to be removed
387 from the cluster.
388
389 If processing is successful, then it raises an
390 L{errors.QuitGanetiException} which is used as a special case to
391 shutdown the node daemon.
392
393 @param modify_ssh_setup: boolean
394
395 """
396 _CleanDirectory(constants.DATA_DIR)
397 _CleanDirectory(constants.CRYPTO_KEYS_DIR)
398 JobQueuePurge()
399
400 if modify_ssh_setup:
401 try:
402 priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
403
404 utils.RemoveAuthorizedKey(auth_keys, utils.ReadFile(pub_key))
405
406 utils.RemoveFile(priv_key)
407 utils.RemoveFile(pub_key)
408 except errors.OpExecError:
409 logging.exception("Error while processing ssh files")
410
411 try:
412 utils.RemoveFile(constants.CONFD_HMAC_KEY)
413 utils.RemoveFile(constants.RAPI_CERT_FILE)
414 utils.RemoveFile(constants.NODED_CERT_FILE)
415 except:
416 logging.exception("Error while removing cluster secrets")
417
418 result = utils.RunCmd([constants.DAEMON_UTIL, "stop", constants.CONFD])
419 if result.failed:
420 logging.error("Command %s failed with exitcode %s and error %s",
421 result.cmd, result.exit_code, result.output)
422
423
424 raise errors.QuitGanetiException(True, 'Shutdown scheduled')
425
428 """Gives back a hash with different information about the node.
429
430 @type vgname: C{string}
431 @param vgname: the name of the volume group to ask for disk space information
432 @type hypervisor_type: C{str}
433 @param hypervisor_type: the name of the hypervisor to ask for
434 memory information
435 @rtype: C{dict}
436 @return: dictionary with the following keys:
437 - vg_size is the size of the configured volume group in MiB
438 - vg_free is the free size of the volume group in MiB
439 - memory_dom0 is the memory allocated for domain0 in MiB
440 - memory_free is the currently available (free) ram in MiB
441 - memory_total is the total number of ram in MiB
442
443 """
444 outputarray = {}
445
446 if vgname is not None:
447 vginfo = bdev.LogicalVolume.GetVGInfo([vgname])
448 vg_free = vg_size = None
449 if vginfo:
450 vg_free = int(round(vginfo[0][0], 0))
451 vg_size = int(round(vginfo[0][1], 0))
452 outputarray['vg_size'] = vg_size
453 outputarray['vg_free'] = vg_free
454
455 if hypervisor_type is not None:
456 hyper = hypervisor.GetHypervisor(hypervisor_type)
457 hyp_info = hyper.GetNodeInfo()
458 if hyp_info is not None:
459 outputarray.update(hyp_info)
460
461 outputarray["bootid"] = utils.ReadFile(_BOOT_ID_PATH, size=128).rstrip("\n")
462
463 return outputarray
464
467 """Verify the status of the local node.
468
469 Based on the input L{what} parameter, various checks are done on the
470 local node.
471
472 If the I{filelist} key is present, this list of
473 files is checksummed and the file/checksum pairs are returned.
474
475 If the I{nodelist} key is present, we check that we have
476 connectivity via ssh with the target nodes (and check the hostname
477 report).
478
479 If the I{node-net-test} key is present, we check that we have
480 connectivity to the given nodes via both primary IP and, if
481 applicable, secondary IPs.
482
483 @type what: C{dict}
484 @param what: a dictionary of things to check:
485 - filelist: list of files for which to compute checksums
486 - nodelist: list of nodes we should check ssh communication with
487 - node-net-test: list of nodes we should check node daemon port
488 connectivity with
489 - hypervisor: list with hypervisors to run the verify for
490 @rtype: dict
491 @return: a dictionary with the same keys as the input dict, and
492 values representing the result of the checks
493
494 """
495 result = {}
496 my_name = netutils.Hostname.GetSysName()
497 port = netutils.GetDaemonPort(constants.NODED)
498 vm_capable = my_name not in what.get(constants.NV_VMNODES, [])
499
500 if constants.NV_HYPERVISOR in what and vm_capable:
501 result[constants.NV_HYPERVISOR] = tmp = {}
502 for hv_name in what[constants.NV_HYPERVISOR]:
503 try:
504 val = hypervisor.GetHypervisor(hv_name).Verify()
505 except errors.HypervisorError, err:
506 val = "Error while checking hypervisor: %s" % str(err)
507 tmp[hv_name] = val
508
509 if constants.NV_HVPARAMS in what and vm_capable:
510 result[constants.NV_HVPARAMS] = tmp = []
511 for source, hv_name, hvparms in what[constants.NV_HVPARAMS]:
512 try:
513 logging.info("Validating hv %s, %s", hv_name, hvparms)
514 hypervisor.GetHypervisor(hv_name).ValidateParameters(hvparms)
515 except errors.HypervisorError, err:
516 tmp.append((source, hv_name, str(err)))
517
518 if constants.NV_FILELIST in what:
519 result[constants.NV_FILELIST] = utils.FingerprintFiles(
520 what[constants.NV_FILELIST])
521
522 if constants.NV_NODELIST in what:
523 result[constants.NV_NODELIST] = tmp = {}
524 random.shuffle(what[constants.NV_NODELIST])
525 for node in what[constants.NV_NODELIST]:
526 success, message = _GetSshRunner(cluster_name).VerifyNodeHostname(node)
527 if not success:
528 tmp[node] = message
529
530 if constants.NV_NODENETTEST in what:
531 result[constants.NV_NODENETTEST] = tmp = {}
532 my_pip = my_sip = None
533 for name, pip, sip in what[constants.NV_NODENETTEST]:
534 if name == my_name:
535 my_pip = pip
536 my_sip = sip
537 break
538 if not my_pip:
539 tmp[my_name] = ("Can't find my own primary/secondary IP"
540 " in the node list")
541 else:
542 for name, pip, sip in what[constants.NV_NODENETTEST]:
543 fail = []
544 if not netutils.TcpPing(pip, port, source=my_pip):
545 fail.append("primary")
546 if sip != pip:
547 if not netutils.TcpPing(sip, port, source=my_sip):
548 fail.append("secondary")
549 if fail:
550 tmp[name] = ("failure using the %s interface(s)" %
551 " and ".join(fail))
552
553 if constants.NV_MASTERIP in what:
554
555
556 master_name, master_ip = what[constants.NV_MASTERIP]
557 if master_name == my_name:
558 source = constants.IP4_ADDRESS_LOCALHOST
559 else:
560 source = None
561 result[constants.NV_MASTERIP] = netutils.TcpPing(master_ip, port,
562 source=source)
563
564 if constants.NV_OOB_PATHS in what:
565 result[constants.NV_OOB_PATHS] = tmp = []
566 for path in what[constants.NV_OOB_PATHS]:
567 try:
568 st = os.stat(path)
569 except OSError, err:
570 tmp.append("error stating out of band helper: %s" % err)
571 else:
572 if stat.S_ISREG(st.st_mode):
573 if stat.S_IMODE(st.st_mode) & stat.S_IXUSR:
574 tmp.append(None)
575 else:
576 tmp.append("out of band helper %s is not executable" % path)
577 else:
578 tmp.append("out of band helper %s is not a file" % path)
579
580 if constants.NV_LVLIST in what and vm_capable:
581 try:
582 val = GetVolumeList(utils.ListVolumeGroups().keys())
583 except RPCFail, err:
584 val = str(err)
585 result[constants.NV_LVLIST] = val
586
587 if constants.NV_INSTANCELIST in what and vm_capable:
588
589 try:
590 val = GetInstanceList(what[constants.NV_INSTANCELIST])
591 except RPCFail, err:
592 val = str(err)
593 result[constants.NV_INSTANCELIST] = val
594
595 if constants.NV_VGLIST in what and vm_capable:
596 result[constants.NV_VGLIST] = utils.ListVolumeGroups()
597
598 if constants.NV_PVLIST in what and vm_capable:
599 result[constants.NV_PVLIST] = \
600 bdev.LogicalVolume.GetPVInfo(what[constants.NV_PVLIST],
601 filter_allocatable=False)
602
603 if constants.NV_VERSION in what:
604 result[constants.NV_VERSION] = (constants.PROTOCOL_VERSION,
605 constants.RELEASE_VERSION)
606
607 if constants.NV_HVINFO in what and vm_capable:
608 hyper = hypervisor.GetHypervisor(what[constants.NV_HVINFO])
609 result[constants.NV_HVINFO] = hyper.GetNodeInfo()
610
611 if constants.NV_DRBDLIST in what and vm_capable:
612 try:
613 used_minors = bdev.DRBD8.GetUsedDevs().keys()
614 except errors.BlockDeviceError, err:
615 logging.warning("Can't get used minors list", exc_info=True)
616 used_minors = str(err)
617 result[constants.NV_DRBDLIST] = used_minors
618
619 if constants.NV_DRBDHELPER in what and vm_capable:
620 status = True
621 try:
622 payload = bdev.BaseDRBD.GetUsermodeHelper()
623 except errors.BlockDeviceError, err:
624 logging.error("Can't get DRBD usermode helper: %s", str(err))
625 status = False
626 payload = str(err)
627 result[constants.NV_DRBDHELPER] = (status, payload)
628
629 if constants.NV_NODESETUP in what:
630 result[constants.NV_NODESETUP] = tmpr = []
631 if not os.path.isdir("/sys/block") or not os.path.isdir("/sys/class/net"):
632 tmpr.append("The sysfs filesytem doesn't seem to be mounted"
633 " under /sys, missing required directories /sys/block"
634 " and /sys/class/net")
635 if (not os.path.isdir("/proc/sys") or
636 not os.path.isfile("/proc/sysrq-trigger")):
637 tmpr.append("The procfs filesystem doesn't seem to be mounted"
638 " under /proc, missing required directory /proc/sys and"
639 " the file /proc/sysrq-trigger")
640
641 if constants.NV_TIME in what:
642 result[constants.NV_TIME] = utils.SplitTime(time.time())
643
644 if constants.NV_OSLIST in what and vm_capable:
645 result[constants.NV_OSLIST] = DiagnoseOS()
646
647 if constants.NV_BRIDGES in what and vm_capable:
648 result[constants.NV_BRIDGES] = [bridge
649 for bridge in what[constants.NV_BRIDGES]
650 if not utils.BridgeExists(bridge)]
651 return result
652
655 """Compute list of logical volumes and their size.
656
657 @type vg_names: list
658 @param vg_names: the volume groups whose LVs we should list, or
659 empty for all volume groups
660 @rtype: dict
661 @return:
662 dictionary of all partions (key) with value being a tuple of
663 their size (in MiB), inactive and online status::
664
665 {'xenvg/test1': ('20.06', True, True)}
666
667 in case of errors, a string is returned with the error
668 details.
669
670 """
671 lvs = {}
672 sep = '|'
673 if not vg_names:
674 vg_names = []
675 result = utils.RunCmd(["lvs", "--noheadings", "--units=m", "--nosuffix",
676 "--separator=%s" % sep,
677 "-ovg_name,lv_name,lv_size,lv_attr"] + vg_names)
678 if result.failed:
679 _Fail("Failed to list logical volumes, lvs output: %s", result.output)
680
681 for line in result.stdout.splitlines():
682 line = line.strip()
683 match = _LVSLINE_REGEX.match(line)
684 if not match:
685 logging.error("Invalid line returned from lvs output: '%s'", line)
686 continue
687 vg_name, name, size, attr = match.groups()
688 inactive = attr[4] == '-'
689 online = attr[5] == 'o'
690 virtual = attr[0] == 'v'
691 if virtual:
692
693
694 continue
695 lvs[vg_name+"/"+name] = (size, inactive, online)
696
697 return lvs
698
701 """List the volume groups and their size.
702
703 @rtype: dict
704 @return: dictionary with keys volume name and values the
705 size of the volume
706
707 """
708 return utils.ListVolumeGroups()
709
712 """List all volumes on this node.
713
714 @rtype: list
715 @return:
716 A list of dictionaries, each having four keys:
717 - name: the logical volume name,
718 - size: the size of the logical volume
719 - dev: the physical device on which the LV lives
720 - vg: the volume group to which it belongs
721
722 In case of errors, we return an empty list and log the
723 error.
724
725 Note that since a logical volume can live on multiple physical
726 volumes, the resulting list might include a logical volume
727 multiple times.
728
729 """
730 result = utils.RunCmd(["lvs", "--noheadings", "--units=m", "--nosuffix",
731 "--separator=|",
732 "--options=lv_name,lv_size,devices,vg_name"])
733 if result.failed:
734 _Fail("Failed to list logical volumes, lvs output: %s",
735 result.output)
736
737 def parse_dev(dev):
738 return dev.split('(')[0]
739
740 def handle_dev(dev):
741 return [parse_dev(x) for x in dev.split(",")]
742
743 def map_line(line):
744 line = [v.strip() for v in line]
745 return [{'name': line[0], 'size': line[1],
746 'dev': dev, 'vg': line[3]} for dev in handle_dev(line[2])]
747
748 all_devs = []
749 for line in result.stdout.splitlines():
750 if line.count('|') >= 3:
751 all_devs.extend(map_line(line.split('|')))
752 else:
753 logging.warning("Strange line in the output from lvs: '%s'", line)
754 return all_devs
755
758 """Check if a list of bridges exist on the current node.
759
760 @rtype: boolean
761 @return: C{True} if all of them exist, C{False} otherwise
762
763 """
764 missing = []
765 for bridge in bridges_list:
766 if not utils.BridgeExists(bridge):
767 missing.append(bridge)
768
769 if missing:
770 _Fail("Missing bridges %s", utils.CommaJoin(missing))
771
774 """Provides a list of instances.
775
776 @type hypervisor_list: list
777 @param hypervisor_list: the list of hypervisors to query information
778
779 @rtype: list
780 @return: a list of all running instances on the current node
781 - instance1.example.com
782 - instance2.example.com
783
784 """
785 results = []
786 for hname in hypervisor_list:
787 try:
788 names = hypervisor.GetHypervisor(hname).ListInstances()
789 results.extend(names)
790 except errors.HypervisorError, err:
791 _Fail("Error enumerating instances (hypervisor %s): %s",
792 hname, err, exc=True)
793
794 return results
795
798 """Gives back the information about an instance as a dictionary.
799
800 @type instance: string
801 @param instance: the instance name
802 @type hname: string
803 @param hname: the hypervisor type of the instance
804
805 @rtype: dict
806 @return: dictionary with the following keys:
807 - memory: memory size of instance (int)
808 - state: xen state of instance (string)
809 - time: cpu time of instance (float)
810
811 """
812 output = {}
813
814 iinfo = hypervisor.GetHypervisor(hname).GetInstanceInfo(instance)
815 if iinfo is not None:
816 output['memory'] = iinfo[2]
817 output['state'] = iinfo[4]
818 output['time'] = iinfo[5]
819
820 return output
821
824 """Gives whether an instance can be migrated.
825
826 @type instance: L{objects.Instance}
827 @param instance: object representing the instance to be checked.
828
829 @rtype: tuple
830 @return: tuple of (result, description) where:
831 - result: whether the instance can be migrated or not
832 - description: a description of the issue, if relevant
833
834 """
835 hyper = hypervisor.GetHypervisor(instance.hypervisor)
836 iname = instance.name
837 if iname not in hyper.ListInstances():
838 _Fail("Instance %s is not running", iname)
839
840 for idx in range(len(instance.disks)):
841 link_name = _GetBlockDevSymlinkPath(iname, idx)
842 if not os.path.islink(link_name):
843 logging.warning("Instance %s is missing symlink %s for disk %d",
844 iname, link_name, idx)
845
848 """Gather data about all instances.
849
850 This is the equivalent of L{GetInstanceInfo}, except that it
851 computes data for all instances at once, thus being faster if one
852 needs data about more than one instance.
853
854 @type hypervisor_list: list
855 @param hypervisor_list: list of hypervisors to query for instance data
856
857 @rtype: dict
858 @return: dictionary of instance: data, with data having the following keys:
859 - memory: memory size of instance (int)
860 - state: xen state of instance (string)
861 - time: cpu time of instance (float)
862 - vcpus: the number of vcpus
863
864 """
865 output = {}
866
867 for hname in hypervisor_list:
868 iinfo = hypervisor.GetHypervisor(hname).GetAllInstancesInfo()
869 if iinfo:
870 for name, _, memory, vcpus, state, times in iinfo:
871 value = {
872 'memory': memory,
873 'vcpus': vcpus,
874 'state': state,
875 'time': times,
876 }
877 if name in output:
878
879
880
881 for key in 'memory', 'vcpus':
882 if value[key] != output[name][key]:
883 _Fail("Instance %s is running twice"
884 " with different parameters", name)
885 output[name] = value
886
887 return output
888
891 """Compute the OS log filename for a given instance and operation.
892
893 The instance name and os name are passed in as strings since not all
894 operations have these as part of an instance object.
895
896 @type kind: string
897 @param kind: the operation type (e.g. add, import, etc.)
898 @type os_name: string
899 @param os_name: the os name
900 @type instance: string
901 @param instance: the name of the instance being imported/added/etc.
902
903 """
904
905 base = ("%s-%s-%s-%s.log" %
906 (kind, os_name, instance, utils.TimestampForFilename()))
907 return utils.PathJoin(constants.LOG_OS_DIR, base)
908
911 """Add an OS to an instance.
912
913 @type instance: L{objects.Instance}
914 @param instance: Instance whose OS is to be installed
915 @type reinstall: boolean
916 @param reinstall: whether this is an instance reinstall
917 @type debug: integer
918 @param debug: debug level, passed to the OS scripts
919 @rtype: None
920
921 """
922 inst_os = OSFromDisk(instance.os)
923
924 create_env = OSEnvironment(instance, inst_os, debug)
925 if reinstall:
926 create_env['INSTANCE_REINSTALL'] = "1"
927
928 logfile = _InstanceLogName("add", instance.os, instance.name)
929
930 result = utils.RunCmd([inst_os.create_script], env=create_env,
931 cwd=inst_os.path, output=logfile,)
932 if result.failed:
933 logging.error("os create command '%s' returned error: %s, logfile: %s,"
934 " output: %s", result.cmd, result.fail_reason, logfile,
935 result.output)
936 lines = [utils.SafeEncode(val)
937 for val in utils.TailFile(logfile, lines=20)]
938 _Fail("OS create script failed (%s), last lines in the"
939 " log file:\n%s", result.fail_reason, "\n".join(lines), log=False)
940
943 """Run the OS rename script for an instance.
944
945 @type instance: L{objects.Instance}
946 @param instance: Instance whose OS is to be installed
947 @type old_name: string
948 @param old_name: previous instance name
949 @type debug: integer
950 @param debug: debug level, passed to the OS scripts
951 @rtype: boolean
952 @return: the success of the operation
953
954 """
955 inst_os = OSFromDisk(instance.os)
956
957 rename_env = OSEnvironment(instance, inst_os, debug)
958 rename_env['OLD_INSTANCE_NAME'] = old_name
959
960 logfile = _InstanceLogName("rename", instance.os,
961 "%s-%s" % (old_name, instance.name))
962
963 result = utils.RunCmd([inst_os.rename_script], env=rename_env,
964 cwd=inst_os.path, output=logfile)
965
966 if result.failed:
967 logging.error("os create command '%s' returned error: %s output: %s",
968 result.cmd, result.fail_reason, result.output)
969 lines = [utils.SafeEncode(val)
970 for val in utils.TailFile(logfile, lines=20)]
971 _Fail("OS rename script failed (%s), last lines in the"
972 " log file:\n%s", result.fail_reason, "\n".join(lines), log=False)
973
978
981 """Set up symlinks to a instance's block device.
982
983 This is an auxiliary function run when an instance is start (on the primary
984 node) or when an instance is migrated (on the target node).
985
986
987 @param instance_name: the name of the target instance
988 @param device_path: path of the physical block device, on the node
989 @param idx: the disk index
990 @return: absolute path to the disk's symlink
991
992 """
993 link_name = _GetBlockDevSymlinkPath(instance_name, idx)
994 try:
995 os.symlink(device_path, link_name)
996 except OSError, err:
997 if err.errno == errno.EEXIST:
998 if (not os.path.islink(link_name) or
999 os.readlink(link_name) != device_path):
1000 os.remove(link_name)
1001 os.symlink(device_path, link_name)
1002 else:
1003 raise
1004
1005 return link_name
1006
1009 """Remove the block device symlinks belonging to the given instance.
1010
1011 """
1012 for idx, _ in enumerate(disks):
1013 link_name = _GetBlockDevSymlinkPath(instance_name, idx)
1014 if os.path.islink(link_name):
1015 try:
1016 os.remove(link_name)
1017 except OSError:
1018 logging.exception("Can't remove symlink '%s'", link_name)
1019
1022 """Set up an instance's block device(s).
1023
1024 This is run on the primary node at instance startup. The block
1025 devices must be already assembled.
1026
1027 @type instance: L{objects.Instance}
1028 @param instance: the instance whose disks we shoul assemble
1029 @rtype: list
1030 @return: list of (disk_object, device_path)
1031
1032 """
1033 block_devices = []
1034 for idx, disk in enumerate(instance.disks):
1035 device = _RecursiveFindBD(disk)
1036 if device is None:
1037 raise errors.BlockDeviceError("Block device '%s' is not set up." %
1038 str(disk))
1039 device.Open()
1040 try:
1041 link_name = _SymlinkBlockDev(instance.name, device.dev_path, idx)
1042 except OSError, e:
1043 raise errors.BlockDeviceError("Cannot create block device symlink: %s" %
1044 e.strerror)
1045
1046 block_devices.append((disk, link_name))
1047
1048 return block_devices
1049
1052 """Start an instance.
1053
1054 @type instance: L{objects.Instance}
1055 @param instance: the instance object
1056 @rtype: None
1057
1058 """
1059 running_instances = GetInstanceList([instance.hypervisor])
1060
1061 if instance.name in running_instances:
1062 logging.info("Instance %s already running, not starting", instance.name)
1063 return
1064
1065 try:
1066 block_devices = _GatherAndLinkBlockDevs(instance)
1067 hyper = hypervisor.GetHypervisor(instance.hypervisor)
1068 hyper.StartInstance(instance, block_devices)
1069 except errors.BlockDeviceError, err:
1070 _Fail("Block device error: %s", err, exc=True)
1071 except errors.HypervisorError, err:
1072 _RemoveBlockDevLinks(instance.name, instance.disks)
1073 _Fail("Hypervisor error: %s", err, exc=True)
1074
1077 """Shut an instance down.
1078
1079 @note: this functions uses polling with a hardcoded timeout.
1080
1081 @type instance: L{objects.Instance}
1082 @param instance: the instance object
1083 @type timeout: integer
1084 @param timeout: maximum timeout for soft shutdown
1085 @rtype: None
1086
1087 """
1088 hv_name = instance.hypervisor
1089 hyper = hypervisor.GetHypervisor(hv_name)
1090 iname = instance.name
1091
1092 if instance.name not in hyper.ListInstances():
1093 logging.info("Instance %s not running, doing nothing", iname)
1094 return
1095
1096 class _TryShutdown:
1097 def __init__(self):
1098 self.tried_once = False
1099
1100 def __call__(self):
1101 if iname not in hyper.ListInstances():
1102 return
1103
1104 try:
1105 hyper.StopInstance(instance, retry=self.tried_once)
1106 except errors.HypervisorError, err:
1107 if iname not in hyper.ListInstances():
1108
1109
1110 return
1111
1112 _Fail("Failed to stop instance %s: %s", iname, err)
1113
1114 self.tried_once = True
1115
1116 raise utils.RetryAgain()
1117
1118 try:
1119 utils.Retry(_TryShutdown(), 5, timeout)
1120 except utils.RetryTimeout:
1121
1122 logging.error("Shutdown of '%s' unsuccessful, forcing", iname)
1123
1124 try:
1125 hyper.StopInstance(instance, force=True)
1126 except errors.HypervisorError, err:
1127 if iname in hyper.ListInstances():
1128
1129
1130 _Fail("Failed to force stop instance %s: %s", iname, err)
1131
1132 time.sleep(1)
1133
1134 if iname in hyper.ListInstances():
1135 _Fail("Could not shutdown instance %s even by destroy", iname)
1136
1137 try:
1138 hyper.CleanupInstance(instance.name)
1139 except errors.HypervisorError, err:
1140 logging.warning("Failed to execute post-shutdown cleanup step: %s", err)
1141
1142 _RemoveBlockDevLinks(iname, instance.disks)
1143
1146 """Reboot an instance.
1147
1148 @type instance: L{objects.Instance}
1149 @param instance: the instance object to reboot
1150 @type reboot_type: str
1151 @param reboot_type: the type of reboot, one the following
1152 constants:
1153 - L{constants.INSTANCE_REBOOT_SOFT}: only reboot the
1154 instance OS, do not recreate the VM
1155 - L{constants.INSTANCE_REBOOT_HARD}: tear down and
1156 restart the VM (at the hypervisor level)
1157 - the other reboot type (L{constants.INSTANCE_REBOOT_FULL}) is
1158 not accepted here, since that mode is handled differently, in
1159 cmdlib, and translates into full stop and start of the
1160 instance (instead of a call_instance_reboot RPC)
1161 @type shutdown_timeout: integer
1162 @param shutdown_timeout: maximum timeout for soft shutdown
1163 @rtype: None
1164
1165 """
1166 running_instances = GetInstanceList([instance.hypervisor])
1167
1168 if instance.name not in running_instances:
1169 _Fail("Cannot reboot instance %s that is not running", instance.name)
1170
1171 hyper = hypervisor.GetHypervisor(instance.hypervisor)
1172 if reboot_type == constants.INSTANCE_REBOOT_SOFT:
1173 try:
1174 hyper.RebootInstance(instance)
1175 except errors.HypervisorError, err:
1176 _Fail("Failed to soft reboot instance %s: %s", instance.name, err)
1177 elif reboot_type == constants.INSTANCE_REBOOT_HARD:
1178 try:
1179 InstanceShutdown(instance, shutdown_timeout)
1180 return StartInstance(instance)
1181 except errors.HypervisorError, err:
1182 _Fail("Failed to hard reboot instance %s: %s", instance.name, err)
1183 else:
1184 _Fail("Invalid reboot_type received: %s", reboot_type)
1185
1200
1203 """Prepare the node to accept an instance.
1204
1205 @type instance: L{objects.Instance}
1206 @param instance: the instance definition
1207 @type info: string/data (opaque)
1208 @param info: migration information, from the source node
1209 @type target: string
1210 @param target: target host (usually ip), on this node
1211
1212 """
1213 hyper = hypervisor.GetHypervisor(instance.hypervisor)
1214 try:
1215 hyper.AcceptInstance(instance, info, target)
1216 except errors.HypervisorError, err:
1217 _Fail("Failed to accept instance: %s", err, exc=True)
1218
1221 """Finalize any preparation to accept an instance.
1222
1223 @type instance: L{objects.Instance}
1224 @param instance: the instance definition
1225 @type info: string/data (opaque)
1226 @param info: migration information, from the source node
1227 @type success: boolean
1228 @param success: whether the migration was a success or a failure
1229
1230 """
1231 hyper = hypervisor.GetHypervisor(instance.hypervisor)
1232 try:
1233 hyper.FinalizeMigration(instance, info, success)
1234 except errors.HypervisorError, err:
1235 _Fail("Failed to finalize migration: %s", err, exc=True)
1236
1239 """Migrates an instance to another node.
1240
1241 @type instance: L{objects.Instance}
1242 @param instance: the instance definition
1243 @type target: string
1244 @param target: the target node name
1245 @type live: boolean
1246 @param live: whether the migration should be done live or not (the
1247 interpretation of this parameter is left to the hypervisor)
1248 @rtype: tuple
1249 @return: a tuple of (success, msg) where:
1250 - succes is a boolean denoting the success/failure of the operation
1251 - msg is a string with details in case of failure
1252
1253 """
1254 hyper = hypervisor.GetHypervisor(instance.hypervisor)
1255
1256 try:
1257 hyper.MigrateInstance(instance, target, live)
1258 except errors.HypervisorError, err:
1259 _Fail("Failed to migrate instance: %s", err, exc=True)
1260
1263 """Creates a block device for an instance.
1264
1265 @type disk: L{objects.Disk}
1266 @param disk: the object describing the disk we should create
1267 @type size: int
1268 @param size: the size of the physical underlying device, in MiB
1269 @type owner: str
1270 @param owner: the name of the instance for which disk is created,
1271 used for device cache data
1272 @type on_primary: boolean
1273 @param on_primary: indicates if it is the primary node or not
1274 @type info: string
1275 @param info: string that will be sent to the physical device
1276 creation, used for example to set (LVM) tags on LVs
1277
1278 @return: the new unique_id of the device (this can sometime be
1279 computed only after creation), or None. On secondary nodes,
1280 it's not required to return anything.
1281
1282 """
1283
1284
1285 clist = []
1286 if disk.children:
1287 for child in disk.children:
1288 try:
1289 crdev = _RecursiveAssembleBD(child, owner, on_primary)
1290 except errors.BlockDeviceError, err:
1291 _Fail("Can't assemble device %s: %s", child, err)
1292 if on_primary or disk.AssembleOnSecondary():
1293
1294
1295 try:
1296
1297 crdev.Open()
1298 except errors.BlockDeviceError, err:
1299 _Fail("Can't make child '%s' read-write: %s", child, err)
1300 clist.append(crdev)
1301
1302 try:
1303 device = bdev.Create(disk.dev_type, disk.physical_id, clist, disk.size)
1304 except errors.BlockDeviceError, err:
1305 _Fail("Can't create block device: %s", err)
1306
1307 if on_primary or disk.AssembleOnSecondary():
1308 try:
1309 device.Assemble()
1310 except errors.BlockDeviceError, err:
1311 _Fail("Can't assemble device after creation, unusual event: %s", err)
1312 device.SetSyncSpeed(constants.SYNC_SPEED)
1313 if on_primary or disk.OpenOnSecondary():
1314 try:
1315 device.Open(force=True)
1316 except errors.BlockDeviceError, err:
1317 _Fail("Can't make device r/w after creation, unusual event: %s", err)
1318 DevCacheManager.UpdateCache(device.dev_path, owner,
1319 on_primary, disk.iv_name)
1320
1321 device.SetInfo(info)
1322
1323 return device.unique_id
1324
1327 """This function actually wipes the device.
1328
1329 @param path: The path to the device to wipe
1330 @param offset: The offset in MiB in the file
1331 @param size: The size in MiB to write
1332
1333 """
1334 cmd = [constants.DD_CMD, "if=/dev/zero", "seek=%d" % offset,
1335 "bs=%d" % constants.WIPE_BLOCK_SIZE, "oflag=direct", "of=%s" % path,
1336 "count=%d" % size]
1337 result = utils.RunCmd(cmd)
1338
1339 if result.failed:
1340 _Fail("Wipe command '%s' exited with error: %s; output: %s", result.cmd,
1341 result.fail_reason, result.output)
1342
1345 """Wipes a block device.
1346
1347 @type disk: L{objects.Disk}
1348 @param disk: the disk object we want to wipe
1349 @type offset: int
1350 @param offset: The offset in MiB in the file
1351 @type size: int
1352 @param size: The size in MiB to write
1353
1354 """
1355 try:
1356 rdev = _RecursiveFindBD(disk)
1357 except errors.BlockDeviceError:
1358 rdev = None
1359
1360 if not rdev:
1361 _Fail("Cannot execute wipe for device %s: device not found", disk.iv_name)
1362
1363
1364 if offset > rdev.size:
1365 _Fail("Offset is bigger than device size")
1366 if (offset + size) > rdev.size:
1367 _Fail("The provided offset and size to wipe is bigger than device size")
1368
1369 _WipeDevice(rdev.dev_path, offset, size)
1370
1373 """Pause or resume the sync of the block device.
1374
1375 @type disks: list of L{objects.Disk}
1376 @param disks: the disks object we want to pause/resume
1377 @type pause: bool
1378 @param pause: Wheater to pause or resume
1379
1380 """
1381 success = []
1382 for disk in disks:
1383 try:
1384 rdev = _RecursiveFindBD(disk)
1385 except errors.BlockDeviceError:
1386 rdev = None
1387
1388 if not rdev:
1389 success.append((False, ("Cannot change sync for device %s:"
1390 " device not found" % disk.iv_name)))
1391 continue
1392
1393 result = rdev.PauseResumeSync(pause)
1394
1395 if result:
1396 success.append((result, None))
1397 else:
1398 if pause:
1399 msg = "Pause"
1400 else:
1401 msg = "Resume"
1402 success.append((result, "%s for device %s failed" % (msg, disk.iv_name)))
1403
1404 return success
1405
1408 """Remove a block device.
1409
1410 @note: This is intended to be called recursively.
1411
1412 @type disk: L{objects.Disk}
1413 @param disk: the disk object we should remove
1414 @rtype: boolean
1415 @return: the success of the operation
1416
1417 """
1418 msgs = []
1419 try:
1420 rdev = _RecursiveFindBD(disk)
1421 except errors.BlockDeviceError, err:
1422
1423 logging.info("Can't attach to device %s in remove", disk)
1424 rdev = None
1425 if rdev is not None:
1426 r_path = rdev.dev_path
1427 try:
1428 rdev.Remove()
1429 except errors.BlockDeviceError, err:
1430 msgs.append(str(err))
1431 if not msgs:
1432 DevCacheManager.RemoveCache(r_path)
1433
1434 if disk.children:
1435 for child in disk.children:
1436 try:
1437 BlockdevRemove(child)
1438 except RPCFail, err:
1439 msgs.append(str(err))
1440
1441 if msgs:
1442 _Fail("; ".join(msgs))
1443
1446 """Activate a block device for an instance.
1447
1448 This is run on the primary and secondary nodes for an instance.
1449
1450 @note: this function is called recursively.
1451
1452 @type disk: L{objects.Disk}
1453 @param disk: the disk we try to assemble
1454 @type owner: str
1455 @param owner: the name of the instance which owns the disk
1456 @type as_primary: boolean
1457 @param as_primary: if we should make the block device
1458 read/write
1459
1460 @return: the assembled device or None (in case no device
1461 was assembled)
1462 @raise errors.BlockDeviceError: in case there is an error
1463 during the activation of the children or the device
1464 itself
1465
1466 """
1467 children = []
1468 if disk.children:
1469 mcn = disk.ChildrenNeeded()
1470 if mcn == -1:
1471 mcn = 0
1472 else:
1473 mcn = len(disk.children) - mcn
1474 for chld_disk in disk.children:
1475 try:
1476 cdev = _RecursiveAssembleBD(chld_disk, owner, as_primary)
1477 except errors.BlockDeviceError, err:
1478 if children.count(None) >= mcn:
1479 raise
1480 cdev = None
1481 logging.error("Error in child activation (but continuing): %s",
1482 str(err))
1483 children.append(cdev)
1484
1485 if as_primary or disk.AssembleOnSecondary():
1486 r_dev = bdev.Assemble(disk.dev_type, disk.physical_id, children, disk.size)
1487 r_dev.SetSyncSpeed(constants.SYNC_SPEED)
1488 result = r_dev
1489 if as_primary or disk.OpenOnSecondary():
1490 r_dev.Open()
1491 DevCacheManager.UpdateCache(r_dev.dev_path, owner,
1492 as_primary, disk.iv_name)
1493
1494 else:
1495 result = True
1496 return result
1497
1500 """Activate a block device for an instance.
1501
1502 This is a wrapper over _RecursiveAssembleBD.
1503
1504 @rtype: str or boolean
1505 @return: a C{/dev/...} path for primary nodes, and
1506 C{True} for secondary nodes
1507
1508 """
1509 try:
1510 result = _RecursiveAssembleBD(disk, owner, as_primary)
1511 if isinstance(result, bdev.BlockDev):
1512
1513 result = result.dev_path
1514 if as_primary:
1515 _SymlinkBlockDev(owner, result, idx)
1516 except errors.BlockDeviceError, err:
1517 _Fail("Error while assembling disk: %s", err, exc=True)
1518 except OSError, err:
1519 _Fail("Error while symlinking disk: %s", err, exc=True)
1520
1521 return result
1522
1525 """Shut down a block device.
1526
1527 First, if the device is assembled (Attach() is successful), then
1528 the device is shutdown. Then the children of the device are
1529 shutdown.
1530
1531 This function is called recursively. Note that we don't cache the
1532 children or such, as oppossed to assemble, shutdown of different
1533 devices doesn't require that the upper device was active.
1534
1535 @type disk: L{objects.Disk}
1536 @param disk: the description of the disk we should
1537 shutdown
1538 @rtype: None
1539
1540 """
1541 msgs = []
1542 r_dev = _RecursiveFindBD(disk)
1543 if r_dev is not None:
1544 r_path = r_dev.dev_path
1545 try:
1546 r_dev.Shutdown()
1547 DevCacheManager.RemoveCache(r_path)
1548 except errors.BlockDeviceError, err:
1549 msgs.append(str(err))
1550
1551 if disk.children:
1552 for child in disk.children:
1553 try:
1554 BlockdevShutdown(child)
1555 except RPCFail, err:
1556 msgs.append(str(err))
1557
1558 if msgs:
1559 _Fail("; ".join(msgs))
1560
1563 """Extend a mirrored block device.
1564
1565 @type parent_cdev: L{objects.Disk}
1566 @param parent_cdev: the disk to which we should add children
1567 @type new_cdevs: list of L{objects.Disk}
1568 @param new_cdevs: the list of children which we should add
1569 @rtype: None
1570
1571 """
1572 parent_bdev = _RecursiveFindBD(parent_cdev)
1573 if parent_bdev is None:
1574 _Fail("Can't find parent device '%s' in add children", parent_cdev)
1575 new_bdevs = [_RecursiveFindBD(disk) for disk in new_cdevs]
1576 if new_bdevs.count(None) > 0:
1577 _Fail("Can't find new device(s) to add: %s:%s", new_bdevs, new_cdevs)
1578 parent_bdev.AddChildren(new_bdevs)
1579
1582 """Shrink a mirrored block device.
1583
1584 @type parent_cdev: L{objects.Disk}
1585 @param parent_cdev: the disk from which we should remove children
1586 @type new_cdevs: list of L{objects.Disk}
1587 @param new_cdevs: the list of children which we should remove
1588 @rtype: None
1589
1590 """
1591 parent_bdev = _RecursiveFindBD(parent_cdev)
1592 if parent_bdev is None:
1593 _Fail("Can't find parent device '%s' in remove children", parent_cdev)
1594 devs = []
1595 for disk in new_cdevs:
1596 rpath = disk.StaticDevPath()
1597 if rpath is None:
1598 bd = _RecursiveFindBD(disk)
1599 if bd is None:
1600 _Fail("Can't find device %s while removing children", disk)
1601 else:
1602 devs.append(bd.dev_path)
1603 else:
1604 if not utils.IsNormAbsPath(rpath):
1605 _Fail("Strange path returned from StaticDevPath: '%s'", rpath)
1606 devs.append(rpath)
1607 parent_bdev.RemoveChildren(devs)
1608
1611 """Get the mirroring status of a list of devices.
1612
1613 @type disks: list of L{objects.Disk}
1614 @param disks: the list of disks which we should query
1615 @rtype: disk
1616 @return: List of L{objects.BlockDevStatus}, one for each disk
1617 @raise errors.BlockDeviceError: if any of the disks cannot be
1618 found
1619
1620 """
1621 stats = []
1622 for dsk in disks:
1623 rbd = _RecursiveFindBD(dsk)
1624 if rbd is None:
1625 _Fail("Can't find device %s", dsk)
1626
1627 stats.append(rbd.CombinedSyncStatus())
1628
1629 return stats
1630
1633 """Get the mirroring status of a list of devices.
1634
1635 @type disks: list of L{objects.Disk}
1636 @param disks: the list of disks which we should query
1637 @rtype: disk
1638 @return: List of tuples, (bool, status), one for each disk; bool denotes
1639 success/failure, status is L{objects.BlockDevStatus} on success, string
1640 otherwise
1641
1642 """
1643 result = []
1644 for disk in disks:
1645 try:
1646 rbd = _RecursiveFindBD(disk)
1647 if rbd is None:
1648 result.append((False, "Can't find device %s" % disk))
1649 continue
1650
1651 status = rbd.CombinedSyncStatus()
1652 except errors.BlockDeviceError, err:
1653 logging.exception("Error while getting disk status")
1654 result.append((False, str(err)))
1655 else:
1656 result.append((True, status))
1657
1658 assert len(disks) == len(result)
1659
1660 return result
1661
1664 """Check if a device is activated.
1665
1666 If so, return information about the real device.
1667
1668 @type disk: L{objects.Disk}
1669 @param disk: the disk object we need to find
1670
1671 @return: None if the device can't be found,
1672 otherwise the device instance
1673
1674 """
1675 children = []
1676 if disk.children:
1677 for chdisk in disk.children:
1678 children.append(_RecursiveFindBD(chdisk))
1679
1680 return bdev.FindDevice(disk.dev_type, disk.physical_id, children, disk.size)
1681
1684 """Opens the underlying block device of a disk.
1685
1686 @type disk: L{objects.Disk}
1687 @param disk: the disk object we want to open
1688
1689 """
1690 real_disk = _RecursiveFindBD(disk)
1691 if real_disk is None:
1692 _Fail("Block device '%s' is not set up", disk)
1693
1694 real_disk.Open()
1695
1696 return real_disk
1697
1700 """Check if a device is activated.
1701
1702 If it is, return information about the real device.
1703
1704 @type disk: L{objects.Disk}
1705 @param disk: the disk to find
1706 @rtype: None or objects.BlockDevStatus
1707 @return: None if the disk cannot be found, otherwise a the current
1708 information
1709
1710 """
1711 try:
1712 rbd = _RecursiveFindBD(disk)
1713 except errors.BlockDeviceError, err:
1714 _Fail("Failed to find device: %s", err, exc=True)
1715
1716 if rbd is None:
1717 return None
1718
1719 return rbd.GetSyncStatus()
1720
1723 """Computes the size of the given disks.
1724
1725 If a disk is not found, returns None instead.
1726
1727 @type disks: list of L{objects.Disk}
1728 @param disks: the list of disk to compute the size for
1729 @rtype: list
1730 @return: list with elements None if the disk cannot be found,
1731 otherwise the size
1732
1733 """
1734 result = []
1735 for cf in disks:
1736 try:
1737 rbd = _RecursiveFindBD(cf)
1738 except errors.BlockDeviceError:
1739 result.append(None)
1740 continue
1741 if rbd is None:
1742 result.append(None)
1743 else:
1744 result.append(rbd.GetActualSize())
1745 return result
1746
1749 """Export a block device to a remote node.
1750
1751 @type disk: L{objects.Disk}
1752 @param disk: the description of the disk to export
1753 @type dest_node: str
1754 @param dest_node: the destination node to export to
1755 @type dest_path: str
1756 @param dest_path: the destination path on the target node
1757 @type cluster_name: str
1758 @param cluster_name: the cluster name, needed for SSH hostalias
1759 @rtype: None
1760
1761 """
1762 real_disk = _OpenRealBD(disk)
1763
1764
1765 expcmd = utils.BuildShellCmd("set -e; set -o pipefail; "
1766 "dd if=%s bs=1048576 count=%s",
1767 real_disk.dev_path, str(disk.size))
1768
1769
1770
1771
1772
1773
1774
1775 destcmd = utils.BuildShellCmd("dd of=%s conv=nocreat,notrunc bs=65536"
1776 " oflag=dsync", dest_path)
1777
1778 remotecmd = _GetSshRunner(cluster_name).BuildCmd(dest_node,
1779 constants.GANETI_RUNAS,
1780 destcmd)
1781
1782
1783 command = '|'.join([expcmd, utils.ShellQuoteArgs(remotecmd)])
1784
1785 result = utils.RunCmd(["bash", "-c", command])
1786
1787 if result.failed:
1788 _Fail("Disk copy command '%s' returned error: %s"
1789 " output: %s", command, result.fail_reason, result.output)
1790
1791
1792 -def UploadFile(file_name, data, mode, uid, gid, atime, mtime):
1793 """Write a file to the filesystem.
1794
1795 This allows the master to overwrite(!) a file. It will only perform
1796 the operation if the file belongs to a list of configuration files.
1797
1798 @type file_name: str
1799 @param file_name: the target file name
1800 @type data: str
1801 @param data: the new contents of the file
1802 @type mode: int
1803 @param mode: the mode to give the file (can be None)
1804 @type uid: string
1805 @param uid: the owner of the file
1806 @type gid: string
1807 @param gid: the group of the file
1808 @type atime: float
1809 @param atime: the atime to set on the file (can be None)
1810 @type mtime: float
1811 @param mtime: the mtime to set on the file (can be None)
1812 @rtype: None
1813
1814 """
1815 if not os.path.isabs(file_name):
1816 _Fail("Filename passed to UploadFile is not absolute: '%s'", file_name)
1817
1818 if file_name not in _ALLOWED_UPLOAD_FILES:
1819 _Fail("Filename passed to UploadFile not in allowed upload targets: '%s'",
1820 file_name)
1821
1822 raw_data = _Decompress(data)
1823
1824 if not (isinstance(uid, basestring) and isinstance(gid, basestring)):
1825 _Fail("Invalid username/groupname type")
1826
1827 getents = runtime.GetEnts()
1828 uid = getents.LookupUser(uid)
1829 gid = getents.LookupGroup(gid)
1830
1831 utils.SafeWriteFile(file_name, None,
1832 data=raw_data, mode=mode, uid=uid, gid=gid,
1833 atime=atime, mtime=mtime)
1834
1835
1836 -def RunOob(oob_program, command, node, timeout):
1837 """Executes oob_program with given command on given node.
1838
1839 @param oob_program: The path to the executable oob_program
1840 @param command: The command to invoke on oob_program
1841 @param node: The node given as an argument to the program
1842 @param timeout: Timeout after which we kill the oob program
1843
1844 @return: stdout
1845 @raise RPCFail: If execution fails for some reason
1846
1847 """
1848 result = utils.RunCmd([oob_program, command, node], timeout=timeout)
1849
1850 if result.failed:
1851 _Fail("'%s' failed with reason '%s'; output: %s", result.cmd,
1852 result.fail_reason, result.output)
1853
1854 return result.stdout
1855
1858 """Update all ssconf files.
1859
1860 Wrapper around the SimpleStore.WriteFiles.
1861
1862 """
1863 ssconf.SimpleStore().WriteFiles(values)
1864
1867 """Format an EnvironmentError exception.
1868
1869 If the L{err} argument has an errno attribute, it will be looked up
1870 and converted into a textual C{E...} description. Otherwise the
1871 string representation of the error will be returned.
1872
1873 @type err: L{EnvironmentError}
1874 @param err: the exception to format
1875
1876 """
1877 if hasattr(err, 'errno'):
1878 detail = errno.errorcode[err.errno]
1879 else:
1880 detail = str(err)
1881 return detail
1882
1885 """Compute and return the API version of a given OS.
1886
1887 This function will try to read the API version of the OS residing in
1888 the 'os_dir' directory.
1889
1890 @type os_dir: str
1891 @param os_dir: the directory in which we should look for the OS
1892 @rtype: tuple
1893 @return: tuple (status, data) with status denoting the validity and
1894 data holding either the vaid versions or an error message
1895
1896 """
1897 api_file = utils.PathJoin(os_dir, constants.OS_API_FILE)
1898
1899 try:
1900 st = os.stat(api_file)
1901 except EnvironmentError, err:
1902 return False, ("Required file '%s' not found under path %s: %s" %
1903 (constants.OS_API_FILE, os_dir, _ErrnoOrStr(err)))
1904
1905 if not stat.S_ISREG(stat.S_IFMT(st.st_mode)):
1906 return False, ("File '%s' in %s is not a regular file" %
1907 (constants.OS_API_FILE, os_dir))
1908
1909 try:
1910 api_versions = utils.ReadFile(api_file).splitlines()
1911 except EnvironmentError, err:
1912 return False, ("Error while reading the API version file at %s: %s" %
1913 (api_file, _ErrnoOrStr(err)))
1914
1915 try:
1916 api_versions = [int(version.strip()) for version in api_versions]
1917 except (TypeError, ValueError), err:
1918 return False, ("API version(s) can't be converted to integer: %s" %
1919 str(err))
1920
1921 return True, api_versions
1922
1925 """Compute the validity for all OSes.
1926
1927 @type top_dirs: list
1928 @param top_dirs: the list of directories in which to
1929 search (if not given defaults to
1930 L{constants.OS_SEARCH_PATH})
1931 @rtype: list of L{objects.OS}
1932 @return: a list of tuples (name, path, status, diagnose, variants,
1933 parameters, api_version) for all (potential) OSes under all
1934 search paths, where:
1935 - name is the (potential) OS name
1936 - path is the full path to the OS
1937 - status True/False is the validity of the OS
1938 - diagnose is the error message for an invalid OS, otherwise empty
1939 - variants is a list of supported OS variants, if any
1940 - parameters is a list of (name, help) parameters, if any
1941 - api_version is a list of support OS API versions
1942
1943 """
1944 if top_dirs is None:
1945 top_dirs = constants.OS_SEARCH_PATH
1946
1947 result = []
1948 for dir_name in top_dirs:
1949 if os.path.isdir(dir_name):
1950 try:
1951 f_names = utils.ListVisibleFiles(dir_name)
1952 except EnvironmentError, err:
1953 logging.exception("Can't list the OS directory %s: %s", dir_name, err)
1954 break
1955 for name in f_names:
1956 os_path = utils.PathJoin(dir_name, name)
1957 status, os_inst = _TryOSFromDisk(name, base_dir=dir_name)
1958 if status:
1959 diagnose = ""
1960 variants = os_inst.supported_variants
1961 parameters = os_inst.supported_parameters
1962 api_versions = os_inst.api_versions
1963 else:
1964 diagnose = os_inst
1965 variants = parameters = api_versions = []
1966 result.append((name, os_path, status, diagnose, variants,
1967 parameters, api_versions))
1968
1969 return result
1970
1973 """Create an OS instance from disk.
1974
1975 This function will return an OS instance if the given name is a
1976 valid OS name.
1977
1978 @type base_dir: string
1979 @keyword base_dir: Base directory containing OS installations.
1980 Defaults to a search in all the OS_SEARCH_PATH dirs.
1981 @rtype: tuple
1982 @return: success and either the OS instance if we find a valid one,
1983 or error message
1984
1985 """
1986 if base_dir is None:
1987 os_dir = utils.FindFile(name, constants.OS_SEARCH_PATH, os.path.isdir)
1988 else:
1989 os_dir = utils.FindFile(name, [base_dir], os.path.isdir)
1990
1991 if os_dir is None:
1992 return False, "Directory for OS %s not found in search path" % name
1993
1994 status, api_versions = _OSOndiskAPIVersion(os_dir)
1995 if not status:
1996
1997 return status, api_versions
1998
1999 if not constants.OS_API_VERSIONS.intersection(api_versions):
2000 return False, ("API version mismatch for path '%s': found %s, want %s." %
2001 (os_dir, api_versions, constants.OS_API_VERSIONS))
2002
2003
2004 os_files = dict.fromkeys(constants.OS_SCRIPTS)
2005
2006 if max(api_versions) >= constants.OS_API_V15:
2007 os_files[constants.OS_VARIANTS_FILE] = ''
2008
2009 if max(api_versions) >= constants.OS_API_V20:
2010 os_files[constants.OS_PARAMETERS_FILE] = ''
2011 else:
2012 del os_files[constants.OS_SCRIPT_VERIFY]
2013
2014 for filename in os_files:
2015 os_files[filename] = utils.PathJoin(os_dir, filename)
2016
2017 try:
2018 st = os.stat(os_files[filename])
2019 except EnvironmentError, err:
2020 return False, ("File '%s' under path '%s' is missing (%s)" %
2021 (filename, os_dir, _ErrnoOrStr(err)))
2022
2023 if not stat.S_ISREG(stat.S_IFMT(st.st_mode)):
2024 return False, ("File '%s' under path '%s' is not a regular file" %
2025 (filename, os_dir))
2026
2027 if filename in constants.OS_SCRIPTS:
2028 if stat.S_IMODE(st.st_mode) & stat.S_IXUSR != stat.S_IXUSR:
2029 return False, ("File '%s' under path '%s' is not executable" %
2030 (filename, os_dir))
2031
2032 variants = []
2033 if constants.OS_VARIANTS_FILE in os_files:
2034 variants_file = os_files[constants.OS_VARIANTS_FILE]
2035 try:
2036 variants = utils.ReadFile(variants_file).splitlines()
2037 except EnvironmentError, err:
2038 return False, ("Error while reading the OS variants file at %s: %s" %
2039 (variants_file, _ErrnoOrStr(err)))
2040 if not variants:
2041 return False, ("No supported os variant found")
2042
2043 parameters = []
2044 if constants.OS_PARAMETERS_FILE in os_files:
2045 parameters_file = os_files[constants.OS_PARAMETERS_FILE]
2046 try:
2047 parameters = utils.ReadFile(parameters_file).splitlines()
2048 except EnvironmentError, err:
2049 return False, ("Error while reading the OS parameters file at %s: %s" %
2050 (parameters_file, _ErrnoOrStr(err)))
2051 parameters = [v.split(None, 1) for v in parameters]
2052
2053 os_obj = objects.OS(name=name, path=os_dir,
2054 create_script=os_files[constants.OS_SCRIPT_CREATE],
2055 export_script=os_files[constants.OS_SCRIPT_EXPORT],
2056 import_script=os_files[constants.OS_SCRIPT_IMPORT],
2057 rename_script=os_files[constants.OS_SCRIPT_RENAME],
2058 verify_script=os_files.get(constants.OS_SCRIPT_VERIFY,
2059 None),
2060 supported_variants=variants,
2061 supported_parameters=parameters,
2062 api_versions=api_versions)
2063 return True, os_obj
2064
2067 """Create an OS instance from disk.
2068
2069 This function will return an OS instance if the given name is a
2070 valid OS name. Otherwise, it will raise an appropriate
2071 L{RPCFail} exception, detailing why this is not a valid OS.
2072
2073 This is just a wrapper over L{_TryOSFromDisk}, which doesn't raise
2074 an exception but returns true/false status data.
2075
2076 @type base_dir: string
2077 @keyword base_dir: Base directory containing OS installations.
2078 Defaults to a search in all the OS_SEARCH_PATH dirs.
2079 @rtype: L{objects.OS}
2080 @return: the OS instance if we find a valid one
2081 @raise RPCFail: if we don't find a valid OS
2082
2083 """
2084 name_only = objects.OS.GetName(name)
2085 status, payload = _TryOSFromDisk(name_only, base_dir)
2086
2087 if not status:
2088 _Fail(payload)
2089
2090 return payload
2091
2092
2093 -def OSCoreEnv(os_name, inst_os, os_params, debug=0):
2094 """Calculate the basic environment for an os script.
2095
2096 @type os_name: str
2097 @param os_name: full operating system name (including variant)
2098 @type inst_os: L{objects.OS}
2099 @param inst_os: operating system for which the environment is being built
2100 @type os_params: dict
2101 @param os_params: the OS parameters
2102 @type debug: integer
2103 @param debug: debug level (0 or 1, for OS Api 10)
2104 @rtype: dict
2105 @return: dict of environment variables
2106 @raise errors.BlockDeviceError: if the block device
2107 cannot be found
2108
2109 """
2110 result = {}
2111 api_version = \
2112 max(constants.OS_API_VERSIONS.intersection(inst_os.api_versions))
2113 result['OS_API_VERSION'] = '%d' % api_version
2114 result['OS_NAME'] = inst_os.name
2115 result['DEBUG_LEVEL'] = '%d' % debug
2116
2117
2118 if api_version >= constants.OS_API_V15:
2119 variant = objects.OS.GetVariant(os_name)
2120 if not variant:
2121 variant = inst_os.supported_variants[0]
2122 result['OS_VARIANT'] = variant
2123
2124
2125 for pname, pvalue in os_params.items():
2126 result['OSP_%s' % pname.upper()] = pvalue
2127
2128 return result
2129
2132 """Calculate the environment for an os script.
2133
2134 @type instance: L{objects.Instance}
2135 @param instance: target instance for the os script run
2136 @type inst_os: L{objects.OS}
2137 @param inst_os: operating system for which the environment is being built
2138 @type debug: integer
2139 @param debug: debug level (0 or 1, for OS Api 10)
2140 @rtype: dict
2141 @return: dict of environment variables
2142 @raise errors.BlockDeviceError: if the block device
2143 cannot be found
2144
2145 """
2146 result = OSCoreEnv(instance.os, inst_os, instance.osparams, debug=debug)
2147
2148 for attr in ["name", "os", "uuid", "ctime", "mtime", "primary_node"]:
2149 result["INSTANCE_%s" % attr.upper()] = str(getattr(instance, attr))
2150
2151 result['HYPERVISOR'] = instance.hypervisor
2152 result['DISK_COUNT'] = '%d' % len(instance.disks)
2153 result['NIC_COUNT'] = '%d' % len(instance.nics)
2154 result['INSTANCE_SECONDARY_NODES'] = \
2155 ('%s' % " ".join(instance.secondary_nodes))
2156
2157
2158 for idx, disk in enumerate(instance.disks):
2159 real_disk = _OpenRealBD(disk)
2160 result['DISK_%d_PATH' % idx] = real_disk.dev_path
2161 result['DISK_%d_ACCESS' % idx] = disk.mode
2162 if constants.HV_DISK_TYPE in instance.hvparams:
2163 result['DISK_%d_FRONTEND_TYPE' % idx] = \
2164 instance.hvparams[constants.HV_DISK_TYPE]
2165 if disk.dev_type in constants.LDS_BLOCK:
2166 result['DISK_%d_BACKEND_TYPE' % idx] = 'block'
2167 elif disk.dev_type == constants.LD_FILE:
2168 result['DISK_%d_BACKEND_TYPE' % idx] = \
2169 'file:%s' % disk.physical_id[0]
2170
2171
2172 for idx, nic in enumerate(instance.nics):
2173 result['NIC_%d_MAC' % idx] = nic.mac
2174 if nic.ip:
2175 result['NIC_%d_IP' % idx] = nic.ip
2176 result['NIC_%d_MODE' % idx] = nic.nicparams[constants.NIC_MODE]
2177 if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
2178 result['NIC_%d_BRIDGE' % idx] = nic.nicparams[constants.NIC_LINK]
2179 if nic.nicparams[constants.NIC_LINK]:
2180 result['NIC_%d_LINK' % idx] = nic.nicparams[constants.NIC_LINK]
2181 if constants.HV_NIC_TYPE in instance.hvparams:
2182 result['NIC_%d_FRONTEND_TYPE' % idx] = \
2183 instance.hvparams[constants.HV_NIC_TYPE]
2184
2185
2186 for source, kind in [(instance.beparams, "BE"), (instance.hvparams, "HV")]:
2187 for key, value in source.items():
2188 result["INSTANCE_%s_%s" % (kind, key)] = str(value)
2189
2190 return result
2191
2194 """Grow a stack of block devices.
2195
2196 This function is called recursively, with the childrens being the
2197 first ones to resize.
2198
2199 @type disk: L{objects.Disk}
2200 @param disk: the disk to be grown
2201 @rtype: (status, result)
2202 @return: a tuple with the status of the operation
2203 (True/False), and the errors message if status
2204 is False
2205
2206 """
2207 r_dev = _RecursiveFindBD(disk)
2208 if r_dev is None:
2209 _Fail("Cannot find block device %s", disk)
2210
2211 try:
2212 r_dev.Grow(amount)
2213 except errors.BlockDeviceError, err:
2214 _Fail("Failed to grow block device: %s", err, exc=True)
2215
2218 """Create a snapshot copy of a block device.
2219
2220 This function is called recursively, and the snapshot is actually created
2221 just for the leaf lvm backend device.
2222
2223 @type disk: L{objects.Disk}
2224 @param disk: the disk to be snapshotted
2225 @rtype: string
2226 @return: snapshot disk ID as (vg, lv)
2227
2228 """
2229 if disk.dev_type == constants.LD_DRBD8:
2230 if not disk.children:
2231 _Fail("DRBD device '%s' without backing storage cannot be snapshotted",
2232 disk.unique_id)
2233 return BlockdevSnapshot(disk.children[0])
2234 elif disk.dev_type == constants.LD_LV:
2235 r_dev = _RecursiveFindBD(disk)
2236 if r_dev is not None:
2237
2238
2239 return r_dev.Snapshot(disk.size)
2240 else:
2241 _Fail("Cannot find block device %s", disk)
2242 else:
2243 _Fail("Cannot snapshot non-lvm block device '%s' of type '%s'",
2244 disk.unique_id, disk.dev_type)
2245
2248 """Write out the export configuration information.
2249
2250 @type instance: L{objects.Instance}
2251 @param instance: the instance which we export, used for
2252 saving configuration
2253 @type snap_disks: list of L{objects.Disk}
2254 @param snap_disks: list of snapshot block devices, which
2255 will be used to get the actual name of the dump file
2256
2257 @rtype: None
2258
2259 """
2260 destdir = utils.PathJoin(constants.EXPORT_DIR, instance.name + ".new")
2261 finaldestdir = utils.PathJoin(constants.EXPORT_DIR, instance.name)
2262
2263 config = objects.SerializableConfigParser()
2264
2265 config.add_section(constants.INISECT_EXP)
2266 config.set(constants.INISECT_EXP, 'version', '0')
2267 config.set(constants.INISECT_EXP, 'timestamp', '%d' % int(time.time()))
2268 config.set(constants.INISECT_EXP, 'source', instance.primary_node)
2269 config.set(constants.INISECT_EXP, 'os', instance.os)
2270 config.set(constants.INISECT_EXP, "compression", "none")
2271
2272 config.add_section(constants.INISECT_INS)
2273 config.set(constants.INISECT_INS, 'name', instance.name)
2274 config.set(constants.INISECT_INS, 'memory', '%d' %
2275 instance.beparams[constants.BE_MEMORY])
2276 config.set(constants.INISECT_INS, 'vcpus', '%d' %
2277 instance.beparams[constants.BE_VCPUS])
2278 config.set(constants.INISECT_INS, 'disk_template', instance.disk_template)
2279 config.set(constants.INISECT_INS, 'hypervisor', instance.hypervisor)
2280
2281 nic_total = 0
2282 for nic_count, nic in enumerate(instance.nics):
2283 nic_total += 1
2284 config.set(constants.INISECT_INS, 'nic%d_mac' %
2285 nic_count, '%s' % nic.mac)
2286 config.set(constants.INISECT_INS, 'nic%d_ip' % nic_count, '%s' % nic.ip)
2287 for param in constants.NICS_PARAMETER_TYPES:
2288 config.set(constants.INISECT_INS, 'nic%d_%s' % (nic_count, param),
2289 '%s' % nic.nicparams.get(param, None))
2290
2291 config.set(constants.INISECT_INS, 'nic_count' , '%d' % nic_total)
2292
2293 disk_total = 0
2294 for disk_count, disk in enumerate(snap_disks):
2295 if disk:
2296 disk_total += 1
2297 config.set(constants.INISECT_INS, 'disk%d_ivname' % disk_count,
2298 ('%s' % disk.iv_name))
2299 config.set(constants.INISECT_INS, 'disk%d_dump' % disk_count,
2300 ('%s' % disk.physical_id[1]))
2301 config.set(constants.INISECT_INS, 'disk%d_size' % disk_count,
2302 ('%d' % disk.size))
2303
2304 config.set(constants.INISECT_INS, 'disk_count' , '%d' % disk_total)
2305
2306
2307
2308 config.add_section(constants.INISECT_HYP)
2309 for name, value in instance.hvparams.items():
2310 if name not in constants.HVC_GLOBALS:
2311 config.set(constants.INISECT_HYP, name, str(value))
2312
2313 config.add_section(constants.INISECT_BEP)
2314 for name, value in instance.beparams.items():
2315 config.set(constants.INISECT_BEP, name, str(value))
2316
2317 config.add_section(constants.INISECT_OSP)
2318 for name, value in instance.osparams.items():
2319 config.set(constants.INISECT_OSP, name, str(value))
2320
2321 utils.WriteFile(utils.PathJoin(destdir, constants.EXPORT_CONF_FILE),
2322 data=config.Dumps())
2323 shutil.rmtree(finaldestdir, ignore_errors=True)
2324 shutil.move(destdir, finaldestdir)
2325
2348
2361
2364 """Remove an existing export from the node.
2365
2366 @type export: str
2367 @param export: the name of the export to remove
2368 @rtype: None
2369
2370 """
2371 target = utils.PathJoin(constants.EXPORT_DIR, export)
2372
2373 try:
2374 shutil.rmtree(target)
2375 except EnvironmentError, err:
2376 _Fail("Error while removing the export: %s", err, exc=True)
2377
2380 """Rename a list of block devices.
2381
2382 @type devlist: list of tuples
2383 @param devlist: list of tuples of the form (disk,
2384 new_logical_id, new_physical_id); disk is an
2385 L{objects.Disk} object describing the current disk,
2386 and new logical_id/physical_id is the name we
2387 rename it to
2388 @rtype: boolean
2389 @return: True if all renames succeeded, False otherwise
2390
2391 """
2392 msgs = []
2393 result = True
2394 for disk, unique_id in devlist:
2395 dev = _RecursiveFindBD(disk)
2396 if dev is None:
2397 msgs.append("Can't find device %s in rename" % str(disk))
2398 result = False
2399 continue
2400 try:
2401 old_rpath = dev.dev_path
2402 dev.Rename(unique_id)
2403 new_rpath = dev.dev_path
2404 if old_rpath != new_rpath:
2405 DevCacheManager.RemoveCache(old_rpath)
2406
2407
2408
2409
2410
2411 except errors.BlockDeviceError, err:
2412 msgs.append("Can't rename device '%s' to '%s': %s" %
2413 (dev, unique_id, err))
2414 logging.exception("Can't rename device '%s' to '%s'", dev, unique_id)
2415 result = False
2416 if not result:
2417 _Fail("; ".join(msgs))
2418
2443
2446 """Create file storage directory.
2447
2448 @type file_storage_dir: str
2449 @param file_storage_dir: directory to create
2450
2451 @rtype: tuple
2452 @return: tuple with first element a boolean indicating wheter dir
2453 creation was successful or not
2454
2455 """
2456 file_storage_dir = _TransformFileStorageDir(file_storage_dir)
2457 if os.path.exists(file_storage_dir):
2458 if not os.path.isdir(file_storage_dir):
2459 _Fail("Specified storage dir '%s' is not a directory",
2460 file_storage_dir)
2461 else:
2462 try:
2463 os.makedirs(file_storage_dir, 0750)
2464 except OSError, err:
2465 _Fail("Cannot create file storage directory '%s': %s",
2466 file_storage_dir, err, exc=True)
2467
2470 """Remove file storage directory.
2471
2472 Remove it only if it's empty. If not log an error and return.
2473
2474 @type file_storage_dir: str
2475 @param file_storage_dir: the directory we should cleanup
2476 @rtype: tuple (success,)
2477 @return: tuple of one element, C{success}, denoting
2478 whether the operation was successful
2479
2480 """
2481 file_storage_dir = _TransformFileStorageDir(file_storage_dir)
2482 if os.path.exists(file_storage_dir):
2483 if not os.path.isdir(file_storage_dir):
2484 _Fail("Specified Storage directory '%s' is not a directory",
2485 file_storage_dir)
2486
2487 try:
2488 os.rmdir(file_storage_dir)
2489 except OSError, err:
2490 _Fail("Cannot remove file storage directory '%s': %s",
2491 file_storage_dir, err)
2492
2495 """Rename the file storage directory.
2496
2497 @type old_file_storage_dir: str
2498 @param old_file_storage_dir: the current path
2499 @type new_file_storage_dir: str
2500 @param new_file_storage_dir: the name we should rename to
2501 @rtype: tuple (success,)
2502 @return: tuple of one element, C{success}, denoting
2503 whether the operation was successful
2504
2505 """
2506 old_file_storage_dir = _TransformFileStorageDir(old_file_storage_dir)
2507 new_file_storage_dir = _TransformFileStorageDir(new_file_storage_dir)
2508 if not os.path.exists(new_file_storage_dir):
2509 if os.path.isdir(old_file_storage_dir):
2510 try:
2511 os.rename(old_file_storage_dir, new_file_storage_dir)
2512 except OSError, err:
2513 _Fail("Cannot rename '%s' to '%s': %s",
2514 old_file_storage_dir, new_file_storage_dir, err)
2515 else:
2516 _Fail("Specified storage dir '%s' is not a directory",
2517 old_file_storage_dir)
2518 else:
2519 if os.path.exists(old_file_storage_dir):
2520 _Fail("Cannot rename '%s' to '%s': both locations exist",
2521 old_file_storage_dir, new_file_storage_dir)
2522
2525 """Checks whether the given filename is in the queue directory.
2526
2527 @type file_name: str
2528 @param file_name: the file name we should check
2529 @rtype: None
2530 @raises RPCFail: if the file is not valid
2531
2532 """
2533 queue_dir = os.path.normpath(constants.QUEUE_DIR)
2534 result = (os.path.commonprefix([queue_dir, file_name]) == queue_dir)
2535
2536 if not result:
2537 _Fail("Passed job queue file '%s' does not belong to"
2538 " the queue directory '%s'", file_name, queue_dir)
2539
2542 """Updates a file in the queue directory.
2543
2544 This is just a wrapper over L{utils.io.WriteFile}, with proper
2545 checking.
2546
2547 @type file_name: str
2548 @param file_name: the job file name
2549 @type content: str
2550 @param content: the new job contents
2551 @rtype: boolean
2552 @return: the success of the operation
2553
2554 """
2555 _EnsureJobQueueFile(file_name)
2556 getents = runtime.GetEnts()
2557
2558
2559 utils.WriteFile(file_name, data=_Decompress(content), uid=getents.masterd_uid,
2560 gid=getents.masterd_gid)
2561
2564 """Renames a job queue file.
2565
2566 This is just a wrapper over os.rename with proper checking.
2567
2568 @type old: str
2569 @param old: the old (actual) file name
2570 @type new: str
2571 @param new: the desired file name
2572 @rtype: tuple
2573 @return: the success of the operation and payload
2574
2575 """
2576 _EnsureJobQueueFile(old)
2577 _EnsureJobQueueFile(new)
2578
2579 getents = runtime.GetEnts()
2580
2581 utils.RenameFile(old, new, mkdir=True, mkdir_mode=0700,
2582 dir_uid=getents.masterd_uid, dir_gid=getents.masterd_gid)
2583
2586 """Closes the given block devices.
2587
2588 This means they will be switched to secondary mode (in case of
2589 DRBD).
2590
2591 @param instance_name: if the argument is not empty, the symlinks
2592 of this instance will be removed
2593 @type disks: list of L{objects.Disk}
2594 @param disks: the list of disks to be closed
2595 @rtype: tuple (success, message)
2596 @return: a tuple of success and message, where success
2597 indicates the succes of the operation, and message
2598 which will contain the error details in case we
2599 failed
2600
2601 """
2602 bdevs = []
2603 for cf in disks:
2604 rd = _RecursiveFindBD(cf)
2605 if rd is None:
2606 _Fail("Can't find device %s", cf)
2607 bdevs.append(rd)
2608
2609 msg = []
2610 for rd in bdevs:
2611 try:
2612 rd.Close()
2613 except errors.BlockDeviceError, err:
2614 msg.append(str(err))
2615 if msg:
2616 _Fail("Can't make devices secondary: %s", ",".join(msg))
2617 else:
2618 if instance_name:
2619 _RemoveBlockDevLinks(instance_name, disks)
2620
2623 """Validates the given hypervisor parameters.
2624
2625 @type hvname: string
2626 @param hvname: the hypervisor name
2627 @type hvparams: dict
2628 @param hvparams: the hypervisor parameters to be validated
2629 @rtype: None
2630
2631 """
2632 try:
2633 hv_type = hypervisor.GetHypervisor(hvname)
2634 hv_type.ValidateParameters(hvparams)
2635 except errors.HypervisorError, err:
2636 _Fail(str(err), log=False)
2637
2640 """Check whether a list of parameters is supported by the OS.
2641
2642 @type os_obj: L{objects.OS}
2643 @param os_obj: OS object to check
2644 @type parameters: list
2645 @param parameters: the list of parameters to check
2646
2647 """
2648 supported = [v[0] for v in os_obj.supported_parameters]
2649 delta = frozenset(parameters).difference(supported)
2650 if delta:
2651 _Fail("The following parameters are not supported"
2652 " by the OS %s: %s" % (os_obj.name, utils.CommaJoin(delta)))
2653
2654
2655 -def ValidateOS(required, osname, checks, osparams):
2656 """Validate the given OS' parameters.
2657
2658 @type required: boolean
2659 @param required: whether absence of the OS should translate into
2660 failure or not
2661 @type osname: string
2662 @param osname: the OS to be validated
2663 @type checks: list
2664 @param checks: list of the checks to run (currently only 'parameters')
2665 @type osparams: dict
2666 @param osparams: dictionary with OS parameters
2667 @rtype: boolean
2668 @return: True if the validation passed, or False if the OS was not
2669 found and L{required} was false
2670
2671 """
2672 if not constants.OS_VALIDATE_CALLS.issuperset(checks):
2673 _Fail("Unknown checks required for OS %s: %s", osname,
2674 set(checks).difference(constants.OS_VALIDATE_CALLS))
2675
2676 name_only = objects.OS.GetName(osname)
2677 status, tbv = _TryOSFromDisk(name_only, None)
2678
2679 if not status:
2680 if required:
2681 _Fail(tbv)
2682 else:
2683 return False
2684
2685 if max(tbv.api_versions) < constants.OS_API_V20:
2686 return True
2687
2688 if constants.OS_VALIDATE_PARAMETERS in checks:
2689 _CheckOSPList(tbv, osparams.keys())
2690
2691 validate_env = OSCoreEnv(osname, tbv, osparams)
2692 result = utils.RunCmd([tbv.verify_script] + checks, env=validate_env,
2693 cwd=tbv.path)
2694 if result.failed:
2695 logging.error("os validate command '%s' returned error: %s output: %s",
2696 result.cmd, result.fail_reason, result.output)
2697 _Fail("OS validation script failed (%s), output: %s",
2698 result.fail_reason, result.output, log=False)
2699
2700 return True
2701
2724
2733
2736 """Creates a new X509 certificate for SSL/TLS.
2737
2738 @type validity: int
2739 @param validity: Validity in seconds
2740 @rtype: tuple; (string, string)
2741 @return: Certificate name and public part
2742
2743 """
2744 (key_pem, cert_pem) = \
2745 utils.GenerateSelfSignedX509Cert(netutils.Hostname.GetSysName(),
2746 min(validity, _MAX_SSL_CERT_VALIDITY))
2747
2748 cert_dir = tempfile.mkdtemp(dir=cryptodir,
2749 prefix="x509-%s-" % utils.TimestampForFilename())
2750 try:
2751 name = os.path.basename(cert_dir)
2752 assert len(name) > 5
2753
2754 (_, key_file, cert_file) = _GetX509Filenames(cryptodir, name)
2755
2756 utils.WriteFile(key_file, mode=0400, data=key_pem)
2757 utils.WriteFile(cert_file, mode=0400, data=cert_pem)
2758
2759
2760 return (name, cert_pem)
2761 except Exception:
2762 shutil.rmtree(cert_dir, ignore_errors=True)
2763 raise
2764
2767 """Removes a X509 certificate.
2768
2769 @type name: string
2770 @param name: Certificate name
2771
2772 """
2773 (cert_dir, key_file, cert_file) = _GetX509Filenames(cryptodir, name)
2774
2775 utils.RemoveFile(key_file)
2776 utils.RemoveFile(cert_file)
2777
2778 try:
2779 os.rmdir(cert_dir)
2780 except EnvironmentError, err:
2781 _Fail("Cannot remove certificate directory '%s': %s",
2782 cert_dir, err)
2783
2786 """Returns the command for the requested input/output.
2787
2788 @type instance: L{objects.Instance}
2789 @param instance: The instance object
2790 @param mode: Import/export mode
2791 @param ieio: Input/output type
2792 @param ieargs: Input/output arguments
2793
2794 """
2795 assert mode in (constants.IEM_IMPORT, constants.IEM_EXPORT)
2796
2797 env = None
2798 prefix = None
2799 suffix = None
2800 exp_size = None
2801
2802 if ieio == constants.IEIO_FILE:
2803 (filename, ) = ieargs
2804
2805 if not utils.IsNormAbsPath(filename):
2806 _Fail("Path '%s' is not normalized or absolute", filename)
2807
2808 directory = os.path.normpath(os.path.dirname(filename))
2809
2810 if (os.path.commonprefix([constants.EXPORT_DIR, directory]) !=
2811 constants.EXPORT_DIR):
2812 _Fail("File '%s' is not under exports directory '%s'",
2813 filename, constants.EXPORT_DIR)
2814
2815
2816 utils.Makedirs(directory, mode=0750)
2817
2818 quoted_filename = utils.ShellQuote(filename)
2819
2820 if mode == constants.IEM_IMPORT:
2821 suffix = "> %s" % quoted_filename
2822 elif mode == constants.IEM_EXPORT:
2823 suffix = "< %s" % quoted_filename
2824
2825
2826 try:
2827 st = os.stat(filename)
2828 except EnvironmentError, err:
2829 logging.error("Can't stat(2) %s: %s", filename, err)
2830 else:
2831 exp_size = utils.BytesToMebibyte(st.st_size)
2832
2833 elif ieio == constants.IEIO_RAW_DISK:
2834 (disk, ) = ieargs
2835
2836 real_disk = _OpenRealBD(disk)
2837
2838 if mode == constants.IEM_IMPORT:
2839
2840
2841
2842
2843
2844
2845 suffix = utils.BuildShellCmd(("| dd of=%s conv=nocreat,notrunc"
2846 " bs=%s oflag=dsync"),
2847 real_disk.dev_path,
2848 str(64 * 1024))
2849
2850 elif mode == constants.IEM_EXPORT:
2851
2852 prefix = utils.BuildShellCmd("dd if=%s bs=%s count=%s |",
2853 real_disk.dev_path,
2854 str(1024 * 1024),
2855 str(disk.size))
2856 exp_size = disk.size
2857
2858 elif ieio == constants.IEIO_SCRIPT:
2859 (disk, disk_index, ) = ieargs
2860
2861 assert isinstance(disk_index, (int, long))
2862
2863 real_disk = _OpenRealBD(disk)
2864
2865 inst_os = OSFromDisk(instance.os)
2866 env = OSEnvironment(instance, inst_os)
2867
2868 if mode == constants.IEM_IMPORT:
2869 env["IMPORT_DEVICE"] = env["DISK_%d_PATH" % disk_index]
2870 env["IMPORT_INDEX"] = str(disk_index)
2871 script = inst_os.import_script
2872
2873 elif mode == constants.IEM_EXPORT:
2874 env["EXPORT_DEVICE"] = real_disk.dev_path
2875 env["EXPORT_INDEX"] = str(disk_index)
2876 script = inst_os.export_script
2877
2878
2879 script_cmd = utils.BuildShellCmd("( cd %s && %s; )", inst_os.path, script)
2880
2881 if mode == constants.IEM_IMPORT:
2882 suffix = "| %s" % script_cmd
2883
2884 elif mode == constants.IEM_EXPORT:
2885 prefix = "%s |" % script_cmd
2886
2887
2888 exp_size = constants.IE_CUSTOM_SIZE
2889
2890 else:
2891 _Fail("Invalid %s I/O mode %r", mode, ieio)
2892
2893 return (env, prefix, suffix, exp_size)
2894
2903
2906 """Starts an import or export daemon.
2907
2908 @param mode: Import/output mode
2909 @type opts: L{objects.ImportExportOptions}
2910 @param opts: Daemon options
2911 @type host: string
2912 @param host: Remote host for export (None for import)
2913 @type port: int
2914 @param port: Remote port for export (None for import)
2915 @type instance: L{objects.Instance}
2916 @param instance: Instance object
2917 @param ieio: Input/output type
2918 @param ieioargs: Input/output arguments
2919
2920 """
2921 if mode == constants.IEM_IMPORT:
2922 prefix = "import"
2923
2924 if not (host is None and port is None):
2925 _Fail("Can not specify host or port on import")
2926
2927 elif mode == constants.IEM_EXPORT:
2928 prefix = "export"
2929
2930 if host is None or port is None:
2931 _Fail("Host and port must be specified for an export")
2932
2933 else:
2934 _Fail("Invalid mode %r", mode)
2935
2936 if (opts.key_name is None) ^ (opts.ca_pem is None):
2937 _Fail("Cluster certificate can only be used for both key and CA")
2938
2939 (cmd_env, cmd_prefix, cmd_suffix, exp_size) = \
2940 _GetImportExportIoCommand(instance, mode, ieio, ieioargs)
2941
2942 if opts.key_name is None:
2943
2944 key_path = constants.NODED_CERT_FILE
2945 cert_path = constants.NODED_CERT_FILE
2946 assert opts.ca_pem is None
2947 else:
2948 (_, key_path, cert_path) = _GetX509Filenames(constants.CRYPTO_KEYS_DIR,
2949 opts.key_name)
2950 assert opts.ca_pem is not None
2951
2952 for i in [key_path, cert_path]:
2953 if not os.path.exists(i):
2954 _Fail("File '%s' does not exist" % i)
2955
2956 status_dir = _CreateImportExportStatusDir(prefix)
2957 try:
2958 status_file = utils.PathJoin(status_dir, _IES_STATUS_FILE)
2959 pid_file = utils.PathJoin(status_dir, _IES_PID_FILE)
2960 ca_file = utils.PathJoin(status_dir, _IES_CA_FILE)
2961
2962 if opts.ca_pem is None:
2963
2964 ca = utils.ReadFile(constants.NODED_CERT_FILE)
2965 else:
2966 ca = opts.ca_pem
2967
2968
2969 utils.WriteFile(ca_file, data=ca, mode=0400)
2970
2971 cmd = [
2972 constants.IMPORT_EXPORT_DAEMON,
2973 status_file, mode,
2974 "--key=%s" % key_path,
2975 "--cert=%s" % cert_path,
2976 "--ca=%s" % ca_file,
2977 ]
2978
2979 if host:
2980 cmd.append("--host=%s" % host)
2981
2982 if port:
2983 cmd.append("--port=%s" % port)
2984
2985 if opts.ipv6:
2986 cmd.append("--ipv6")
2987 else:
2988 cmd.append("--ipv4")
2989
2990 if opts.compress:
2991 cmd.append("--compress=%s" % opts.compress)
2992
2993 if opts.magic:
2994 cmd.append("--magic=%s" % opts.magic)
2995
2996 if exp_size is not None:
2997 cmd.append("--expected-size=%s" % exp_size)
2998
2999 if cmd_prefix:
3000 cmd.append("--cmd-prefix=%s" % cmd_prefix)
3001
3002 if cmd_suffix:
3003 cmd.append("--cmd-suffix=%s" % cmd_suffix)
3004
3005 if mode == constants.IEM_EXPORT:
3006
3007 cmd.append("--connect-retries=%s" % constants.RIE_CONNECT_RETRIES)
3008 cmd.append("--connect-timeout=%s" % constants.RIE_CONNECT_ATTEMPT_TIMEOUT)
3009 elif opts.connect_timeout is not None:
3010 assert mode == constants.IEM_IMPORT
3011
3012 cmd.append("--connect-timeout=%s" % opts.connect_timeout)
3013
3014 logfile = _InstanceLogName(prefix, instance.os, instance.name)
3015
3016
3017
3018 utils.StartDaemon(cmd, env=cmd_env, pidfile=pid_file,
3019 output=logfile)
3020
3021
3022 return os.path.basename(status_dir)
3023
3024 except Exception:
3025 shutil.rmtree(status_dir, ignore_errors=True)
3026 raise
3027
3030 """Returns import/export daemon status.
3031
3032 @type names: sequence
3033 @param names: List of names
3034 @rtype: List of dicts
3035 @return: Returns a list of the state of each named import/export or None if a
3036 status couldn't be read
3037
3038 """
3039 result = []
3040
3041 for name in names:
3042 status_file = utils.PathJoin(constants.IMPORT_EXPORT_DIR, name,
3043 _IES_STATUS_FILE)
3044
3045 try:
3046 data = utils.ReadFile(status_file)
3047 except EnvironmentError, err:
3048 if err.errno != errno.ENOENT:
3049 raise
3050 data = None
3051
3052 if not data:
3053 result.append(None)
3054 continue
3055
3056 result.append(serializer.LoadJson(data))
3057
3058 return result
3059
3074
3077 """Cleanup after an import or export.
3078
3079 If the import/export daemon is still running it's killed. Afterwards the
3080 whole status directory is removed.
3081
3082 """
3083 logging.info("Finalizing import/export %s", name)
3084
3085 status_dir = utils.PathJoin(constants.IMPORT_EXPORT_DIR, name)
3086
3087 pid = utils.ReadLockedPidFile(utils.PathJoin(status_dir, _IES_PID_FILE))
3088
3089 if pid:
3090 logging.info("Import/export %s is still running with PID %s",
3091 name, pid)
3092 utils.KillProcess(pid, waitpid=False)
3093
3094 shutil.rmtree(status_dir, ignore_errors=True)
3095
3098 """Sets the physical ID on disks and returns the block devices.
3099
3100 """
3101
3102 my_name = netutils.Hostname.GetSysName()
3103 for cf in disks:
3104 cf.SetPhysicalID(my_name, nodes_ip)
3105
3106 bdevs = []
3107
3108 for cf in disks:
3109 rd = _RecursiveFindBD(cf)
3110 if rd is None:
3111 _Fail("Can't find device %s", cf)
3112 bdevs.append(rd)
3113 return bdevs
3114
3117 """Disconnects the network on a list of drbd devices.
3118
3119 """
3120 bdevs = _FindDisks(nodes_ip, disks)
3121
3122
3123 for rd in bdevs:
3124 try:
3125 rd.DisconnectNet()
3126 except errors.BlockDeviceError, err:
3127 _Fail("Can't change network configuration to standalone mode: %s",
3128 err, exc=True)
3129
3130
3131 -def DrbdAttachNet(nodes_ip, disks, instance_name, multimaster):
3132 """Attaches the network on a list of drbd devices.
3133
3134 """
3135 bdevs = _FindDisks(nodes_ip, disks)
3136
3137 if multimaster:
3138 for idx, rd in enumerate(bdevs):
3139 try:
3140 _SymlinkBlockDev(instance_name, rd.dev_path, idx)
3141 except EnvironmentError, err:
3142 _Fail("Can't create symlink: %s", err)
3143
3144
3145 for rd in bdevs:
3146 try:
3147 rd.AttachNet(multimaster)
3148 except errors.BlockDeviceError, err:
3149 _Fail("Can't change network configuration: %s", err)
3150
3151
3152
3153
3154
3155
3156
3157 def _Attach():
3158 all_connected = True
3159
3160 for rd in bdevs:
3161 stats = rd.GetProcStatus()
3162
3163 all_connected = (all_connected and
3164 (stats.is_connected or stats.is_in_resync))
3165
3166 if stats.is_standalone:
3167
3168
3169
3170 try:
3171 rd.AttachNet(multimaster)
3172 except errors.BlockDeviceError, err:
3173 _Fail("Can't change network configuration: %s", err)
3174
3175 if not all_connected:
3176 raise utils.RetryAgain()
3177
3178 try:
3179
3180 utils.Retry(_Attach, (0.1, 1.5, 5.0), 2 * 60)
3181 except utils.RetryTimeout:
3182 _Fail("Timeout in disk reconnecting")
3183
3184 if multimaster:
3185
3186 for rd in bdevs:
3187 try:
3188 rd.Open()
3189 except errors.BlockDeviceError, err:
3190 _Fail("Can't change to primary mode: %s", err)
3191
3194 """Wait until DRBDs have synchronized.
3195
3196 """
3197 def _helper(rd):
3198 stats = rd.GetProcStatus()
3199 if not (stats.is_connected or stats.is_in_resync):
3200 raise utils.RetryAgain()
3201 return stats
3202
3203 bdevs = _FindDisks(nodes_ip, disks)
3204
3205 min_resync = 100
3206 alldone = True
3207 for rd in bdevs:
3208 try:
3209
3210 stats = utils.Retry(_helper, 1, 15, args=[rd])
3211 except utils.RetryTimeout:
3212 stats = rd.GetProcStatus()
3213
3214 if not (stats.is_connected or stats.is_in_resync):
3215 _Fail("DRBD device %s is not in sync: stats=%s", rd, stats)
3216 alldone = alldone and (not stats.is_in_resync)
3217 if stats.sync_percent is not None:
3218 min_resync = min(min_resync, stats.sync_percent)
3219
3220 return (alldone, min_resync)
3221
3231
3234 """Hard-powercycle the node.
3235
3236 Because we need to return first, and schedule the powercycle in the
3237 background, we won't be able to report failures nicely.
3238
3239 """
3240 hyper = hypervisor.GetHypervisor(hypervisor_type)
3241 try:
3242 pid = os.fork()
3243 except OSError:
3244
3245 pid = 0
3246 if pid > 0:
3247 return "Reboot scheduled in 5 seconds"
3248
3249 try:
3250 utils.Mlockall()
3251 except Exception:
3252 pass
3253 time.sleep(5)
3254 hyper.PowercycleNode()
3255
3258 """Hook runner.
3259
3260 This class is instantiated on the node side (ganeti-noded) and not
3261 on the master side.
3262
3263 """
3264 - def __init__(self, hooks_base_dir=None):
3265 """Constructor for hooks runner.
3266
3267 @type hooks_base_dir: str or None
3268 @param hooks_base_dir: if not None, this overrides the
3269 L{constants.HOOKS_BASE_DIR} (useful for unittests)
3270
3271 """
3272 if hooks_base_dir is None:
3273 hooks_base_dir = constants.HOOKS_BASE_DIR
3274
3275
3276 self._BASE_DIR = hooks_base_dir
3277
3278 - def RunHooks(self, hpath, phase, env):
3279 """Run the scripts in the hooks directory.
3280
3281 @type hpath: str
3282 @param hpath: the path to the hooks directory which
3283 holds the scripts
3284 @type phase: str
3285 @param phase: either L{constants.HOOKS_PHASE_PRE} or
3286 L{constants.HOOKS_PHASE_POST}
3287 @type env: dict
3288 @param env: dictionary with the environment for the hook
3289 @rtype: list
3290 @return: list of 3-element tuples:
3291 - script path
3292 - script result, either L{constants.HKR_SUCCESS} or
3293 L{constants.HKR_FAIL}
3294 - output of the script
3295
3296 @raise errors.ProgrammerError: for invalid input
3297 parameters
3298
3299 """
3300 if phase == constants.HOOKS_PHASE_PRE:
3301 suffix = "pre"
3302 elif phase == constants.HOOKS_PHASE_POST:
3303 suffix = "post"
3304 else:
3305 _Fail("Unknown hooks phase '%s'", phase)
3306
3307
3308 subdir = "%s-%s.d" % (hpath, suffix)
3309 dir_name = utils.PathJoin(self._BASE_DIR, subdir)
3310
3311 results = []
3312
3313 if not os.path.isdir(dir_name):
3314
3315
3316 return results
3317
3318 runparts_results = utils.RunParts(dir_name, env=env, reset_env=True)
3319
3320 for (relname, relstatus, runresult) in runparts_results:
3321 if relstatus == constants.RUNPARTS_SKIP:
3322 rrval = constants.HKR_SKIP
3323 output = ""
3324 elif relstatus == constants.RUNPARTS_ERR:
3325 rrval = constants.HKR_FAIL
3326 output = "Hook script execution error: %s" % runresult
3327 elif relstatus == constants.RUNPARTS_RUN:
3328 if runresult.failed:
3329 rrval = constants.HKR_FAIL
3330 else:
3331 rrval = constants.HKR_SUCCESS
3332 output = utils.SafeEncode(runresult.output.strip())
3333 results.append(("%s/%s" % (subdir, relname), rrval, output))
3334
3335 return results
3336
3339 """IAllocator runner.
3340
3341 This class is instantiated on the node side (ganeti-noded) and not on
3342 the master side.
3343
3344 """
3345 @staticmethod
3346 - def Run(name, idata):
3347 """Run an iallocator script.
3348
3349 @type name: str
3350 @param name: the iallocator script name
3351 @type idata: str
3352 @param idata: the allocator input data
3353
3354 @rtype: tuple
3355 @return: two element tuple of:
3356 - status
3357 - either error message or stdout of allocator (for success)
3358
3359 """
3360 alloc_script = utils.FindFile(name, constants.IALLOCATOR_SEARCH_PATH,
3361 os.path.isfile)
3362 if alloc_script is None:
3363 _Fail("iallocator module '%s' not found in the search path", name)
3364
3365 fd, fin_name = tempfile.mkstemp(prefix="ganeti-iallocator.")
3366 try:
3367 os.write(fd, idata)
3368 os.close(fd)
3369 result = utils.RunCmd([alloc_script, fin_name])
3370 if result.failed:
3371 _Fail("iallocator module '%s' failed: %s, output '%s'",
3372 name, result.fail_reason, result.output)
3373 finally:
3374 os.unlink(fin_name)
3375
3376 return result.stdout
3377
3380 """Simple class for managing a cache of block device information.
3381
3382 """
3383 _DEV_PREFIX = "/dev/"
3384 _ROOT_DIR = constants.BDEV_CACHE_DIR
3385
3386 @classmethod
3388 """Converts a /dev/name path to the cache file name.
3389
3390 This replaces slashes with underscores and strips the /dev
3391 prefix. It then returns the full path to the cache file.
3392
3393 @type dev_path: str
3394 @param dev_path: the C{/dev/} path name
3395 @rtype: str
3396 @return: the converted path name
3397
3398 """
3399 if dev_path.startswith(cls._DEV_PREFIX):
3400 dev_path = dev_path[len(cls._DEV_PREFIX):]
3401 dev_path = dev_path.replace("/", "_")
3402 fpath = utils.PathJoin(cls._ROOT_DIR, "bdev_%s" % dev_path)
3403 return fpath
3404
3405 @classmethod
3406 - def UpdateCache(cls, dev_path, owner, on_primary, iv_name):
3407 """Updates the cache information for a given device.
3408
3409 @type dev_path: str
3410 @param dev_path: the pathname of the device
3411 @type owner: str
3412 @param owner: the owner (instance name) of the device
3413 @type on_primary: bool
3414 @param on_primary: whether this is the primary
3415 node nor not
3416 @type iv_name: str
3417 @param iv_name: the instance-visible name of the
3418 device, as in objects.Disk.iv_name
3419
3420 @rtype: None
3421
3422 """
3423 if dev_path is None:
3424 logging.error("DevCacheManager.UpdateCache got a None dev_path")
3425 return
3426 fpath = cls._ConvertPath(dev_path)
3427 if on_primary:
3428 state = "primary"
3429 else:
3430 state = "secondary"
3431 if iv_name is None:
3432 iv_name = "not_visible"
3433 fdata = "%s %s %s\n" % (str(owner), state, iv_name)
3434 try:
3435 utils.WriteFile(fpath, data=fdata)
3436 except EnvironmentError, err:
3437 logging.exception("Can't update bdev cache for %s: %s", dev_path, err)
3438
3439 @classmethod
3441 """Remove data for a dev_path.
3442
3443 This is just a wrapper over L{utils.io.RemoveFile} with a converted
3444 path name and logging.
3445
3446 @type dev_path: str
3447 @param dev_path: the pathname of the device
3448
3449 @rtype: None
3450
3451 """
3452 if dev_path is None:
3453 logging.error("DevCacheManager.RemoveCache got a None dev_path")
3454 return
3455 fpath = cls._ConvertPath(dev_path)
3456 try:
3457 utils.RemoveFile(fpath)
3458 except EnvironmentError, err:
3459 logging.exception("Can't update bdev cache for %s: %s", dev_path, err)
3460