4 # Copyright (C) 2006, 2007, 2008 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 """Global Configuration data for Ganeti.
24 This module provides the interface to a special case of cluster
25 configuration data, which is mostly static and available to all nodes.
33 from ganeti import errors
34 from ganeti import constants
35 from ganeti import utils
36 from ganeti import serializer
37 from ganeti import objects
40 SSCONF_LOCK_TIMEOUT = 10
42 RE_VALID_SSCONF_NAME = re.compile(r'^[-_a-z0-9]+$')
45 class SimpleConfigReader(object):
46 """Simple class to read configuration file.
49 def __init__(self, file_name=constants.CLUSTER_CONF_FILE):
50 """Initializes this class.
52 @type file_name: string
53 @param file_name: Configuration file path
56 self._file_name = file_name
57 self._last_inode = None
58 self._last_mtime = None
59 self._last_size = None
61 self._config_data = None
62 self._instances_ips = None
63 self._inst_ips_by_link = None
64 self._ip_to_instance = None
65 self._mc_primary_ips = None
66 self._nodes_primary_ips = None
68 # we need a forced reload at class init time, to initialize _last_*
69 self._Load(force=True)
71 def _Load(self, force=False):
72 """Loads (or reloads) the config file.
75 @param force: whether to force the reload without checking the mtime
77 @return: boolean value that says whether we reloaded the configuration or
78 not (because we decided it was already up-to-date)
82 cfg_stat = os.stat(self._file_name)
83 except EnvironmentError, err:
84 raise errors.ConfigurationError("Cannot stat config file %s: %s" %
85 (self._file_name, err))
86 inode = cfg_stat.st_ino
87 mtime = cfg_stat.st_mtime
88 size = cfg_stat.st_size
90 if (force or inode != self._last_inode or
91 mtime > self._last_mtime or
92 size != self._last_size):
93 self._last_inode = inode
94 self._last_mtime = mtime
95 self._last_size = size
101 self._config_data = serializer.Load(utils.ReadFile(self._file_name))
102 except EnvironmentError, err:
103 raise errors.ConfigurationError("Cannot read config file %s: %s" %
104 (self._file_name, err))
105 except ValueError, err:
106 raise errors.ConfigurationError("Cannot load config file %s: %s" %
107 (self._file_name, err))
109 self._ip_to_instance = {}
110 self._instances_ips = []
111 self._inst_ips_by_link = {}
112 c_nparams = self._config_data['cluster']['nicparams'][constants.PP_DEFAULT]
113 for iname in self._config_data['instances']:
114 instance = self._config_data['instances'][iname]
115 for nic in instance['nics']:
116 if 'ip' in nic and nic['ip']:
117 self._instances_ips.append(nic['ip'])
118 self._ip_to_instance[nic['ip']] = iname
119 params = objects.FillDict(c_nparams, nic['nicparams'])
120 if not params['link'] in self._inst_ips_by_link:
121 self._inst_ips_by_link[params['link']] = []
122 self._inst_ips_by_link[params['link']].append(nic['ip'])
124 self._nodes_primary_ips = []
125 self._mc_primary_ips = []
126 for node_name in self._config_data["nodes"]:
127 node = self._config_data["nodes"][node_name]
128 self._nodes_primary_ips.append(node["primary_ip"])
129 if node["master_candidate"]:
130 self._mc_primary_ips.append(node["primary_ip"])
134 # Clients can request a reload of the config file, so we export our internal
135 # _Load function as Reload.
138 def GetClusterName(self):
139 return self._config_data["cluster"]["cluster_name"]
141 def GetHostKey(self):
142 return self._config_data["cluster"]["rsahostkeypub"]
144 def GetMasterNode(self):
145 return self._config_data["cluster"]["master_node"]
147 def GetMasterIP(self):
148 return self._config_data["cluster"]["master_ip"]
150 def GetMasterNetdev(self):
151 return self._config_data["cluster"]["master_netdev"]
153 def GetFileStorageDir(self):
154 return self._config_data["cluster"]["file_storage_dir"]
156 def GetNodeList(self):
157 return self._config_data["nodes"].keys()
159 def GetConfigSerialNo(self):
160 return self._config_data["serial_no"]
162 def GetClusterSerialNo(self):
163 return self._config_data["cluster"]["serial_no"]
165 def GetNodeStatusFlags(self, node):
166 """Get a node's status flags
169 @param node: node name
170 @rtype: (bool, bool, bool)
171 @return: (master_candidate, drained, offline) (or None if no such node)
174 if node not in self._config_data["nodes"]:
177 master_candidate = self._config_data["nodes"][node]["master_candidate"]
178 drained = self._config_data["nodes"][node]["drained"]
179 offline = self._config_data["nodes"][node]["offline"]
180 return master_candidate, drained, offline
182 def GetInstanceByIp(self, ip):
183 if ip not in self._ip_to_instance:
185 return self._ip_to_instance[ip]
187 def GetNodePrimaryIp(self, node):
188 """Get a node's primary ip
191 @param node: node name
192 @rtype: string, or None
193 @return: node's primary ip, or None if no such node
196 if node not in self._config_data["nodes"]:
198 return self._config_data["nodes"][node]["primary_ip"]
200 def GetInstancePrimaryNode(self, instance):
201 """Get an instance's primary node
203 @type instance: string
204 @param instance: instance name
205 @rtype: string, or None
206 @return: primary node, or None if no such instance
209 if instance not in self._config_data["instances"]:
211 return self._config_data["instances"][instance]["primary_node"]
213 def GetNodesPrimaryIps(self):
214 return self._nodes_primary_ips
216 def GetMasterCandidatesPrimaryIps(self):
217 return self._mc_primary_ips
219 def GetInstancesIps(self, link):
221 return self._instances_ips
222 if link in self._inst_ips_by_link:
223 return self._inst_ips_by_link[link]
228 class SimpleStore(object):
229 """Interface to static cluster data.
231 This is different that the config.ConfigWriter and
232 SimpleConfigReader classes in that it holds data that will always be
233 present, even on nodes which don't have all the cluster data.
235 Other particularities of the datastore:
236 - keys are restricted to predefined values
239 _SS_FILEPREFIX = "ssconf_"
241 constants.SS_CLUSTER_NAME,
242 constants.SS_CLUSTER_TAGS,
243 constants.SS_FILE_STORAGE_DIR,
244 constants.SS_MASTER_CANDIDATES,
245 constants.SS_MASTER_CANDIDATES_IPS,
246 constants.SS_MASTER_IP,
247 constants.SS_MASTER_NETDEV,
248 constants.SS_MASTER_NODE,
249 constants.SS_NODE_LIST,
250 constants.SS_NODE_PRIMARY_IPS,
251 constants.SS_NODE_SECONDARY_IPS,
252 constants.SS_OFFLINE_NODES,
253 constants.SS_ONLINE_NODES,
254 constants.SS_INSTANCE_LIST,
255 constants.SS_RELEASE_VERSION,
259 def __init__(self, cfg_location=None):
260 if cfg_location is None:
261 self._cfg_dir = constants.DATA_DIR
263 self._cfg_dir = cfg_location
265 def KeyToFilename(self, key):
266 """Convert a given key into filename.
269 if key not in self._VALID_KEYS:
270 raise errors.ProgrammerError("Invalid key requested from SSConf: '%s'"
273 filename = self._cfg_dir + '/' + self._SS_FILEPREFIX + key
276 def _ReadFile(self, key):
277 """Generic routine to read keys.
279 This will read the file which holds the value requested. Errors
280 will be changed into ConfigurationErrors.
283 filename = self.KeyToFilename(key)
285 data = utils.ReadFile(filename, size=self._MAX_SIZE)
286 except EnvironmentError, err:
287 raise errors.ConfigurationError("Can't read from the ssconf file:"
289 data = data.rstrip('\n')
292 def WriteFiles(self, values):
293 """Writes ssconf files used by external scripts.
296 @param values: Dictionary of (name, value)
299 ssconf_lock = utils.FileLock(constants.SSCONF_LOCK_FILE)
301 # Get lock while writing files
302 ssconf_lock.Exclusive(blocking=True, timeout=SSCONF_LOCK_TIMEOUT)
304 for name, value in values.iteritems():
305 if value and not value.endswith("\n"):
307 utils.WriteFile(self.KeyToFilename(name), data=value, mode=0444)
311 def GetFileList(self):
312 """Return the list of all config files.
314 This is used for computing node replication data.
317 return [self.KeyToFilename(key) for key in self._VALID_KEYS]
319 def GetClusterName(self):
320 """Get the cluster name.
323 return self._ReadFile(constants.SS_CLUSTER_NAME)
325 def GetFileStorageDir(self):
326 """Get the file storage dir.
329 return self._ReadFile(constants.SS_FILE_STORAGE_DIR)
331 def GetMasterCandidates(self):
332 """Return the list of master candidates.
335 data = self._ReadFile(constants.SS_MASTER_CANDIDATES)
336 nl = data.splitlines(False)
339 def GetMasterCandidatesIPList(self):
340 """Return the list of master candidates' primary IP.
343 data = self._ReadFile(constants.SS_MASTER_CANDIDATES_IPS)
344 nl = data.splitlines(False)
347 def GetMasterIP(self):
348 """Get the IP of the master node for this cluster.
351 return self._ReadFile(constants.SS_MASTER_IP)
353 def GetMasterNetdev(self):
354 """Get the netdev to which we'll add the master ip.
357 return self._ReadFile(constants.SS_MASTER_NETDEV)
359 def GetMasterNode(self):
360 """Get the hostname of the master node for this cluster.
363 return self._ReadFile(constants.SS_MASTER_NODE)
365 def GetNodeList(self):
366 """Return the list of cluster nodes.
369 data = self._ReadFile(constants.SS_NODE_LIST)
370 nl = data.splitlines(False)
373 def GetNodePrimaryIPList(self):
374 """Return the list of cluster nodes' primary IP.
377 data = self._ReadFile(constants.SS_NODE_PRIMARY_IPS)
378 nl = data.splitlines(False)
381 def GetNodeSecondaryIPList(self):
382 """Return the list of cluster nodes' secondary IP.
385 data = self._ReadFile(constants.SS_NODE_SECONDARY_IPS)
386 nl = data.splitlines(False)
389 def GetClusterTags(self):
390 """Return the cluster tags.
393 data = self._ReadFile(constants.SS_CLUSTER_TAGS)
394 nl = data.splitlines(False)
398 def GetMasterAndMyself(ss=None):
399 """Get the master node and my own hostname.
401 This can be either used for a 'soft' check (compared to CheckMaster,
402 which exits) or just for computing both at the same time.
404 The function does not handle any errors, these should be handled in
405 the caller (errors.ConfigurationError, errors.ResolverError).
407 @param ss: either a sstore.SimpleConfigReader or a
408 sstore.SimpleStore instance
410 @return: a tuple (master node name, my own name)
415 return ss.GetMasterNode(), utils.HostInfo().name
418 def CheckMaster(debug, ss=None):
419 """Checks the node setup.
421 If this is the master, the function will return. Otherwise it will
422 exit with an exit code based on the node status.
426 master_name, myself = GetMasterAndMyself(ss)
427 except errors.ConfigurationError, err:
428 print "Cluster configuration incomplete: '%s'" % str(err)
429 sys.exit(constants.EXIT_NODESETUP_ERROR)
430 except errors.ResolverError, err:
431 sys.stderr.write("Cannot resolve my own name (%s)\n" % err.args[0])
432 sys.exit(constants.EXIT_NODESETUP_ERROR)
434 if myself != master_name:
436 sys.stderr.write("Not master, exiting.\n")
437 sys.exit(constants.EXIT_NOTMASTER)
440 def CheckMasterCandidate(debug, ss=None):
441 """Checks the node setup.
443 If this is a master candidate, the function will return. Otherwise it will
444 exit with an exit code based on the node status.
450 myself = utils.HostInfo().name
451 candidates = ss.GetMasterCandidates()
452 except errors.ConfigurationError, err:
453 print "Cluster configuration incomplete: '%s'" % str(err)
454 sys.exit(constants.EXIT_NODESETUP_ERROR)
455 except errors.ResolverError, err:
456 sys.stderr.write("Cannot resolve my own name (%s)\n" % err.args[0])
457 sys.exit(constants.EXIT_NODESETUP_ERROR)
459 if myself not in candidates:
461 sys.stderr.write("Not master candidate, exiting.\n")
462 sys.exit(constants.EXIT_NOTCANDIDATE)