1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
|
# Code to vivify a bootconf configuration into a real TFTP/DHCP configuration.
#
# Michael DeHaan <mdehaan@redhat.com>
import api
import config
import os
import sys
import traceback
import re
import shutil
import IPy
from msg import *
class BootSync:
def __init__(self,api):
self.api = api
self.verbose = True
"""
Syncs the current bootconf configuration.
Automatically runs the 'check' function first to eliminate likely failures.
FUTURE: make dryrun work.
"""
def sync(self,dry_run=False,verbose=True):
self.dry_run = dry_run
results = self.api.check()
if results != []:
self.api.last_error = m("run_check")
return False
try:
self.copy_pxelinux()
self.clean_pxelinux_tree()
self.copy_distros()
self.validate_kickstarts()
self.build_pxelinux_tree()
except:
traceback.print_exc()
return False
return True
"""
Copy syslinux to the configured tftpboot directory
"""
def copy_pxelinux(self):
self.copy(self.api.config.pxelinux, os.path.join(self.api.config.tftpboot, "pxelinux.0"))
"""
Delete any previously built pxelinux.cfg tree for individual systems.
This is better than trying to just add additional entries
as both MAC and IP settings could have been added and the MACs will
take precedence. So we can't really trust human edits won't
conflict.
"""
def clean_pxelinux_tree(self):
self.rmtree(os.path.join(self.api.config.tftpboot, "pxelinux.cfg"), True)
"""
A distro is a kernel and an initrd. Copy all of them and error
out if any files are missing. The conf file was correct if built
via the CLI or API, though it's possible files have been moved
since or perhaps they reference NFS directories that are no longer
mounted.
"""
def copy_distros(self):
# copy is a 4-letter word but tftpboot runs chroot, thus it's required.
images = os.path.join(self.api.config.tftpboot, "images")
self.rmtree(os.path.join(self.api.config.tftpboot, "images"), True)
self.mkdir(images)
for d in self.api.get_distros().contents():
distro_dir = os.path.join(images,d.name)
self.mkdir(distro_dir)
kernel = self.api.utils.find_kernel(d.kernel) # full path
initrd = self.api.utils.find_initrd(d.initrd) # full path
if kernel is None or not os.path.isfile(kernel):
self.api.last_error = "Kernel for distro (%s) cannot be found and needs to be fixed: %s" % (d.name, d.kernel)
raise "error"
if initrd is None or not os.path.isfile(initrd):
self.api.last_error = "Initrd for distro (%s) cannot be found and needs to be fixed: %s" % (d.name, d.initrd)
raise "error"
b_kernel = os.path.basename(kernel)
b_initrd = os.path.basename(initrd)
self.copyfile(kernel, os.path.join(distro_dir, b_kernel))
self.copyfile(initrd, os.path.join(distro_dir, b_initrd))
"""
Similar to what we do for distros, ensure all the kickstarts
in conf file are valid. Since kickstarts are referenced by URL
(http or ftp), we do not have to copy them. They are already
expected to be in the right place. We can't check to see that the
URLs are right (or we don't, we could...) but we do check to see
that the files are at least still there.
"""
def validate_kickstarts(self):
# ensure all referenced kickstarts exist
# these are served by either NFS, Apache, or some ftpd, so we don't need to copy them
# it's up to the user to make sure they are nicely served by their URLs
for g in self.api.get_groups().contents():
kickstart_path = self.api.utils.find_kickstart(g.kickstart)
if kickstart_path is None:
self.api.last_error = "Kickstart for group (%s) is not valid and needs to be fixed: %s" % (g.name, g.kickstart)
raise "error"
"""
Now that kernels and initrds are copied and kickstarts are all valid,
build the pxelinux.cfg tree, which contains a directory for each
configured IP or MAC address.
"""
def build_pxelinux_tree(self):
# create pxelinux.cfg under tftpboot
# and file for each MAC or IP (hex encoded 01-XX-XX-XX-XX-XX-XX)
systems = self.api.get_systems()
groups = self.api.get_groups()
distros = self.api.get_distros()
self.mkdir(os.path.join(self.api.config.tftpboot,"pxelinux.cfg"))
for system in self.api.get_systems().contents():
group = groups.find(system.group)
if group is None:
self.api.last_error = "System %s is orphaned (no group), was the configuration edited manually?" % system.name
raise "error"
distro = distros.find(group.distro)
if distro is None:
self.api.last_error = "Group %s is orphaned (no distro), was the configuration edited manually?" % group.name
raise "error"
filename = self.get_pxelinux_filename(system.name)
filename = os.path.join(self.api.config.tftpboot, "pxelinux.cfg", filename)
self.write_pxelinux_file(filename,system,group,distro)
"""
The configuration file for each system pxelinux uses is either
a form of the MAC address of the hex version of the IP. Not sure
about ipv6 (or if that works). The system name in the config file
is either a system name, an IP, or the MAC, so figure it out, resolve
the host if needed, and return the pxelinux directory name.
"""
def get_pxelinux_filename(self,name_input):
name = self.api.utils.find_system_identifier(name_input)
if self.api.utils.is_ip(name):
return IPy.IP(name).strHex()[2:]
elif self.api.utils.is_mac(name):
return "01-" + "-".join(name.split(":")).lower()
else:
self.api.last_error = "system name (%s) couldn't resolve and is not an IP or a MAC address." % name
raise "error"
"""
Write a configuration file for the pxelinux boot loader.
More system-specific configuration may come in later, if so
that would appear inside the system object in api.py
"""
def write_pxelinux_file(self,filename,system,group,distro):
kernel_path = os.path.join("/images",distro.name,os.path.basename(distro.kernel))
initrd_path = os.path.join("/images",distro.name,os.path.basename(distro.initrd))
kickstart_path = group.kickstart
self.sync_log("writing: %s" % filename)
self.sync_log("---------------------------------")
if self.dry_run:
file = None
else:
file = open(filename,"w+")
self.tee(file,"default linux\n")
self.tee(file,"prompt 0\n")
self.tee(file,"timeout 1\n")
self.tee(file,"label linux\n")
self.tee(file," kernel %s\n" % kernel_path)
# FIXME: allow leaving off the kickstart if no kickstart...
# FIXME: if the users kernel_options string has zero chance of
# booting we *could* try to detect it and warn them.
kopts = self.blend_kernel_options((
self.api.config.kernel_options,
group.kernel_options,
distro.kernel_options,
system.kernel_options
))
nextline = " append %s initrd=%s" % (kopts,initrd_path)
if kickstart_path is not None and kickstart_path != "":
nextline = nextline + " ks=%s" % kickstart_path
self.tee(file, nextline)
if not self.dry_run:
file.close()
self.sync_log("--------------------------------")
"""
For dry_run support, and logging...
"""
def tee(self,file,text):
self.sync_log(text)
if not self.dry_run:
file.write(text)
def copyfile(self,src,dst):
self.sync_log("copy %s to %s" % (src,dst))
if self.dry_run:
return True
return shutil.copyfile(src,dst)
def copy(self,src,dst):
self.sync_log("copy %s to %s" % (src,dst))
if self.dry_run:
return True
return shutil.copy(src,dst)
def rmtree(self,path,ignore):
self.sync_log("removing dir %s" % (path))
if self.dry_run:
return True
return shutil.rmtree(path,ignore)
def mkdir(self,path,mode=0777):
self.sync_log("creating dir %s" % (path))
if self.dry_run:
return True
return os.mkdir(path,mode)
"""
Used to differentiate dry_run output from the real thing
automagically
"""
def sync_log(self,message):
if self.verbose:
if self.dry_run:
print "dry_run | %s" % message
else:
print message
"""
Given a list of kernel options, take the values used by the
first argument in the list unless overridden by those in the
second (or further on), according to --key=value formats.
This is used such that we can have default kernel options
in /etc and then distro, group, and system options with various
levels of configurability.
"""
def blend_kernel_options(self, list_of_opts):
internal = {}
results = []
# for all list of kernel options
for items in list_of_opts:
# get each option
tokens=items.split(" ")
# deal with key/value pairs and single options alike
for token in tokens:
key_value = token.split("=")
if len(key_value) == 1:
internal[key_value[0]] = ""
else:
internal[key_value[0]] = key_value[1]
# now go back through the final list and render the single
# items AND key/value items
for key in internal.keys():
data = internal[key]
if key == "ks" or key == "initrd" or key == "append":
# the user REALLY doesn't want to do this...
continue
if data == "":
results.append(key)
else:
results.append("%s=%s" % (key,internal[key]))
# end result is a new fragment of a kernel options string
return " ".join(results)
|
