1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 """Global Configuration data for Ganeti.
23
24 This module provides the interface to a special case of cluster
25 configuration data, which is mostly static and available to all nodes.
26
27 """
28
29 import sys
30 import re
31 import os
32 import errno
33
34 from ganeti import errors
35 from ganeti import constants
36 from ganeti import utils
37 from ganeti import serializer
38 from ganeti import objects
39 from ganeti import netutils
40
41
42 SSCONF_LOCK_TIMEOUT = 10
43
44 RE_VALID_SSCONF_NAME = re.compile(r"^[-_a-z0-9]+$")
45
46
48 """Simple class to read configuration file.
49
50 """
52 """Initializes this class.
53
54 @type file_name: string
55 @param file_name: Configuration file path
56
57 """
58 self._file_name = file_name
59 self._last_inode = None
60 self._last_mtime = None
61 self._last_size = None
62
63 self._config_data = None
64 self._inst_ips_by_link = None
65 self._ip_to_inst_by_link = None
66 self._instances_ips = None
67 self._mc_primary_ips = None
68 self._nodes_primary_ips = None
69
70
71 self._Load(force=True)
72
73 - def _Load(self, force=False):
74 """Loads (or reloads) the config file.
75
76 @type force: boolean
77 @param force: whether to force the reload without checking the mtime
78 @rtype: boolean
79 @return: boolean value that says whether we reloaded the configuration or
80 not (because we decided it was already up-to-date)
81
82 """
83 try:
84 cfg_stat = os.stat(self._file_name)
85 except EnvironmentError, err:
86 raise errors.ConfigurationError("Cannot stat config file %s: %s" %
87 (self._file_name, err))
88 inode = cfg_stat.st_ino
89 mtime = cfg_stat.st_mtime
90 size = cfg_stat.st_size
91
92 if (force or inode != self._last_inode or
93 mtime > self._last_mtime or
94 size != self._last_size):
95 self._last_inode = inode
96 self._last_mtime = mtime
97 self._last_size = size
98 else:
99
100 return False
101
102 try:
103 self._config_data = serializer.Load(utils.ReadFile(self._file_name))
104 except EnvironmentError, err:
105 raise errors.ConfigurationError("Cannot read config file %s: %s" %
106 (self._file_name, err))
107 except ValueError, err:
108 raise errors.ConfigurationError("Cannot load config file %s: %s" %
109 (self._file_name, err))
110
111 self._ip_to_inst_by_link = {}
112 self._instances_ips = []
113 self._inst_ips_by_link = {}
114 c_nparams = self._config_data["cluster"]["nicparams"][constants.PP_DEFAULT]
115 for iname in self._config_data["instances"]:
116 instance = self._config_data["instances"][iname]
117 for nic in instance["nics"]:
118 if "ip" in nic and nic["ip"]:
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._ip_to_inst_by_link[params["link"]] = {}
123 self._ip_to_inst_by_link[params["link"]][nic["ip"]] = iname
124 self._inst_ips_by_link[params["link"]].append(nic["ip"])
125
126 self._nodes_primary_ips = []
127 self._mc_primary_ips = []
128 for node_name in self._config_data["nodes"]:
129 node = self._config_data["nodes"][node_name]
130 self._nodes_primary_ips.append(node["primary_ip"])
131 if node["master_candidate"]:
132 self._mc_primary_ips.append(node["primary_ip"])
133
134 return True
135
136
137
138 Reload = _Load
139
141 return self._config_data["cluster"]["cluster_name"]
142
144 return self._config_data["cluster"]["rsahostkeypub"]
145
147 return self._config_data["cluster"]["master_node"]
148
150 return self._config_data["cluster"]["master_ip"]
151
153 return self._config_data["cluster"]["master_netdev"]
154
156 return self._config_data["cluster"]["file_storage_dir"]
157
159 return self._config_data["cluster"]["shared_file_storage_dir"]
160
162 return self._config_data["nodes"].keys()
163
165 return self._config_data["serial_no"]
166
168 return self._config_data["cluster"]["serial_no"]
169
172
175
177 """Get a node's status flags
178
179 @type node: string
180 @param node: node name
181 @rtype: (bool, bool, bool)
182 @return: (master_candidate, drained, offline) (or None if no such node)
183
184 """
185 if node not in self._config_data["nodes"]:
186 return None
187
188 master_candidate = self._config_data["nodes"][node]["master_candidate"]
189 drained = self._config_data["nodes"][node]["drained"]
190 offline = self._config_data["nodes"][node]["offline"]
191 return master_candidate, drained, offline
192
194 """Get instance name from its link and ip address.
195
196 @type ip: string
197 @param ip: ip address
198 @type link: string
199 @param link: nic link
200 @rtype: string
201 @return: instance name
202
203 """
204 if not link:
205 link = self.GetDefaultNicLink()
206 if not link in self._ip_to_inst_by_link:
207 return None
208 if not ip in self._ip_to_inst_by_link[link]:
209 return None
210 return self._ip_to_inst_by_link[link][ip]
211
213 """Get a node's primary ip
214
215 @type node: string
216 @param node: node name
217 @rtype: string, or None
218 @return: node's primary ip, or None if no such node
219
220 """
221 if node not in self._config_data["nodes"]:
222 return None
223 return self._config_data["nodes"][node]["primary_ip"]
224
226 """Get an instance's primary node
227
228 @type instance: string
229 @param instance: instance name
230 @rtype: string, or None
231 @return: primary node, or None if no such instance
232
233 """
234 if instance not in self._config_data["instances"]:
235 return None
236 return self._config_data["instances"][instance]["primary_node"]
237
239 return self._nodes_primary_ips
240
242 return self._mc_primary_ips
243
245 """Get list of nic ips connected to a certain link.
246
247 @type link: string
248 @param link: nic link
249 @rtype: list
250 @return: list of ips connected to that link
251
252 """
253 if not link:
254 link = self.GetDefaultNicLink()
255
256 if link in self._inst_ips_by_link:
257 return self._inst_ips_by_link[link]
258 else:
259 return []
260
261
263 """Interface to static cluster data.
264
265 This is different that the config.ConfigWriter and
266 SimpleConfigReader classes in that it holds data that will always be
267 present, even on nodes which don't have all the cluster data.
268
269 Other particularities of the datastore:
270 - keys are restricted to predefined values
271
272 """
273 _SS_FILEPREFIX = "ssconf_"
274 _VALID_KEYS = (
275 constants.SS_CLUSTER_NAME,
276 constants.SS_CLUSTER_TAGS,
277 constants.SS_FILE_STORAGE_DIR,
278 constants.SS_SHARED_FILE_STORAGE_DIR,
279 constants.SS_MASTER_CANDIDATES,
280 constants.SS_MASTER_CANDIDATES_IPS,
281 constants.SS_MASTER_IP,
282 constants.SS_MASTER_NETDEV,
283 constants.SS_MASTER_NODE,
284 constants.SS_NODE_LIST,
285 constants.SS_NODE_PRIMARY_IPS,
286 constants.SS_NODE_SECONDARY_IPS,
287 constants.SS_OFFLINE_NODES,
288 constants.SS_ONLINE_NODES,
289 constants.SS_PRIMARY_IP_FAMILY,
290 constants.SS_INSTANCE_LIST,
291 constants.SS_RELEASE_VERSION,
292 constants.SS_HYPERVISOR_LIST,
293 constants.SS_MAINTAIN_NODE_HEALTH,
294 constants.SS_UID_POOL,
295 constants.SS_NODEGROUPS,
296 )
297 _MAX_SIZE = 131072
298
300 if cfg_location is None:
301 self._cfg_dir = constants.DATA_DIR
302 else:
303 self._cfg_dir = cfg_location
304
306 """Convert a given key into filename.
307
308 """
309 if key not in self._VALID_KEYS:
310 raise errors.ProgrammerError("Invalid key requested from SSConf: '%s'"
311 % str(key))
312
313 filename = self._cfg_dir + "/" + self._SS_FILEPREFIX + key
314 return filename
315
317 """Generic routine to read keys.
318
319 This will read the file which holds the value requested. Errors
320 will be changed into ConfigurationErrors.
321
322 """
323 filename = self.KeyToFilename(key)
324 try:
325 data = utils.ReadFile(filename, size=self._MAX_SIZE)
326 except EnvironmentError, err:
327 if err.errno == errno.ENOENT and default is not None:
328 return default
329 raise errors.ConfigurationError("Can't read from the ssconf file:"
330 " '%s'" % str(err))
331 data = data.rstrip("\n")
332 return data
333
356
358 """Return the list of all config files.
359
360 This is used for computing node replication data.
361
362 """
363 return [self.KeyToFilename(key) for key in self._VALID_KEYS]
364
370
376
382
390
398
404
410
416
424
432
440
448
456
464
466 """Return the value of the maintain_node_health option.
467
468 """
469 data = self._ReadFile(constants.SS_MAINTAIN_NODE_HEALTH)
470
471 return data == "True"
472
474 """Return the user-id pool definition string.
475
476 The separator character is a newline.
477
478 The return value can be parsed using uidpool.ParseUidPool()::
479
480 ss = ssconf.SimpleStore()
481 uid_pool = uidpool.ParseUidPool(ss.GetUidPool(), separator="\\n")
482
483 """
484 data = self._ReadFile(constants.SS_UID_POOL)
485 return data
486
497
498
500 """Get the master node and my own hostname.
501
502 This can be either used for a 'soft' check (compared to CheckMaster,
503 which exits) or just for computing both at the same time.
504
505 The function does not handle any errors, these should be handled in
506 the caller (errors.ConfigurationError, errors.ResolverError).
507
508 @param ss: either a sstore.SimpleConfigReader or a
509 sstore.SimpleStore instance
510 @rtype: tuple
511 @return: a tuple (master node name, my own name)
512
513 """
514 if ss is None:
515 ss = SimpleStore()
516 return ss.GetMasterNode(), netutils.Hostname.GetSysName()
517
518
539