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.items():
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 GetAllNodeGroupsInfo(self):
881 """Get the configuration of all node groups.
884 return dict(self._config_data.nodegroups)
886 @locking.ssynchronized(_config_lock, shared=1)
887 def GetNodeGroupList(self):
888 """Get a list of node groups.
891 return self._config_data.nodegroups.keys()
893 @locking.ssynchronized(_config_lock)
894 def AddInstance(self, instance, ec_id):
895 """Add an instance to the config.
897 This should be used after creating a new instance.
899 @type instance: L{objects.Instance}
900 @param instance: the instance object
903 if not isinstance(instance, objects.Instance):
904 raise errors.ProgrammerError("Invalid type passed to AddInstance")
906 if instance.disk_template != constants.DT_DISKLESS:
907 all_lvs = instance.MapLVsByNode()
908 logging.info("Instance '%s' DISK_LAYOUT: %s", instance.name, all_lvs)
910 all_macs = self._AllMACs()
911 for nic in instance.nics:
912 if nic.mac in all_macs:
913 raise errors.ConfigurationError("Cannot add instance %s:"
914 " MAC address '%s' already in use." %
915 (instance.name, nic.mac))
917 self._EnsureUUID(instance, ec_id)
919 instance.serial_no = 1
920 instance.ctime = instance.mtime = time.time()
921 self._config_data.instances[instance.name] = instance
922 self._config_data.cluster.serial_no += 1
923 self._UnlockedReleaseDRBDMinors(instance.name)
926 def _EnsureUUID(self, item, ec_id):
927 """Ensures a given object has a valid UUID.
929 @param item: the instance or node to be checked
930 @param ec_id: the execution context id for the uuid reservation
934 item.uuid = self._GenerateUniqueID(ec_id)
935 elif item.uuid in self._AllIDs(include_temporary=True):
936 raise errors.ConfigurationError("Cannot add '%s': UUID %s already"
937 " in use" % (item.name, item.uuid))
939 def _SetInstanceStatus(self, instance_name, status):
940 """Set the instance's status to a given value.
943 assert isinstance(status, bool), \
944 "Invalid status '%s' passed to SetInstanceStatus" % (status,)
946 if instance_name not in self._config_data.instances:
947 raise errors.ConfigurationError("Unknown instance '%s'" %
949 instance = self._config_data.instances[instance_name]
950 if instance.admin_up != status:
951 instance.admin_up = status
952 instance.serial_no += 1
953 instance.mtime = time.time()
956 @locking.ssynchronized(_config_lock)
957 def MarkInstanceUp(self, instance_name):
958 """Mark the instance status to up in the config.
961 self._SetInstanceStatus(instance_name, True)
963 @locking.ssynchronized(_config_lock)
964 def RemoveInstance(self, instance_name):
965 """Remove the instance from the configuration.
968 if instance_name not in self._config_data.instances:
969 raise errors.ConfigurationError("Unknown instance '%s'" % instance_name)
970 del self._config_data.instances[instance_name]
971 self._config_data.cluster.serial_no += 1
974 @locking.ssynchronized(_config_lock)
975 def RenameInstance(self, old_name, new_name):
976 """Rename an instance.
978 This needs to be done in ConfigWriter and not by RemoveInstance
979 combined with AddInstance as only we can guarantee an atomic
983 if old_name not in self._config_data.instances:
984 raise errors.ConfigurationError("Unknown instance '%s'" % old_name)
985 inst = self._config_data.instances[old_name]
986 del self._config_data.instances[old_name]
989 for disk in inst.disks:
990 if disk.dev_type == constants.LD_FILE:
991 # rename the file paths in logical and physical id
992 file_storage_dir = os.path.dirname(os.path.dirname(disk.logical_id[1]))
993 disk.physical_id = disk.logical_id = (disk.logical_id[0],
994 utils.PathJoin(file_storage_dir,
998 # Force update of ssconf files
999 self._config_data.cluster.serial_no += 1
1001 self._config_data.instances[inst.name] = inst
1004 @locking.ssynchronized(_config_lock)
1005 def MarkInstanceDown(self, instance_name):
1006 """Mark the status of an instance to down in the configuration.
1009 self._SetInstanceStatus(instance_name, False)
1011 def _UnlockedGetInstanceList(self):
1012 """Get the list of instances.
1014 This function is for internal use, when the config lock is already held.
1017 return self._config_data.instances.keys()
1019 @locking.ssynchronized(_config_lock, shared=1)
1020 def GetInstanceList(self):
1021 """Get the list of instances.
1023 @return: array of instances, ex. ['instance2.example.com',
1024 'instance1.example.com']
1027 return self._UnlockedGetInstanceList()
1029 @locking.ssynchronized(_config_lock, shared=1)
1030 def ExpandInstanceName(self, short_name):
1031 """Attempt to expand an incomplete instance name.
1034 return utils.MatchNameComponent(short_name,
1035 self._config_data.instances.keys(),
1036 case_sensitive=False)
1038 def _UnlockedGetInstanceInfo(self, instance_name):
1039 """Returns information about an instance.
1041 This function is for internal use, when the config lock is already held.
1044 if instance_name not in self._config_data.instances:
1047 return self._config_data.instances[instance_name]
1049 @locking.ssynchronized(_config_lock, shared=1)
1050 def GetInstanceInfo(self, instance_name):
1051 """Returns information about an instance.
1053 It takes the information from the configuration file. Other information of
1054 an instance are taken from the live systems.
1056 @param instance_name: name of the instance, e.g.
1057 I{instance1.example.com}
1059 @rtype: L{objects.Instance}
1060 @return: the instance object
1063 return self._UnlockedGetInstanceInfo(instance_name)
1065 @locking.ssynchronized(_config_lock, shared=1)
1066 def GetAllInstancesInfo(self):
1067 """Get the configuration of all instances.
1070 @return: dict of (instance, instance_info), where instance_info is what
1071 would GetInstanceInfo return for the node
1074 my_dict = dict([(instance, self._UnlockedGetInstanceInfo(instance))
1075 for instance in self._UnlockedGetInstanceList()])
1078 @locking.ssynchronized(_config_lock)
1079 def AddNode(self, node, ec_id):
1080 """Add a node to the configuration.
1082 @type node: L{objects.Node}
1083 @param node: a Node instance
1086 logging.info("Adding node %s to configuration", node.name)
1088 self._EnsureUUID(node, ec_id)
1091 node.ctime = node.mtime = time.time()
1092 self._UnlockedAddNodeToGroup(node.name, node.group)
1093 self._config_data.nodes[node.name] = node
1094 self._config_data.cluster.serial_no += 1
1097 @locking.ssynchronized(_config_lock)
1098 def RemoveNode(self, node_name):
1099 """Remove a node from the configuration.
1102 logging.info("Removing node %s from configuration", node_name)
1104 if node_name not in self._config_data.nodes:
1105 raise errors.ConfigurationError("Unknown node '%s'" % node_name)
1107 self._UnlockedRemoveNodeFromGroup(self._config_data.nodes[node_name])
1108 del self._config_data.nodes[node_name]
1109 self._config_data.cluster.serial_no += 1
1112 @locking.ssynchronized(_config_lock, shared=1)
1113 def ExpandNodeName(self, short_name):
1114 """Attempt to expand an incomplete instance name.
1117 return utils.MatchNameComponent(short_name,
1118 self._config_data.nodes.keys(),
1119 case_sensitive=False)
1121 def _UnlockedGetNodeInfo(self, node_name):
1122 """Get the configuration of a node, as stored in the config.
1124 This function is for internal use, when the config lock is already
1127 @param node_name: the node name, e.g. I{node1.example.com}
1129 @rtype: L{objects.Node}
1130 @return: the node object
1133 if node_name not in self._config_data.nodes:
1136 return self._config_data.nodes[node_name]
1138 @locking.ssynchronized(_config_lock, shared=1)
1139 def GetNodeInfo(self, node_name):
1140 """Get the configuration of a node, as stored in the config.
1142 This is just a locked wrapper over L{_UnlockedGetNodeInfo}.
1144 @param node_name: the node name, e.g. I{node1.example.com}
1146 @rtype: L{objects.Node}
1147 @return: the node object
1150 return self._UnlockedGetNodeInfo(node_name)
1152 @locking.ssynchronized(_config_lock, shared=1)
1153 def GetNodeInstances(self, node_name):
1154 """Get the instances of a node, as stored in the config.
1156 @param node_name: the node name, e.g. I{node1.example.com}
1158 @rtype: (list, list)
1159 @return: a tuple with two lists: the primary and the secondary instances
1164 for inst in self._config_data.instances.values():
1165 if inst.primary_node == node_name:
1166 pri.append(inst.name)
1167 if node_name in inst.secondary_nodes:
1168 sec.append(inst.name)
1171 def _UnlockedGetNodeList(self):
1172 """Return the list of nodes which are in the configuration.
1174 This function is for internal use, when the config lock is already
1180 return self._config_data.nodes.keys()
1182 @locking.ssynchronized(_config_lock, shared=1)
1183 def GetNodeList(self):
1184 """Return the list of nodes which are in the configuration.
1187 return self._UnlockedGetNodeList()
1189 def _UnlockedGetOnlineNodeList(self):
1190 """Return the list of nodes which are online.
1193 all_nodes = [self._UnlockedGetNodeInfo(node)
1194 for node in self._UnlockedGetNodeList()]
1195 return [node.name for node in all_nodes if not node.offline]
1197 @locking.ssynchronized(_config_lock, shared=1)
1198 def GetOnlineNodeList(self):
1199 """Return the list of nodes which are online.
1202 return self._UnlockedGetOnlineNodeList()
1204 @locking.ssynchronized(_config_lock, shared=1)
1205 def GetNonVmCapableNodeList(self):
1206 """Return the list of nodes which are not vm capable.
1209 all_nodes = [self._UnlockedGetNodeInfo(node)
1210 for node in self._UnlockedGetNodeList()]
1211 return [node.name for node in all_nodes if not node.vm_capable]
1213 @locking.ssynchronized(_config_lock, shared=1)
1214 def GetAllNodesInfo(self):
1215 """Get the configuration of all nodes.
1218 @return: dict of (node, node_info), where node_info is what
1219 would GetNodeInfo return for the node
1222 my_dict = dict([(node, self._UnlockedGetNodeInfo(node))
1223 for node in self._UnlockedGetNodeList()])
1226 def _UnlockedGetMasterCandidateStats(self, exceptions=None):
1227 """Get the number of current and maximum desired and possible candidates.
1229 @type exceptions: list
1230 @param exceptions: if passed, list of nodes that should be ignored
1232 @return: tuple of (current, desired and possible, possible)
1235 mc_now = mc_should = mc_max = 0
1236 for node in self._config_data.nodes.values():
1237 if exceptions and node.name in exceptions:
1239 if not (node.offline or node.drained) and node.master_capable:
1241 if node.master_candidate:
1243 mc_should = min(mc_max, self._config_data.cluster.candidate_pool_size)
1244 return (mc_now, mc_should, mc_max)
1246 @locking.ssynchronized(_config_lock, shared=1)
1247 def GetMasterCandidateStats(self, exceptions=None):
1248 """Get the number of current and maximum possible candidates.
1250 This is just a wrapper over L{_UnlockedGetMasterCandidateStats}.
1252 @type exceptions: list
1253 @param exceptions: if passed, list of nodes that should be ignored
1255 @return: tuple of (current, max)
1258 return self._UnlockedGetMasterCandidateStats(exceptions)
1260 @locking.ssynchronized(_config_lock)
1261 def MaintainCandidatePool(self, exceptions):
1262 """Try to grow the candidate pool to the desired size.
1264 @type exceptions: list
1265 @param exceptions: if passed, list of nodes that should be ignored
1267 @return: list with the adjusted nodes (L{objects.Node} instances)
1270 mc_now, mc_max, _ = self._UnlockedGetMasterCandidateStats(exceptions)
1273 node_list = self._config_data.nodes.keys()
1274 random.shuffle(node_list)
1275 for name in node_list:
1276 if mc_now >= mc_max:
1278 node = self._config_data.nodes[name]
1279 if (node.master_candidate or node.offline or node.drained or
1280 node.name in exceptions or not node.master_capable):
1282 mod_list.append(node)
1283 node.master_candidate = True
1286 if mc_now != mc_max:
1287 # this should not happen
1288 logging.warning("Warning: MaintainCandidatePool didn't manage to"
1289 " fill the candidate pool (%d/%d)", mc_now, mc_max)
1291 self._config_data.cluster.serial_no += 1
1296 def _UnlockedAddNodeToGroup(self, node_name, nodegroup_uuid):
1297 """Add a given node to the specified group.
1300 if nodegroup_uuid not in self._config_data.nodegroups:
1301 # This can happen if a node group gets deleted between its lookup and
1302 # when we're adding the first node to it, since we don't keep a lock in
1303 # the meantime. It's ok though, as we'll fail cleanly if the node group
1304 # is not found anymore.
1305 raise errors.OpExecError("Unknown node group: %s" % nodegroup_uuid)
1306 if node_name not in self._config_data.nodegroups[nodegroup_uuid].members:
1307 self._config_data.nodegroups[nodegroup_uuid].members.append(node_name)
1309 def _UnlockedRemoveNodeFromGroup(self, node):
1310 """Remove a given node from its group.
1313 nodegroup = node.group
1314 if nodegroup not in self._config_data.nodegroups:
1315 logging.warning("Warning: node '%s' has unknown node group '%s'"
1316 " (while being removed from it)", node.name, nodegroup)
1317 nodegroup_obj = self._config_data.nodegroups[nodegroup]
1318 if node.name not in nodegroup_obj.members:
1319 logging.warning("Warning: node '%s' not a member of its node group '%s'"
1320 " (while being removed from it)", node.name, nodegroup)
1322 nodegroup_obj.members.remove(node.name)
1324 def _BumpSerialNo(self):
1325 """Bump up the serial number of the config.
1328 self._config_data.serial_no += 1
1329 self._config_data.mtime = time.time()
1331 def _AllUUIDObjects(self):
1332 """Returns all objects with uuid attributes.
1335 return (self._config_data.instances.values() +
1336 self._config_data.nodes.values() +
1337 self._config_data.nodegroups.values() +
1338 [self._config_data.cluster])
1340 def _OpenConfig(self, accept_foreign):
1341 """Read the config data from disk.
1344 raw_data = utils.ReadFile(self._cfg_file)
1347 data = objects.ConfigData.FromDict(serializer.Load(raw_data))
1348 except Exception, err:
1349 raise errors.ConfigurationError(err)
1351 # Make sure the configuration has the right version
1352 _ValidateConfig(data)
1354 if (not hasattr(data, 'cluster') or
1355 not hasattr(data.cluster, 'rsahostkeypub')):
1356 raise errors.ConfigurationError("Incomplete configuration"
1357 " (missing cluster.rsahostkeypub)")
1359 if data.cluster.master_node != self._my_hostname and not accept_foreign:
1360 msg = ("The configuration denotes node %s as master, while my"
1361 " hostname is %s; opening a foreign configuration is only"
1362 " possible in accept_foreign mode" %
1363 (data.cluster.master_node, self._my_hostname))
1364 raise errors.ConfigurationError(msg)
1366 # Upgrade configuration if needed
1367 data.UpgradeConfig()
1369 self._config_data = data
1370 # reset the last serial as -1 so that the next write will cause
1372 self._last_cluster_serial = -1
1374 # And finally run our (custom) config upgrade sequence
1375 self._UpgradeConfig()
1377 self._cfg_id = utils.GetFileID(path=self._cfg_file)
1379 def _UpgradeConfig(self):
1380 """Run upgrade steps that cannot be done purely in the objects.
1382 This is because some data elements need uniqueness across the
1383 whole configuration, etc.
1385 @warning: this function will call L{_WriteConfig()}, but also
1386 L{DropECReservations} so it needs to be called only from a
1387 "safe" place (the constructor). If one wanted to call it with
1388 the lock held, a DropECReservationUnlocked would need to be
1389 created first, to avoid causing deadlock.
1393 for item in self._AllUUIDObjects():
1394 if item.uuid is None:
1395 item.uuid = self._GenerateUniqueID(_UPGRADE_CONFIG_JID)
1397 if not self._config_data.nodegroups:
1398 default_nodegroup_uuid = self._GenerateUniqueID(_UPGRADE_CONFIG_JID)
1399 default_nodegroup = objects.NodeGroup(
1400 uuid=default_nodegroup_uuid,
1404 self._config_data.nodegroups[default_nodegroup_uuid] = default_nodegroup
1406 for node in self._config_data.nodes.values():
1408 node.group = self.LookupNodeGroup(None)
1410 # This is technically *not* an upgrade, but needs to be done both when
1411 # nodegroups are being added, and upon normally loading the config,
1412 # because the members list of a node group is discarded upon
1413 # serializing/deserializing the object.
1414 self._UnlockedAddNodeToGroup(node.name, node.group)
1417 # This is ok even if it acquires the internal lock, as _UpgradeConfig is
1418 # only called at config init time, without the lock held
1419 self.DropECReservations(_UPGRADE_CONFIG_JID)
1421 def _DistributeConfig(self, feedback_fn):
1422 """Distribute the configuration to the other nodes.
1424 Currently, this only copies the configuration file. In the future,
1425 it could be used to encapsulate the 2/3-phase update mechanism.
1435 myhostname = self._my_hostname
1436 # we can skip checking whether _UnlockedGetNodeInfo returns None
1437 # since the node list comes from _UnlocketGetNodeList, and we are
1438 # called with the lock held, so no modifications should take place
1440 for node_name in self._UnlockedGetNodeList():
1441 if node_name == myhostname:
1443 node_info = self._UnlockedGetNodeInfo(node_name)
1444 if not node_info.master_candidate:
1446 node_list.append(node_info.name)
1447 addr_list.append(node_info.primary_ip)
1449 result = rpc.RpcRunner.call_upload_file(node_list, self._cfg_file,
1450 address_list=addr_list)
1451 for to_node, to_result in result.items():
1452 msg = to_result.fail_msg
1454 msg = ("Copy of file %s to node %s failed: %s" %
1455 (self._cfg_file, to_node, msg))
1465 def _WriteConfig(self, destination=None, feedback_fn=None):
1466 """Write the configuration data to persistent storage.
1469 assert feedback_fn is None or callable(feedback_fn)
1471 # Warn on config errors, but don't abort the save - the
1472 # configuration has already been modified, and we can't revert;
1473 # the best we can do is to warn the user and save as is, leaving
1474 # recovery to the user
1475 config_errors = self._UnlockedVerifyConfig()
1477 errmsg = ("Configuration data is not consistent: %s" %
1478 (utils.CommaJoin(config_errors)))
1479 logging.critical(errmsg)
1483 if destination is None:
1484 destination = self._cfg_file
1485 self._BumpSerialNo()
1486 txt = serializer.Dump(self._config_data.ToDict())
1488 getents = self._getents()
1490 fd = utils.SafeWriteFile(destination, self._cfg_id, data=txt,
1491 close=False, gid=getents.confd_gid, mode=0640)
1492 except errors.LockError:
1493 raise errors.ConfigurationError("The configuration file has been"
1494 " modified since the last write, cannot"
1497 self._cfg_id = utils.GetFileID(fd=fd)
1501 self.write_count += 1
1503 # and redistribute the config file to master candidates
1504 self._DistributeConfig(feedback_fn)
1506 # Write ssconf files on all nodes (including locally)
1507 if self._last_cluster_serial < self._config_data.cluster.serial_no:
1508 if not self._offline:
1509 result = rpc.RpcRunner.call_write_ssconf_files(
1510 self._UnlockedGetOnlineNodeList(),
1511 self._UnlockedGetSsconfValues())
1513 for nname, nresu in result.items():
1514 msg = nresu.fail_msg
1516 errmsg = ("Error while uploading ssconf files to"
1517 " node %s: %s" % (nname, msg))
1518 logging.warning(errmsg)
1523 self._last_cluster_serial = self._config_data.cluster.serial_no
1525 def _UnlockedGetSsconfValues(self):
1526 """Return the values needed by ssconf.
1529 @return: a dictionary with keys the ssconf names and values their
1534 instance_names = utils.NiceSort(self._UnlockedGetInstanceList())
1535 node_names = utils.NiceSort(self._UnlockedGetNodeList())
1536 node_info = [self._UnlockedGetNodeInfo(name) for name in node_names]
1537 node_pri_ips = ["%s %s" % (ninfo.name, ninfo.primary_ip)
1538 for ninfo in node_info]
1539 node_snd_ips = ["%s %s" % (ninfo.name, ninfo.secondary_ip)
1540 for ninfo in node_info]
1542 instance_data = fn(instance_names)
1543 off_data = fn(node.name for node in node_info if node.offline)
1544 on_data = fn(node.name for node in node_info if not node.offline)
1545 mc_data = fn(node.name for node in node_info if node.master_candidate)
1546 mc_ips_data = fn(node.primary_ip for node in node_info
1547 if node.master_candidate)
1548 node_data = fn(node_names)
1549 node_pri_ips_data = fn(node_pri_ips)
1550 node_snd_ips_data = fn(node_snd_ips)
1552 cluster = self._config_data.cluster
1553 cluster_tags = fn(cluster.GetTags())
1555 hypervisor_list = fn(cluster.enabled_hypervisors)
1557 uid_pool = uidpool.FormatUidPool(cluster.uid_pool, separator="\n")
1559 nodegroups = ["%s %s" % (nodegroup.uuid, nodegroup.name) for nodegroup in
1560 self._config_data.nodegroups.values()]
1561 nodegroups_data = fn(utils.NiceSort(nodegroups))
1564 constants.SS_CLUSTER_NAME: cluster.cluster_name,
1565 constants.SS_CLUSTER_TAGS: cluster_tags,
1566 constants.SS_FILE_STORAGE_DIR: cluster.file_storage_dir,
1567 constants.SS_MASTER_CANDIDATES: mc_data,
1568 constants.SS_MASTER_CANDIDATES_IPS: mc_ips_data,
1569 constants.SS_MASTER_IP: cluster.master_ip,
1570 constants.SS_MASTER_NETDEV: cluster.master_netdev,
1571 constants.SS_MASTER_NODE: cluster.master_node,
1572 constants.SS_NODE_LIST: node_data,
1573 constants.SS_NODE_PRIMARY_IPS: node_pri_ips_data,
1574 constants.SS_NODE_SECONDARY_IPS: node_snd_ips_data,
1575 constants.SS_OFFLINE_NODES: off_data,
1576 constants.SS_ONLINE_NODES: on_data,
1577 constants.SS_PRIMARY_IP_FAMILY: str(cluster.primary_ip_family),
1578 constants.SS_INSTANCE_LIST: instance_data,
1579 constants.SS_RELEASE_VERSION: constants.RELEASE_VERSION,
1580 constants.SS_HYPERVISOR_LIST: hypervisor_list,
1581 constants.SS_MAINTAIN_NODE_HEALTH: str(cluster.maintain_node_health),
1582 constants.SS_UID_POOL: uid_pool,
1583 constants.SS_NODEGROUPS: nodegroups_data,
1586 @locking.ssynchronized(_config_lock, shared=1)
1587 def GetSsconfValues(self):
1588 """Wrapper using lock around _UnlockedGetSsconf().
1591 return self._UnlockedGetSsconfValues()
1593 @locking.ssynchronized(_config_lock, shared=1)
1594 def GetVGName(self):
1595 """Return the volume group name.
1598 return self._config_data.cluster.volume_group_name
1600 @locking.ssynchronized(_config_lock)
1601 def SetVGName(self, vg_name):
1602 """Set the volume group name.
1605 self._config_data.cluster.volume_group_name = vg_name
1606 self._config_data.cluster.serial_no += 1
1609 @locking.ssynchronized(_config_lock, shared=1)
1610 def GetDRBDHelper(self):
1611 """Return DRBD usermode helper.
1614 return self._config_data.cluster.drbd_usermode_helper
1616 @locking.ssynchronized(_config_lock)
1617 def SetDRBDHelper(self, drbd_helper):
1618 """Set DRBD usermode helper.
1621 self._config_data.cluster.drbd_usermode_helper = drbd_helper
1622 self._config_data.cluster.serial_no += 1
1625 @locking.ssynchronized(_config_lock, shared=1)
1626 def GetMACPrefix(self):
1627 """Return the mac prefix.
1630 return self._config_data.cluster.mac_prefix
1632 @locking.ssynchronized(_config_lock, shared=1)
1633 def GetClusterInfo(self):
1634 """Returns information about the cluster
1636 @rtype: L{objects.Cluster}
1637 @return: the cluster object
1640 return self._config_data.cluster
1642 @locking.ssynchronized(_config_lock, shared=1)
1643 def HasAnyDiskOfType(self, dev_type):
1644 """Check if in there is at disk of the given type in the configuration.
1647 return self._config_data.HasAnyDiskOfType(dev_type)
1649 @locking.ssynchronized(_config_lock)
1650 def Update(self, target, feedback_fn):
1651 """Notify function to be called after updates.
1653 This function must be called when an object (as returned by
1654 GetInstanceInfo, GetNodeInfo, GetCluster) has been updated and the
1655 caller wants the modifications saved to the backing store. Note
1656 that all modified objects will be saved, but the target argument
1657 is the one the caller wants to ensure that it's saved.
1659 @param target: an instance of either L{objects.Cluster},
1660 L{objects.Node} or L{objects.Instance} which is existing in
1662 @param feedback_fn: Callable feedback function
1665 if self._config_data is None:
1666 raise errors.ProgrammerError("Configuration file not read,"
1668 update_serial = False
1669 if isinstance(target, objects.Cluster):
1670 test = target == self._config_data.cluster
1671 elif isinstance(target, objects.Node):
1672 test = target in self._config_data.nodes.values()
1673 update_serial = True
1674 elif isinstance(target, objects.Instance):
1675 test = target in self._config_data.instances.values()
1677 raise errors.ProgrammerError("Invalid object type (%s) passed to"
1678 " ConfigWriter.Update" % type(target))
1680 raise errors.ConfigurationError("Configuration updated since object"
1681 " has been read or unknown object")
1682 target.serial_no += 1
1683 target.mtime = now = time.time()
1686 # for node updates, we need to increase the cluster serial too
1687 self._config_data.cluster.serial_no += 1
1688 self._config_data.cluster.mtime = now
1690 if isinstance(target, objects.Instance):
1691 self._UnlockedReleaseDRBDMinors(target.name)
1693 self._WriteConfig(feedback_fn=feedback_fn)
1695 @locking.ssynchronized(_config_lock)
1696 def DropECReservations(self, ec_id):
1697 """Drop per-execution-context reservations
1700 for rm in self._all_rms:
1701 rm.DropECReservations(ec_id)