4 # Copyright (C) 2006, 2007, 2008, 2009, 2010 Google Inc.
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful, but
12 # WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 """Configuration management for Ganeti
24 This module provides the interface to the Ganeti cluster configuration.
26 The configuration data is stored on every node but is updated on the master
27 only. After each update, the master distributes the data to the other nodes.
29 Currently, the data storage format is JSON. YAML was slow and consuming too
34 # pylint: disable-msg=R0904
35 # R0904: Too many public methods
42 from ganeti import errors
43 from ganeti import locking
44 from ganeti import utils
45 from ganeti import constants
46 from ganeti import rpc
47 from ganeti import objects
48 from ganeti import serializer
49 from ganeti import uidpool
50 from ganeti import netutils
51 from ganeti import runtime
54 _config_lock = locking.SharedLock("ConfigWriter")
56 # job id used for resource management at config upgrade time
57 _UPGRADE_CONFIG_JID = "jid-cfg-upgrade"
60 def _ValidateConfig(data):
61 """Verifies that a configuration objects looks valid.
63 This only verifies the version of the configuration.
65 @raise errors.ConfigurationError: if the version differs from what
69 if data.version != constants.CONFIG_VERSION:
70 raise errors.ConfigVersionMismatch(constants.CONFIG_VERSION, data.version)
73 class TemporaryReservationManager:
74 """A temporary resource reservation manager.
76 This is used to reserve resources in a job, before using them, making sure
77 other jobs cannot get them in the meantime.
81 self._ec_reserved = {}
83 def Reserved(self, resource):
84 for holder_reserved in self._ec_reserved.values():
85 if resource in holder_reserved:
89 def Reserve(self, ec_id, resource):
90 if self.Reserved(resource):
91 raise errors.ReservationError("Duplicate reservation for resource '%s'"
93 if ec_id not in self._ec_reserved:
94 self._ec_reserved[ec_id] = set([resource])
96 self._ec_reserved[ec_id].add(resource)
98 def DropECReservations(self, ec_id):
99 if ec_id in self._ec_reserved:
100 del self._ec_reserved[ec_id]
102 def GetReserved(self):
104 for holder_reserved in self._ec_reserved.values():
105 all_reserved.update(holder_reserved)
108 def Generate(self, existing, generate_one_fn, ec_id):
109 """Generate a new resource of this type
112 assert callable(generate_one_fn)
114 all_elems = self.GetReserved()
115 all_elems.update(existing)
118 new_resource = generate_one_fn()
119 if new_resource is not None and new_resource not in all_elems:
122 raise errors.ConfigurationError("Not able generate new resource"
123 " (last tried: %s)" % new_resource)
124 self.Reserve(ec_id, new_resource)
129 """The interface to the cluster configuration.
131 @ivar _temporary_lvs: reservation manager for temporary LVs
132 @ivar _all_rms: a list of all temporary reservation managers
135 def __init__(self, cfg_file=None, offline=False, _getents=runtime.GetEnts,
136 accept_foreign=False):
138 self._lock = _config_lock
139 self._config_data = None
140 self._offline = offline
142 self._cfg_file = constants.CLUSTER_CONF_FILE
144 self._cfg_file = cfg_file
145 self._getents = _getents
146 self._temporary_ids = TemporaryReservationManager()
147 self._temporary_drbds = {}
148 self._temporary_macs = TemporaryReservationManager()
149 self._temporary_secrets = TemporaryReservationManager()
150 self._temporary_lvs = TemporaryReservationManager()
151 self._all_rms = [self._temporary_ids, self._temporary_macs,
152 self._temporary_secrets, self._temporary_lvs]
153 # Note: in order to prevent errors when resolving our name in
154 # _DistributeConfig, we compute it here once and reuse it; it's
155 # better to raise an error before starting to modify the config
156 # file than after it was modified
157 self._my_hostname = netutils.Hostname.GetSysName()
158 self._last_cluster_serial = -1
160 self._OpenConfig(accept_foreign)
162 # this method needs to be static, so that we can call it on the class
165 """Check if the cluster is configured.
168 return os.path.exists(constants.CLUSTER_CONF_FILE)
170 def _GenerateOneMAC(self):
171 """Generate one mac address
174 prefix = self._config_data.cluster.mac_prefix
175 byte1 = random.randrange(0, 256)
176 byte2 = random.randrange(0, 256)
177 byte3 = random.randrange(0, 256)
178 mac = "%s:%02x:%02x:%02x" % (prefix, byte1, byte2, byte3)
181 @locking.ssynchronized(_config_lock, shared=1)
182 def GenerateMAC(self, ec_id):
183 """Generate a MAC for an instance.
185 This should check the current instances for duplicates.
188 existing = self._AllMACs()
189 return self._temporary_ids.Generate(existing, self._GenerateOneMAC, ec_id)
191 @locking.ssynchronized(_config_lock, shared=1)
192 def ReserveMAC(self, mac, ec_id):
193 """Reserve a MAC for an instance.
195 This only checks instances managed by this cluster, it does not
196 check for potential collisions elsewhere.
199 all_macs = self._AllMACs()
201 raise errors.ReservationError("mac already in use")
203 self._temporary_macs.Reserve(mac, ec_id)
205 @locking.ssynchronized(_config_lock, shared=1)
206 def ReserveLV(self, lv_name, ec_id):
207 """Reserve an VG/LV pair for an instance.
209 @type lv_name: string
210 @param lv_name: the logical volume name to reserve
213 all_lvs = self._AllLVs()
214 if lv_name in all_lvs:
215 raise errors.ReservationError("LV already in use")
217 self._temporary_lvs.Reserve(lv_name, ec_id)
219 @locking.ssynchronized(_config_lock, shared=1)
220 def GenerateDRBDSecret(self, ec_id):
221 """Generate a DRBD secret.
223 This checks the current disks for duplicates.
226 return self._temporary_secrets.Generate(self._AllDRBDSecrets(),
227 utils.GenerateSecret,
231 """Compute the list of all LVs.
235 for instance in self._config_data.instances.values():
236 node_data = instance.MapLVsByNode()
237 for lv_list in node_data.values():
238 lvnames.update(lv_list)
241 def _AllIDs(self, include_temporary):
242 """Compute the list of all UUIDs and names we have.
244 @type include_temporary: boolean
245 @param include_temporary: whether to include the _temporary_ids set
247 @return: a set of IDs
251 if include_temporary:
252 existing.update(self._temporary_ids.GetReserved())
253 existing.update(self._AllLVs())
254 existing.update(self._config_data.instances.keys())
255 existing.update(self._config_data.nodes.keys())
256 existing.update([i.uuid for i in self._AllUUIDObjects() if i.uuid])
259 def _GenerateUniqueID(self, ec_id):
260 """Generate an unique UUID.
262 This checks the current node, instances and disk names for
266 @return: the unique id
269 existing = self._AllIDs(include_temporary=False)
270 return self._temporary_ids.Generate(existing, utils.NewUUID, ec_id)
272 @locking.ssynchronized(_config_lock, shared=1)
273 def GenerateUniqueID(self, ec_id):
274 """Generate an unique ID.
276 This is just a wrapper over the unlocked version.
279 @param ec_id: unique id for the job to reserve the id to
282 return self._GenerateUniqueID(ec_id)
285 """Return all MACs present in the config.
288 @return: the list of all MACs
292 for instance in self._config_data.instances.values():
293 for nic in instance.nics:
294 result.append(nic.mac)
298 def _AllDRBDSecrets(self):
299 """Return all DRBD secrets present in the config.
302 @return: the list of all DRBD secrets
305 def helper(disk, result):
306 """Recursively gather secrets from this disk."""
307 if disk.dev_type == constants.DT_DRBD8:
308 result.append(disk.logical_id[5])
310 for child in disk.children:
311 helper(child, result)
314 for instance in self._config_data.instances.values():
315 for disk in instance.disks:
320 def _CheckDiskIDs(self, disk, l_ids, p_ids):
321 """Compute duplicate disk IDs
323 @type disk: L{objects.Disk}
324 @param disk: the disk at which to start searching
326 @param l_ids: list of current logical ids
328 @param p_ids: list of current physical ids
330 @return: a list of error messages
334 if disk.logical_id is not None:
335 if disk.logical_id in l_ids:
336 result.append("duplicate logical id %s" % str(disk.logical_id))
338 l_ids.append(disk.logical_id)
339 if disk.physical_id is not None:
340 if disk.physical_id in p_ids:
341 result.append("duplicate physical id %s" % str(disk.physical_id))
343 p_ids.append(disk.physical_id)
346 for child in disk.children:
347 result.extend(self._CheckDiskIDs(child, l_ids, p_ids))
350 def _UnlockedVerifyConfig(self):
354 @return: a list of error messages; a non-empty list signifies
361 data = self._config_data
365 # global cluster checks
366 if not data.cluster.enabled_hypervisors:
367 result.append("enabled hypervisors list doesn't have any entries")
368 invalid_hvs = set(data.cluster.enabled_hypervisors) - constants.HYPER_TYPES
370 result.append("enabled hypervisors contains invalid entries: %s" %
372 missing_hvp = (set(data.cluster.enabled_hypervisors) -
373 set(data.cluster.hvparams.keys()))
375 result.append("hypervisor parameters missing for the enabled"
376 " hypervisor(s) %s" % utils.CommaJoin(missing_hvp))
378 if data.cluster.master_node not in data.nodes:
379 result.append("cluster has invalid primary node '%s'" %
380 data.cluster.master_node)
382 # per-instance checks
383 for instance_name in data.instances:
384 instance = data.instances[instance_name]
385 if instance.name != instance_name:
386 result.append("instance '%s' is indexed by wrong name '%s'" %
387 (instance.name, instance_name))
388 if instance.primary_node not in data.nodes:
389 result.append("instance '%s' has invalid primary node '%s'" %
390 (instance_name, instance.primary_node))
391 for snode in instance.secondary_nodes:
392 if snode not in data.nodes:
393 result.append("instance '%s' has invalid secondary node '%s'" %
394 (instance_name, snode))
395 for idx, nic in enumerate(instance.nics):
396 if nic.mac in seen_macs:
397 result.append("instance '%s' has NIC %d mac %s duplicate" %
398 (instance_name, idx, nic.mac))
400 seen_macs.append(nic.mac)
402 # gather the drbd ports for duplicate checks
403 for dsk in instance.disks:
404 if dsk.dev_type in constants.LDS_DRBD:
405 tcp_port = dsk.logical_id[2]
406 if tcp_port not in ports:
408 ports[tcp_port].append((instance.name, "drbd disk %s" % dsk.iv_name))
409 # gather network port reservation
410 net_port = getattr(instance, "network_port", None)
411 if net_port is not None:
412 if net_port not in ports:
414 ports[net_port].append((instance.name, "network port"))
416 # instance disk verify
417 for idx, disk in enumerate(instance.disks):
418 result.extend(["instance '%s' disk %d error: %s" %
419 (instance.name, idx, msg) for msg in disk.Verify()])
420 result.extend(self._CheckDiskIDs(disk, seen_lids, seen_pids))
422 # cluster-wide pool of free ports
423 for free_port in data.cluster.tcpudp_port_pool:
424 if free_port not in ports:
425 ports[free_port] = []
426 ports[free_port].append(("cluster", "port marked as free"))
428 # compute tcp/udp duplicate ports
434 txt = utils.CommaJoin(["%s/%s" % val for val in pdata])
435 result.append("tcp/udp port %s has duplicates: %s" % (pnum, txt))
437 # highest used tcp port check
439 if keys[-1] > data.cluster.highest_used_port:
440 result.append("Highest used port mismatch, saved %s, computed %s" %
441 (data.cluster.highest_used_port, keys[-1]))
443 if not data.nodes[data.cluster.master_node].master_candidate:
444 result.append("Master node is not a master candidate")
446 # master candidate checks
447 mc_now, mc_max, _ = self._UnlockedGetMasterCandidateStats()
449 result.append("Not enough master candidates: actual %d, target %d" %
453 for node_name, node in data.nodes.items():
454 if node.name != node_name:
455 result.append("Node '%s' is indexed by wrong name '%s'" %
456 (node.name, node_name))
457 if [node.master_candidate, node.drained, node.offline].count(True) > 1:
458 result.append("Node %s state is invalid: master_candidate=%s,"
459 " drain=%s, offline=%s" %
460 (node.name, node.master_candidate, node.drained,
464 nodegroups_names = set()
465 for nodegroup_uuid in data.nodegroups:
466 nodegroup = data.nodegroups[nodegroup_uuid]
467 if nodegroup.uuid != nodegroup_uuid:
468 result.append("nodegroup '%s' (uuid: '%s') indexed by wrong uuid '%s'"
469 % (nodegroup.name, nodegroup.uuid, nodegroup_uuid))
470 if utils.UUID_RE.match(nodegroup.name.lower()):
471 result.append("nodegroup '%s' (uuid: '%s') has uuid-like name" %
472 (nodegroup.name, nodegroup.uuid))
473 if nodegroup.name in nodegroups_names:
474 result.append("duplicate nodegroup name '%s'" % nodegroup.name)
476 nodegroups_names.add(nodegroup.name)
479 _, duplicates = self._UnlockedComputeDRBDMap()
480 for node, minor, instance_a, instance_b in duplicates:
481 result.append("DRBD minor %d on node %s is assigned twice to instances"
482 " %s and %s" % (minor, node, instance_a, instance_b))
485 default_nicparams = data.cluster.nicparams[constants.PP_DEFAULT]
488 def _AddIpAddress(ip, name):
489 ips.setdefault(ip, []).append(name)
491 _AddIpAddress(data.cluster.master_ip, "cluster_ip")
493 for node in data.nodes.values():
494 _AddIpAddress(node.primary_ip, "node:%s/primary" % node.name)
495 if node.secondary_ip != node.primary_ip:
496 _AddIpAddress(node.secondary_ip, "node:%s/secondary" % node.name)
498 for instance in data.instances.values():
499 for idx, nic in enumerate(instance.nics):
503 nicparams = objects.FillDict(default_nicparams, nic.nicparams)
504 nic_mode = nicparams[constants.NIC_MODE]
505 nic_link = nicparams[constants.NIC_LINK]
507 if nic_mode == constants.NIC_MODE_BRIDGED:
508 link = "bridge:%s" % nic_link
509 elif nic_mode == constants.NIC_MODE_ROUTED:
510 link = "route:%s" % nic_link
512 raise errors.ProgrammerError("NIC mode '%s' not handled" % nic_mode)
514 _AddIpAddress("%s/%s" % (link, nic.ip),
515 "instance:%s/nic:%d" % (instance.name, idx))
517 for ip, owners in ips.items():
519 result.append("IP address %s is used by multiple owners: %s" %
520 (ip, utils.CommaJoin(owners)))
524 @locking.ssynchronized(_config_lock, shared=1)
525 def VerifyConfig(self):
528 This is just a wrapper over L{_UnlockedVerifyConfig}.
531 @return: a list of error messages; a non-empty list signifies
535 return self._UnlockedVerifyConfig()
537 def _UnlockedSetDiskID(self, disk, node_name):
538 """Convert the unique ID to the ID needed on the target nodes.
540 This is used only for drbd, which needs ip/port configuration.
542 The routine descends down and updates its children also, because
543 this helps when the only the top device is passed to the remote
546 This function is for internal use, when the config lock is already held.
550 for child in disk.children:
551 self._UnlockedSetDiskID(child, node_name)
553 if disk.logical_id is None and disk.physical_id is not None:
555 if disk.dev_type == constants.LD_DRBD8:
556 pnode, snode, port, pminor, sminor, secret = disk.logical_id
557 if node_name not in (pnode, snode):
558 raise errors.ConfigurationError("DRBD device not knowing node %s" %
560 pnode_info = self._UnlockedGetNodeInfo(pnode)
561 snode_info = self._UnlockedGetNodeInfo(snode)
562 if pnode_info is None or snode_info is None:
563 raise errors.ConfigurationError("Can't find primary or secondary node"
564 " for %s" % str(disk))
565 p_data = (pnode_info.secondary_ip, port)
566 s_data = (snode_info.secondary_ip, port)
567 if pnode == node_name:
568 disk.physical_id = p_data + s_data + (pminor, secret)
569 else: # it must be secondary, we tested above
570 disk.physical_id = s_data + p_data + (sminor, secret)
572 disk.physical_id = disk.logical_id
575 @locking.ssynchronized(_config_lock)
576 def SetDiskID(self, disk, node_name):
577 """Convert the unique ID to the ID needed on the target nodes.
579 This is used only for drbd, which needs ip/port configuration.
581 The routine descends down and updates its children also, because
582 this helps when the only the top device is passed to the remote
586 return self._UnlockedSetDiskID(disk, node_name)
588 @locking.ssynchronized(_config_lock)
589 def AddTcpUdpPort(self, port):
590 """Adds a new port to the available port pool.
593 if not isinstance(port, int):
594 raise errors.ProgrammerError("Invalid type passed for port")
596 self._config_data.cluster.tcpudp_port_pool.add(port)
599 @locking.ssynchronized(_config_lock, shared=1)
600 def GetPortList(self):
601 """Returns a copy of the current port list.
604 return self._config_data.cluster.tcpudp_port_pool.copy()
606 @locking.ssynchronized(_config_lock)
607 def AllocatePort(self):
610 The port will be taken from the available port pool or from the
611 default port range (and in this case we increase
615 # If there are TCP/IP ports configured, we use them first.
616 if self._config_data.cluster.tcpudp_port_pool:
617 port = self._config_data.cluster.tcpudp_port_pool.pop()
619 port = self._config_data.cluster.highest_used_port + 1
620 if port >= constants.LAST_DRBD_PORT:
621 raise errors.ConfigurationError("The highest used port is greater"
622 " than %s. Aborting." %
623 constants.LAST_DRBD_PORT)
624 self._config_data.cluster.highest_used_port = port
629 def _UnlockedComputeDRBDMap(self):
630 """Compute the used DRBD minor/nodes.
633 @return: dictionary of node_name: dict of minor: instance_name;
634 the returned dict will have all the nodes in it (even if with
635 an empty list), and a list of duplicates; if the duplicates
636 list is not empty, the configuration is corrupted and its caller
637 should raise an exception
640 def _AppendUsedPorts(instance_name, disk, used):
642 if disk.dev_type == constants.LD_DRBD8 and len(disk.logical_id) >= 5:
643 node_a, node_b, _, minor_a, minor_b = disk.logical_id[:5]
644 for node, port in ((node_a, minor_a), (node_b, minor_b)):
645 assert node in used, ("Node '%s' of instance '%s' not found"
646 " in node list" % (node, instance_name))
647 if port in used[node]:
648 duplicates.append((node, port, instance_name, used[node][port]))
650 used[node][port] = instance_name
652 for child in disk.children:
653 duplicates.extend(_AppendUsedPorts(instance_name, child, used))
657 my_dict = dict((node, {}) for node in self._config_data.nodes)
658 for instance in self._config_data.instances.itervalues():
659 for disk in instance.disks:
660 duplicates.extend(_AppendUsedPorts(instance.name, disk, my_dict))
661 for (node, minor), instance in self._temporary_drbds.iteritems():
662 if minor in my_dict[node] and my_dict[node][minor] != instance:
663 duplicates.append((node, minor, instance, my_dict[node][minor]))
665 my_dict[node][minor] = instance
666 return my_dict, duplicates
668 @locking.ssynchronized(_config_lock)
669 def ComputeDRBDMap(self):
670 """Compute the used DRBD minor/nodes.
672 This is just a wrapper over L{_UnlockedComputeDRBDMap}.
674 @return: dictionary of node_name: dict of minor: instance_name;
675 the returned dict will have all the nodes in it (even if with
679 d_map, duplicates = self._UnlockedComputeDRBDMap()
681 raise errors.ConfigurationError("Duplicate DRBD ports detected: %s" %
685 @locking.ssynchronized(_config_lock)
686 def AllocateDRBDMinor(self, nodes, instance):
687 """Allocate a drbd minor.
689 The free minor will be automatically computed from the existing
690 devices. A node can be given multiple times in order to allocate
691 multiple minors. The result is the list of minors, in the same
692 order as the passed nodes.
694 @type instance: string
695 @param instance: the instance for which we allocate minors
698 assert isinstance(instance, basestring), \
699 "Invalid argument '%s' passed to AllocateDRBDMinor" % instance
701 d_map, duplicates = self._UnlockedComputeDRBDMap()
703 raise errors.ConfigurationError("Duplicate DRBD ports detected: %s" %
709 # no minors used, we can start at 0
712 self._temporary_drbds[(nname, 0)] = instance
716 ffree = utils.FirstFree(keys)
718 # return the next minor
719 # TODO: implement high-limit check
723 # double-check minor against current instances
724 assert minor not in d_map[nname], \
725 ("Attempt to reuse allocated DRBD minor %d on node %s,"
726 " already allocated to instance %s" %
727 (minor, nname, d_map[nname][minor]))
728 ndata[minor] = instance
729 # double-check minor against reservation
730 r_key = (nname, minor)
731 assert r_key not in self._temporary_drbds, \
732 ("Attempt to reuse reserved DRBD minor %d on node %s,"
733 " reserved for instance %s" %
734 (minor, nname, self._temporary_drbds[r_key]))
735 self._temporary_drbds[r_key] = instance
737 logging.debug("Request to allocate drbd minors, input: %s, returning %s",
741 def _UnlockedReleaseDRBDMinors(self, instance):
742 """Release temporary drbd minors allocated for a given instance.
744 @type instance: string
745 @param instance: the instance for which temporary minors should be
749 assert isinstance(instance, basestring), \
750 "Invalid argument passed to ReleaseDRBDMinors"
751 for key, name in self._temporary_drbds.items():
753 del self._temporary_drbds[key]
755 @locking.ssynchronized(_config_lock)
756 def ReleaseDRBDMinors(self, instance):
757 """Release temporary drbd minors allocated for a given instance.
759 This should be called on the error paths, on the success paths
760 it's automatically called by the ConfigWriter add and update
763 This function is just a wrapper over L{_UnlockedReleaseDRBDMinors}.
765 @type instance: string
766 @param instance: the instance for which temporary minors should be
770 self._UnlockedReleaseDRBDMinors(instance)
772 @locking.ssynchronized(_config_lock, shared=1)
773 def GetConfigVersion(self):
774 """Get the configuration version.
776 @return: Config version
779 return self._config_data.version
781 @locking.ssynchronized(_config_lock, shared=1)
782 def GetClusterName(self):
785 @return: Cluster name
788 return self._config_data.cluster.cluster_name
790 @locking.ssynchronized(_config_lock, shared=1)
791 def GetMasterNode(self):
792 """Get the hostname of the master node for this cluster.
794 @return: Master hostname
797 return self._config_data.cluster.master_node
799 @locking.ssynchronized(_config_lock, shared=1)
800 def GetMasterIP(self):
801 """Get the IP of the master node for this cluster.
806 return self._config_data.cluster.master_ip
808 @locking.ssynchronized(_config_lock, shared=1)
809 def GetMasterNetdev(self):
810 """Get the master network device for this cluster.
813 return self._config_data.cluster.master_netdev
815 @locking.ssynchronized(_config_lock, shared=1)
816 def GetFileStorageDir(self):
817 """Get the file storage dir for this cluster.
820 return self._config_data.cluster.file_storage_dir
822 @locking.ssynchronized(_config_lock, shared=1)
823 def GetHypervisorType(self):
824 """Get the hypervisor type for this cluster.
827 return self._config_data.cluster.enabled_hypervisors[0]
829 @locking.ssynchronized(_config_lock, shared=1)
830 def GetHostKey(self):
831 """Return the rsa hostkey from the config.
834 @return: the rsa hostkey
837 return self._config_data.cluster.rsahostkeypub
839 @locking.ssynchronized(_config_lock, shared=1)
840 def GetDefaultIAllocator(self):
841 """Get the default instance allocator for this cluster.
844 return self._config_data.cluster.default_iallocator
846 @locking.ssynchronized(_config_lock, shared=1)
847 def GetPrimaryIPFamily(self):
848 """Get cluster primary ip family.
850 @return: primary ip family
853 return self._config_data.cluster.primary_ip_family
855 @locking.ssynchronized(_config_lock, shared=1)
856 def LookupNodeGroup(self, target):
857 """Lookup a node group's UUID.
859 @type target: string or None
860 @param target: group name or UUID or None to look for the default
862 @return: nodegroup UUID
863 @raises errors.OpPrereqError: when the target group cannot be found
867 if len(self._config_data.nodegroups) != 1:
868 raise errors.OpPrereqError("More than one nodegroup exists. Target"
869 " group must be specified explicitely.")
871 return self._config_data.nodegroups.keys()[0]
872 if target in self._config_data.nodegroups:
874 for nodegroup in self._config_data.nodegroups.values():
875 if nodegroup.name == target:
876 return nodegroup.uuid
877 raise errors.OpPrereqError("Nodegroup '%s' not found", target)
879 @locking.ssynchronized(_config_lock, shared=1)
880 def GetNodeGroup(self, uuid):
881 """Lookup a node group.
884 @param uuid: group UUID
885 @rtype: L{objects.NodeGroup} or None
886 @return: nodegroup object, or None if not found
889 if uuid not in self._config_data.nodegroups:
892 return self._config_data.nodegroups[uuid]
894 @locking.ssynchronized(_config_lock, shared=1)
895 def GetAllNodeGroupsInfo(self):
896 """Get the configuration of all node groups.
899 return dict(self._config_data.nodegroups)
901 @locking.ssynchronized(_config_lock, shared=1)
902 def GetNodeGroupList(self):
903 """Get a list of node groups.
906 return self._config_data.nodegroups.keys()
908 @locking.ssynchronized(_config_lock)
909 def AddInstance(self, instance, ec_id):
910 """Add an instance to the config.
912 This should be used after creating a new instance.
914 @type instance: L{objects.Instance}
915 @param instance: the instance object
918 if not isinstance(instance, objects.Instance):
919 raise errors.ProgrammerError("Invalid type passed to AddInstance")
921 if instance.disk_template != constants.DT_DISKLESS:
922 all_lvs = instance.MapLVsByNode()
923 logging.info("Instance '%s' DISK_LAYOUT: %s", instance.name, all_lvs)
925 all_macs = self._AllMACs()
926 for nic in instance.nics:
927 if nic.mac in all_macs:
928 raise errors.ConfigurationError("Cannot add instance %s:"
929 " MAC address '%s' already in use." %
930 (instance.name, nic.mac))
932 self._EnsureUUID(instance, ec_id)
934 instance.serial_no = 1
935 instance.ctime = instance.mtime = time.time()
936 self._config_data.instances[instance.name] = instance
937 self._config_data.cluster.serial_no += 1
938 self._UnlockedReleaseDRBDMinors(instance.name)
941 def _EnsureUUID(self, item, ec_id):
942 """Ensures a given object has a valid UUID.
944 @param item: the instance or node to be checked
945 @param ec_id: the execution context id for the uuid reservation
949 item.uuid = self._GenerateUniqueID(ec_id)
950 elif item.uuid in self._AllIDs(include_temporary=True):
951 raise errors.ConfigurationError("Cannot add '%s': UUID %s already"
952 " in use" % (item.name, item.uuid))
954 def _SetInstanceStatus(self, instance_name, status):
955 """Set the instance's status to a given value.
958 assert isinstance(status, bool), \
959 "Invalid status '%s' passed to SetInstanceStatus" % (status,)
961 if instance_name not in self._config_data.instances:
962 raise errors.ConfigurationError("Unknown instance '%s'" %
964 instance = self._config_data.instances[instance_name]
965 if instance.admin_up != status:
966 instance.admin_up = status
967 instance.serial_no += 1
968 instance.mtime = time.time()
971 @locking.ssynchronized(_config_lock)
972 def MarkInstanceUp(self, instance_name):
973 """Mark the instance status to up in the config.
976 self._SetInstanceStatus(instance_name, True)
978 @locking.ssynchronized(_config_lock)
979 def RemoveInstance(self, instance_name):
980 """Remove the instance from the configuration.
983 if instance_name not in self._config_data.instances:
984 raise errors.ConfigurationError("Unknown instance '%s'" % instance_name)
985 del self._config_data.instances[instance_name]
986 self._config_data.cluster.serial_no += 1
989 @locking.ssynchronized(_config_lock)
990 def RenameInstance(self, old_name, new_name):
991 """Rename an instance.
993 This needs to be done in ConfigWriter and not by RemoveInstance
994 combined with AddInstance as only we can guarantee an atomic
998 if old_name not in self._config_data.instances:
999 raise errors.ConfigurationError("Unknown instance '%s'" % old_name)
1000 inst = self._config_data.instances[old_name]
1001 del self._config_data.instances[old_name]
1002 inst.name = new_name
1004 for disk in inst.disks:
1005 if disk.dev_type == constants.LD_FILE:
1006 # rename the file paths in logical and physical id
1007 file_storage_dir = os.path.dirname(os.path.dirname(disk.logical_id[1]))
1008 disk.physical_id = disk.logical_id = (disk.logical_id[0],
1009 utils.PathJoin(file_storage_dir,
1013 # Force update of ssconf files
1014 self._config_data.cluster.serial_no += 1
1016 self._config_data.instances[inst.name] = inst
1019 @locking.ssynchronized(_config_lock)
1020 def MarkInstanceDown(self, instance_name):
1021 """Mark the status of an instance to down in the configuration.
1024 self._SetInstanceStatus(instance_name, False)
1026 def _UnlockedGetInstanceList(self):
1027 """Get the list of instances.
1029 This function is for internal use, when the config lock is already held.
1032 return self._config_data.instances.keys()
1034 @locking.ssynchronized(_config_lock, shared=1)
1035 def GetInstanceList(self):
1036 """Get the list of instances.
1038 @return: array of instances, ex. ['instance2.example.com',
1039 'instance1.example.com']
1042 return self._UnlockedGetInstanceList()
1044 @locking.ssynchronized(_config_lock, shared=1)
1045 def ExpandInstanceName(self, short_name):
1046 """Attempt to expand an incomplete instance name.
1049 return utils.MatchNameComponent(short_name,
1050 self._config_data.instances.keys(),
1051 case_sensitive=False)
1053 def _UnlockedGetInstanceInfo(self, instance_name):
1054 """Returns information about an instance.
1056 This function is for internal use, when the config lock is already held.
1059 if instance_name not in self._config_data.instances:
1062 return self._config_data.instances[instance_name]
1064 @locking.ssynchronized(_config_lock, shared=1)
1065 def GetInstanceInfo(self, instance_name):
1066 """Returns information about an instance.
1068 It takes the information from the configuration file. Other information of
1069 an instance are taken from the live systems.
1071 @param instance_name: name of the instance, e.g.
1072 I{instance1.example.com}
1074 @rtype: L{objects.Instance}
1075 @return: the instance object
1078 return self._UnlockedGetInstanceInfo(instance_name)
1080 @locking.ssynchronized(_config_lock, shared=1)
1081 def GetAllInstancesInfo(self):
1082 """Get the configuration of all instances.
1085 @return: dict of (instance, instance_info), where instance_info is what
1086 would GetInstanceInfo return for the node
1089 my_dict = dict([(instance, self._UnlockedGetInstanceInfo(instance))
1090 for instance in self._UnlockedGetInstanceList()])
1093 @locking.ssynchronized(_config_lock)
1094 def AddNode(self, node, ec_id):
1095 """Add a node to the configuration.
1097 @type node: L{objects.Node}
1098 @param node: a Node instance
1101 logging.info("Adding node %s to configuration", node.name)
1103 self._EnsureUUID(node, ec_id)
1106 node.ctime = node.mtime = time.time()
1107 self._UnlockedAddNodeToGroup(node.name, node.group)
1108 self._config_data.nodes[node.name] = node
1109 self._config_data.cluster.serial_no += 1
1112 @locking.ssynchronized(_config_lock)
1113 def RemoveNode(self, node_name):
1114 """Remove a node from the configuration.
1117 logging.info("Removing node %s from configuration", node_name)
1119 if node_name not in self._config_data.nodes:
1120 raise errors.ConfigurationError("Unknown node '%s'" % node_name)
1122 self._UnlockedRemoveNodeFromGroup(self._config_data.nodes[node_name])
1123 del self._config_data.nodes[node_name]
1124 self._config_data.cluster.serial_no += 1
1127 @locking.ssynchronized(_config_lock, shared=1)
1128 def ExpandNodeName(self, short_name):
1129 """Attempt to expand an incomplete instance name.
1132 return utils.MatchNameComponent(short_name,
1133 self._config_data.nodes.keys(),
1134 case_sensitive=False)
1136 def _UnlockedGetNodeInfo(self, node_name):
1137 """Get the configuration of a node, as stored in the config.
1139 This function is for internal use, when the config lock is already
1142 @param node_name: the node name, e.g. I{node1.example.com}
1144 @rtype: L{objects.Node}
1145 @return: the node object
1148 if node_name not in self._config_data.nodes:
1151 return self._config_data.nodes[node_name]
1153 @locking.ssynchronized(_config_lock, shared=1)
1154 def GetNodeInfo(self, node_name):
1155 """Get the configuration of a node, as stored in the config.
1157 This is just a locked wrapper over L{_UnlockedGetNodeInfo}.
1159 @param node_name: the node name, e.g. I{node1.example.com}
1161 @rtype: L{objects.Node}
1162 @return: the node object
1165 return self._UnlockedGetNodeInfo(node_name)
1167 @locking.ssynchronized(_config_lock, shared=1)
1168 def GetNodeInstances(self, node_name):
1169 """Get the instances of a node, as stored in the config.
1171 @param node_name: the node name, e.g. I{node1.example.com}
1173 @rtype: (list, list)
1174 @return: a tuple with two lists: the primary and the secondary instances
1179 for inst in self._config_data.instances.values():
1180 if inst.primary_node == node_name:
1181 pri.append(inst.name)
1182 if node_name in inst.secondary_nodes:
1183 sec.append(inst.name)
1186 def _UnlockedGetNodeList(self):
1187 """Return the list of nodes which are in the configuration.
1189 This function is for internal use, when the config lock is already
1195 return self._config_data.nodes.keys()
1197 @locking.ssynchronized(_config_lock, shared=1)
1198 def GetNodeList(self):
1199 """Return the list of nodes which are in the configuration.
1202 return self._UnlockedGetNodeList()
1204 def _UnlockedGetOnlineNodeList(self):
1205 """Return the list of nodes which are online.
1208 all_nodes = [self._UnlockedGetNodeInfo(node)
1209 for node in self._UnlockedGetNodeList()]
1210 return [node.name for node in all_nodes if not node.offline]
1212 @locking.ssynchronized(_config_lock, shared=1)
1213 def GetOnlineNodeList(self):
1214 """Return the list of nodes which are online.
1217 return self._UnlockedGetOnlineNodeList()
1219 @locking.ssynchronized(_config_lock, shared=1)
1220 def GetNonVmCapableNodeList(self):
1221 """Return the list of nodes which are not vm capable.
1224 all_nodes = [self._UnlockedGetNodeInfo(node)
1225 for node in self._UnlockedGetNodeList()]
1226 return [node.name for node in all_nodes if not node.vm_capable]
1228 @locking.ssynchronized(_config_lock, shared=1)
1229 def GetAllNodesInfo(self):
1230 """Get the configuration of all nodes.
1233 @return: dict of (node, node_info), where node_info is what
1234 would GetNodeInfo return for the node
1237 my_dict = dict([(node, self._UnlockedGetNodeInfo(node))
1238 for node in self._UnlockedGetNodeList()])
1241 def _UnlockedGetMasterCandidateStats(self, exceptions=None):
1242 """Get the number of current and maximum desired and possible candidates.
1244 @type exceptions: list
1245 @param exceptions: if passed, list of nodes that should be ignored
1247 @return: tuple of (current, desired and possible, possible)
1250 mc_now = mc_should = mc_max = 0
1251 for node in self._config_data.nodes.values():
1252 if exceptions and node.name in exceptions:
1254 if not (node.offline or node.drained) and node.master_capable:
1256 if node.master_candidate:
1258 mc_should = min(mc_max, self._config_data.cluster.candidate_pool_size)
1259 return (mc_now, mc_should, mc_max)
1261 @locking.ssynchronized(_config_lock, shared=1)
1262 def GetMasterCandidateStats(self, exceptions=None):
1263 """Get the number of current and maximum possible candidates.
1265 This is just a wrapper over L{_UnlockedGetMasterCandidateStats}.
1267 @type exceptions: list
1268 @param exceptions: if passed, list of nodes that should be ignored
1270 @return: tuple of (current, max)
1273 return self._UnlockedGetMasterCandidateStats(exceptions)
1275 @locking.ssynchronized(_config_lock)
1276 def MaintainCandidatePool(self, exceptions):
1277 """Try to grow the candidate pool to the desired size.
1279 @type exceptions: list
1280 @param exceptions: if passed, list of nodes that should be ignored
1282 @return: list with the adjusted nodes (L{objects.Node} instances)
1285 mc_now, mc_max, _ = self._UnlockedGetMasterCandidateStats(exceptions)
1288 node_list = self._config_data.nodes.keys()
1289 random.shuffle(node_list)
1290 for name in node_list:
1291 if mc_now >= mc_max:
1293 node = self._config_data.nodes[name]
1294 if (node.master_candidate or node.offline or node.drained or
1295 node.name in exceptions or not node.master_capable):
1297 mod_list.append(node)
1298 node.master_candidate = True
1301 if mc_now != mc_max:
1302 # this should not happen
1303 logging.warning("Warning: MaintainCandidatePool didn't manage to"
1304 " fill the candidate pool (%d/%d)", mc_now, mc_max)
1306 self._config_data.cluster.serial_no += 1
1311 def _UnlockedAddNodeToGroup(self, node_name, nodegroup_uuid):
1312 """Add a given node to the specified group.
1315 if nodegroup_uuid not in self._config_data.nodegroups:
1316 # This can happen if a node group gets deleted between its lookup and
1317 # when we're adding the first node to it, since we don't keep a lock in
1318 # the meantime. It's ok though, as we'll fail cleanly if the node group
1319 # is not found anymore.
1320 raise errors.OpExecError("Unknown node group: %s" % nodegroup_uuid)
1321 if node_name not in self._config_data.nodegroups[nodegroup_uuid].members:
1322 self._config_data.nodegroups[nodegroup_uuid].members.append(node_name)
1324 def _UnlockedRemoveNodeFromGroup(self, node):
1325 """Remove a given node from its group.
1328 nodegroup = node.group
1329 if nodegroup not in self._config_data.nodegroups:
1330 logging.warning("Warning: node '%s' has unknown node group '%s'"
1331 " (while being removed from it)", node.name, nodegroup)
1332 nodegroup_obj = self._config_data.nodegroups[nodegroup]
1333 if node.name not in nodegroup_obj.members:
1334 logging.warning("Warning: node '%s' not a member of its node group '%s'"
1335 " (while being removed from it)", node.name, nodegroup)
1337 nodegroup_obj.members.remove(node.name)
1339 def _BumpSerialNo(self):
1340 """Bump up the serial number of the config.
1343 self._config_data.serial_no += 1
1344 self._config_data.mtime = time.time()
1346 def _AllUUIDObjects(self):
1347 """Returns all objects with uuid attributes.
1350 return (self._config_data.instances.values() +
1351 self._config_data.nodes.values() +
1352 self._config_data.nodegroups.values() +
1353 [self._config_data.cluster])
1355 def _OpenConfig(self, accept_foreign):
1356 """Read the config data from disk.
1359 raw_data = utils.ReadFile(self._cfg_file)
1362 data = objects.ConfigData.FromDict(serializer.Load(raw_data))
1363 except Exception, err:
1364 raise errors.ConfigurationError(err)
1366 # Make sure the configuration has the right version
1367 _ValidateConfig(data)
1369 if (not hasattr(data, 'cluster') or
1370 not hasattr(data.cluster, 'rsahostkeypub')):
1371 raise errors.ConfigurationError("Incomplete configuration"
1372 " (missing cluster.rsahostkeypub)")
1374 if data.cluster.master_node != self._my_hostname and not accept_foreign:
1375 msg = ("The configuration denotes node %s as master, while my"
1376 " hostname is %s; opening a foreign configuration is only"
1377 " possible in accept_foreign mode" %
1378 (data.cluster.master_node, self._my_hostname))
1379 raise errors.ConfigurationError(msg)
1381 # Upgrade configuration if needed
1382 data.UpgradeConfig()
1384 self._config_data = data
1385 # reset the last serial as -1 so that the next write will cause
1387 self._last_cluster_serial = -1
1389 # And finally run our (custom) config upgrade sequence
1390 self._UpgradeConfig()
1392 self._cfg_id = utils.GetFileID(path=self._cfg_file)
1394 def _UpgradeConfig(self):
1395 """Run upgrade steps that cannot be done purely in the objects.
1397 This is because some data elements need uniqueness across the
1398 whole configuration, etc.
1400 @warning: this function will call L{_WriteConfig()}, but also
1401 L{DropECReservations} so it needs to be called only from a
1402 "safe" place (the constructor). If one wanted to call it with
1403 the lock held, a DropECReservationUnlocked would need to be
1404 created first, to avoid causing deadlock.
1408 for item in self._AllUUIDObjects():
1409 if item.uuid is None:
1410 item.uuid = self._GenerateUniqueID(_UPGRADE_CONFIG_JID)
1412 if not self._config_data.nodegroups:
1413 default_nodegroup_uuid = self._GenerateUniqueID(_UPGRADE_CONFIG_JID)
1414 default_nodegroup = objects.NodeGroup(
1415 uuid=default_nodegroup_uuid,
1419 self._config_data.nodegroups[default_nodegroup_uuid] = default_nodegroup
1421 for node in self._config_data.nodes.values():
1423 node.group = self.LookupNodeGroup(None)
1425 # This is technically *not* an upgrade, but needs to be done both when
1426 # nodegroups are being added, and upon normally loading the config,
1427 # because the members list of a node group is discarded upon
1428 # serializing/deserializing the object.
1429 self._UnlockedAddNodeToGroup(node.name, node.group)
1432 # This is ok even if it acquires the internal lock, as _UpgradeConfig is
1433 # only called at config init time, without the lock held
1434 self.DropECReservations(_UPGRADE_CONFIG_JID)
1436 def _DistributeConfig(self, feedback_fn):
1437 """Distribute the configuration to the other nodes.
1439 Currently, this only copies the configuration file. In the future,
1440 it could be used to encapsulate the 2/3-phase update mechanism.
1450 myhostname = self._my_hostname
1451 # we can skip checking whether _UnlockedGetNodeInfo returns None
1452 # since the node list comes from _UnlocketGetNodeList, and we are
1453 # called with the lock held, so no modifications should take place
1455 for node_name in self._UnlockedGetNodeList():
1456 if node_name == myhostname:
1458 node_info = self._UnlockedGetNodeInfo(node_name)
1459 if not node_info.master_candidate:
1461 node_list.append(node_info.name)
1462 addr_list.append(node_info.primary_ip)
1464 result = rpc.RpcRunner.call_upload_file(node_list, self._cfg_file,
1465 address_list=addr_list)
1466 for to_node, to_result in result.items():
1467 msg = to_result.fail_msg
1469 msg = ("Copy of file %s to node %s failed: %s" %
1470 (self._cfg_file, to_node, msg))
1480 def _WriteConfig(self, destination=None, feedback_fn=None):
1481 """Write the configuration data to persistent storage.
1484 assert feedback_fn is None or callable(feedback_fn)
1486 # Warn on config errors, but don't abort the save - the
1487 # configuration has already been modified, and we can't revert;
1488 # the best we can do is to warn the user and save as is, leaving
1489 # recovery to the user
1490 config_errors = self._UnlockedVerifyConfig()
1492 errmsg = ("Configuration data is not consistent: %s" %
1493 (utils.CommaJoin(config_errors)))
1494 logging.critical(errmsg)
1498 if destination is None:
1499 destination = self._cfg_file
1500 self._BumpSerialNo()
1501 txt = serializer.Dump(self._config_data.ToDict())
1503 getents = self._getents()
1505 fd = utils.SafeWriteFile(destination, self._cfg_id, data=txt,
1506 close=False, gid=getents.confd_gid, mode=0640)
1507 except errors.LockError:
1508 raise errors.ConfigurationError("The configuration file has been"
1509 " modified since the last write, cannot"
1512 self._cfg_id = utils.GetFileID(fd=fd)
1516 self.write_count += 1
1518 # and redistribute the config file to master candidates
1519 self._DistributeConfig(feedback_fn)
1521 # Write ssconf files on all nodes (including locally)
1522 if self._last_cluster_serial < self._config_data.cluster.serial_no:
1523 if not self._offline:
1524 result = rpc.RpcRunner.call_write_ssconf_files(
1525 self._UnlockedGetOnlineNodeList(),
1526 self._UnlockedGetSsconfValues())
1528 for nname, nresu in result.items():
1529 msg = nresu.fail_msg
1531 errmsg = ("Error while uploading ssconf files to"
1532 " node %s: %s" % (nname, msg))
1533 logging.warning(errmsg)
1538 self._last_cluster_serial = self._config_data.cluster.serial_no
1540 def _UnlockedGetSsconfValues(self):
1541 """Return the values needed by ssconf.
1544 @return: a dictionary with keys the ssconf names and values their
1549 instance_names = utils.NiceSort(self._UnlockedGetInstanceList())
1550 node_names = utils.NiceSort(self._UnlockedGetNodeList())
1551 node_info = [self._UnlockedGetNodeInfo(name) for name in node_names]
1552 node_pri_ips = ["%s %s" % (ninfo.name, ninfo.primary_ip)
1553 for ninfo in node_info]
1554 node_snd_ips = ["%s %s" % (ninfo.name, ninfo.secondary_ip)
1555 for ninfo in node_info]
1557 instance_data = fn(instance_names)
1558 off_data = fn(node.name for node in node_info if node.offline)
1559 on_data = fn(node.name for node in node_info if not node.offline)
1560 mc_data = fn(node.name for node in node_info if node.master_candidate)
1561 mc_ips_data = fn(node.primary_ip for node in node_info
1562 if node.master_candidate)
1563 node_data = fn(node_names)
1564 node_pri_ips_data = fn(node_pri_ips)
1565 node_snd_ips_data = fn(node_snd_ips)
1567 cluster = self._config_data.cluster
1568 cluster_tags = fn(cluster.GetTags())
1570 hypervisor_list = fn(cluster.enabled_hypervisors)
1572 uid_pool = uidpool.FormatUidPool(cluster.uid_pool, separator="\n")
1574 nodegroups = ["%s %s" % (nodegroup.uuid, nodegroup.name) for nodegroup in
1575 self._config_data.nodegroups.values()]
1576 nodegroups_data = fn(utils.NiceSort(nodegroups))
1579 constants.SS_CLUSTER_NAME: cluster.cluster_name,
1580 constants.SS_CLUSTER_TAGS: cluster_tags,
1581 constants.SS_FILE_STORAGE_DIR: cluster.file_storage_dir,
1582 constants.SS_MASTER_CANDIDATES: mc_data,
1583 constants.SS_MASTER_CANDIDATES_IPS: mc_ips_data,
1584 constants.SS_MASTER_IP: cluster.master_ip,
1585 constants.SS_MASTER_NETDEV: cluster.master_netdev,
1586 constants.SS_MASTER_NODE: cluster.master_node,
1587 constants.SS_NODE_LIST: node_data,
1588 constants.SS_NODE_PRIMARY_IPS: node_pri_ips_data,
1589 constants.SS_NODE_SECONDARY_IPS: node_snd_ips_data,
1590 constants.SS_OFFLINE_NODES: off_data,
1591 constants.SS_ONLINE_NODES: on_data,
1592 constants.SS_PRIMARY_IP_FAMILY: str(cluster.primary_ip_family),
1593 constants.SS_INSTANCE_LIST: instance_data,
1594 constants.SS_RELEASE_VERSION: constants.RELEASE_VERSION,
1595 constants.SS_HYPERVISOR_LIST: hypervisor_list,
1596 constants.SS_MAINTAIN_NODE_HEALTH: str(cluster.maintain_node_health),
1597 constants.SS_UID_POOL: uid_pool,
1598 constants.SS_NODEGROUPS: nodegroups_data,
1601 @locking.ssynchronized(_config_lock, shared=1)
1602 def GetSsconfValues(self):
1603 """Wrapper using lock around _UnlockedGetSsconf().
1606 return self._UnlockedGetSsconfValues()
1608 @locking.ssynchronized(_config_lock, shared=1)
1609 def GetVGName(self):
1610 """Return the volume group name.
1613 return self._config_data.cluster.volume_group_name
1615 @locking.ssynchronized(_config_lock)
1616 def SetVGName(self, vg_name):
1617 """Set the volume group name.
1620 self._config_data.cluster.volume_group_name = vg_name
1621 self._config_data.cluster.serial_no += 1
1624 @locking.ssynchronized(_config_lock, shared=1)
1625 def GetDRBDHelper(self):
1626 """Return DRBD usermode helper.
1629 return self._config_data.cluster.drbd_usermode_helper
1631 @locking.ssynchronized(_config_lock)
1632 def SetDRBDHelper(self, drbd_helper):
1633 """Set DRBD usermode helper.
1636 self._config_data.cluster.drbd_usermode_helper = drbd_helper
1637 self._config_data.cluster.serial_no += 1
1640 @locking.ssynchronized(_config_lock, shared=1)
1641 def GetMACPrefix(self):
1642 """Return the mac prefix.
1645 return self._config_data.cluster.mac_prefix
1647 @locking.ssynchronized(_config_lock, shared=1)
1648 def GetClusterInfo(self):
1649 """Returns information about the cluster
1651 @rtype: L{objects.Cluster}
1652 @return: the cluster object
1655 return self._config_data.cluster
1657 @locking.ssynchronized(_config_lock, shared=1)
1658 def HasAnyDiskOfType(self, dev_type):
1659 """Check if in there is at disk of the given type in the configuration.
1662 return self._config_data.HasAnyDiskOfType(dev_type)
1664 @locking.ssynchronized(_config_lock)
1665 def Update(self, target, feedback_fn):
1666 """Notify function to be called after updates.
1668 This function must be called when an object (as returned by
1669 GetInstanceInfo, GetNodeInfo, GetCluster) has been updated and the
1670 caller wants the modifications saved to the backing store. Note
1671 that all modified objects will be saved, but the target argument
1672 is the one the caller wants to ensure that it's saved.
1674 @param target: an instance of either L{objects.Cluster},
1675 L{objects.Node} or L{objects.Instance} which is existing in
1677 @param feedback_fn: Callable feedback function
1680 if self._config_data is None:
1681 raise errors.ProgrammerError("Configuration file not read,"
1683 update_serial = False
1684 if isinstance(target, objects.Cluster):
1685 test = target == self._config_data.cluster
1686 elif isinstance(target, objects.Node):
1687 test = target in self._config_data.nodes.values()
1688 update_serial = True
1689 elif isinstance(target, objects.Instance):
1690 test = target in self._config_data.instances.values()
1692 raise errors.ProgrammerError("Invalid object type (%s) passed to"
1693 " ConfigWriter.Update" % type(target))
1695 raise errors.ConfigurationError("Configuration updated since object"
1696 " has been read or unknown object")
1697 target.serial_no += 1
1698 target.mtime = now = time.time()
1701 # for node updates, we need to increase the cluster serial too
1702 self._config_data.cluster.serial_no += 1
1703 self._config_data.cluster.mtime = now
1705 if isinstance(target, objects.Instance):
1706 self._UnlockedReleaseDRBDMinors(target.name)
1708 self._WriteConfig(feedback_fn=feedback_fn)
1710 @locking.ssynchronized(_config_lock)
1711 def DropECReservations(self, ec_id):
1712 """Drop per-execution-context reservations
1715 for rm in self._all_rms:
1716 rm.DropECReservations(ec_id)