diff options
Diffstat (limited to 'scripts/lib/mic/imager/loop.py')
-rw-r--r-- | scripts/lib/mic/imager/loop.py | 418 |
1 files changed, 418 insertions, 0 deletions
diff --git a/scripts/lib/mic/imager/loop.py b/scripts/lib/mic/imager/loop.py new file mode 100644 index 0000000000..4d05ef271d --- /dev/null +++ b/scripts/lib/mic/imager/loop.py | |||
@@ -0,0 +1,418 @@ | |||
1 | #!/usr/bin/python -tt | ||
2 | # | ||
3 | # Copyright (c) 2011 Intel, Inc. | ||
4 | # | ||
5 | # This program is free software; you can redistribute it and/or modify it | ||
6 | # under the terms of the GNU General Public License as published by the Free | ||
7 | # Software Foundation; version 2 of the License | ||
8 | # | ||
9 | # This program is distributed in the hope that it will be useful, but | ||
10 | # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | ||
11 | # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
12 | # for more details. | ||
13 | # | ||
14 | # You should have received a copy of the GNU General Public License along | ||
15 | # with this program; if not, write to the Free Software Foundation, Inc., 59 | ||
16 | # Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
17 | |||
18 | import os | ||
19 | import glob | ||
20 | import shutil | ||
21 | |||
22 | from mic import kickstart, msger | ||
23 | from mic.utils.errors import CreatorError, MountError | ||
24 | from mic.utils import misc, runner, fs_related as fs | ||
25 | from mic.imager.baseimager import BaseImageCreator | ||
26 | |||
27 | |||
28 | # The maximum string length supported for LoopImageCreator.fslabel | ||
29 | FSLABEL_MAXLEN = 32 | ||
30 | |||
31 | |||
32 | def save_mountpoints(fpath, loops, arch = None): | ||
33 | """Save mount points mapping to file | ||
34 | |||
35 | :fpath, the xml file to store partition info | ||
36 | :loops, dict of partition info | ||
37 | :arch, image arch | ||
38 | """ | ||
39 | |||
40 | if not fpath or not loops: | ||
41 | return | ||
42 | |||
43 | from xml.dom import minidom | ||
44 | doc = minidom.Document() | ||
45 | imgroot = doc.createElement("image") | ||
46 | doc.appendChild(imgroot) | ||
47 | if arch: | ||
48 | imgroot.setAttribute('arch', arch) | ||
49 | for loop in loops: | ||
50 | part = doc.createElement("partition") | ||
51 | imgroot.appendChild(part) | ||
52 | for (key, val) in loop.items(): | ||
53 | if isinstance(val, fs.Mount): | ||
54 | continue | ||
55 | part.setAttribute(key, str(val)) | ||
56 | |||
57 | with open(fpath, 'w') as wf: | ||
58 | wf.write(doc.toprettyxml(indent=' ')) | ||
59 | |||
60 | return | ||
61 | |||
62 | def load_mountpoints(fpath): | ||
63 | """Load mount points mapping from file | ||
64 | |||
65 | :fpath, file path to load | ||
66 | """ | ||
67 | |||
68 | if not fpath: | ||
69 | return | ||
70 | |||
71 | from xml.dom import minidom | ||
72 | mount_maps = [] | ||
73 | with open(fpath, 'r') as rf: | ||
74 | dom = minidom.parse(rf) | ||
75 | imgroot = dom.documentElement | ||
76 | for part in imgroot.getElementsByTagName("partition"): | ||
77 | p = dict(part.attributes.items()) | ||
78 | |||
79 | try: | ||
80 | mp = (p['mountpoint'], p['label'], p['name'], | ||
81 | int(p['size']), p['fstype']) | ||
82 | except KeyError: | ||
83 | msger.warning("Wrong format line in file: %s" % fpath) | ||
84 | except ValueError: | ||
85 | msger.warning("Invalid size '%s' in file: %s" % (p['size'], fpath)) | ||
86 | else: | ||
87 | mount_maps.append(mp) | ||
88 | |||
89 | return mount_maps | ||
90 | |||
91 | class LoopImageCreator(BaseImageCreator): | ||
92 | """Installs a system into a loopback-mountable filesystem image. | ||
93 | |||
94 | LoopImageCreator is a straightforward ImageCreator subclass; the system | ||
95 | is installed into an ext3 filesystem on a sparse file which can be | ||
96 | subsequently loopback-mounted. | ||
97 | |||
98 | When specifying multiple partitions in kickstart file, each partition | ||
99 | will be created as a separated loop image. | ||
100 | """ | ||
101 | |||
102 | def __init__(self, creatoropts=None, pkgmgr=None, | ||
103 | compress_image=None, | ||
104 | shrink_image=False): | ||
105 | """Initialize a LoopImageCreator instance. | ||
106 | |||
107 | This method takes the same arguments as ImageCreator.__init__() | ||
108 | with the addition of: | ||
109 | |||
110 | fslabel -- A string used as a label for any filesystems created. | ||
111 | """ | ||
112 | |||
113 | BaseImageCreator.__init__(self, creatoropts, pkgmgr) | ||
114 | |||
115 | self.compress_image = compress_image | ||
116 | self.shrink_image = shrink_image | ||
117 | |||
118 | self.__fslabel = None | ||
119 | self.fslabel = self.name | ||
120 | |||
121 | self.__blocksize = 4096 | ||
122 | if self.ks: | ||
123 | self.__fstype = kickstart.get_image_fstype(self.ks, | ||
124 | "ext3") | ||
125 | self.__fsopts = kickstart.get_image_fsopts(self.ks, | ||
126 | "defaults,noatime") | ||
127 | |||
128 | allloops = [] | ||
129 | for part in sorted(kickstart.get_partitions(self.ks), | ||
130 | key=lambda p: p.mountpoint): | ||
131 | if part.fstype == "swap": | ||
132 | continue | ||
133 | |||
134 | label = part.label | ||
135 | mp = part.mountpoint | ||
136 | if mp == '/': | ||
137 | # the base image | ||
138 | if not label: | ||
139 | label = self.name | ||
140 | else: | ||
141 | mp = mp.rstrip('/') | ||
142 | if not label: | ||
143 | msger.warning('no "label" specified for loop img at %s' | ||
144 | ', use the mountpoint as the name' % mp) | ||
145 | label = mp.split('/')[-1] | ||
146 | |||
147 | imgname = misc.strip_end(label, '.img') + '.img' | ||
148 | allloops.append({ | ||
149 | 'mountpoint': mp, | ||
150 | 'label': label, | ||
151 | 'name': imgname, | ||
152 | 'size': part.size or 4096L * 1024 * 1024, | ||
153 | 'fstype': part.fstype or 'ext3', | ||
154 | 'extopts': part.extopts or None, | ||
155 | 'loop': None, # to be created in _mount_instroot | ||
156 | }) | ||
157 | self._instloops = allloops | ||
158 | |||
159 | else: | ||
160 | self.__fstype = None | ||
161 | self.__fsopts = None | ||
162 | self._instloops = [] | ||
163 | |||
164 | self.__imgdir = None | ||
165 | |||
166 | if self.ks: | ||
167 | self.__image_size = kickstart.get_image_size(self.ks, | ||
168 | 4096L * 1024 * 1024) | ||
169 | else: | ||
170 | self.__image_size = 0 | ||
171 | |||
172 | self._img_name = self.name + ".img" | ||
173 | |||
174 | def get_image_names(self): | ||
175 | if not self._instloops: | ||
176 | return None | ||
177 | |||
178 | return [lo['name'] for lo in self._instloops] | ||
179 | |||
180 | def _set_fstype(self, fstype): | ||
181 | self.__fstype = fstype | ||
182 | |||
183 | def _set_image_size(self, imgsize): | ||
184 | self.__image_size = imgsize | ||
185 | |||
186 | |||
187 | # | ||
188 | # Properties | ||
189 | # | ||
190 | def __get_fslabel(self): | ||
191 | if self.__fslabel is None: | ||
192 | return self.name | ||
193 | else: | ||
194 | return self.__fslabel | ||
195 | def __set_fslabel(self, val): | ||
196 | if val is None: | ||
197 | self.__fslabel = None | ||
198 | else: | ||
199 | self.__fslabel = val[:FSLABEL_MAXLEN] | ||
200 | #A string used to label any filesystems created. | ||
201 | # | ||
202 | #Some filesystems impose a constraint on the maximum allowed size of the | ||
203 | #filesystem label. In the case of ext3 it's 16 characters, but in the case | ||
204 | #of ISO9660 it's 32 characters. | ||
205 | # | ||
206 | #mke2fs silently truncates the label, but mkisofs aborts if the label is | ||
207 | #too long. So, for convenience sake, any string assigned to this attribute | ||
208 | #is silently truncated to FSLABEL_MAXLEN (32) characters. | ||
209 | fslabel = property(__get_fslabel, __set_fslabel) | ||
210 | |||
211 | def __get_image(self): | ||
212 | if self.__imgdir is None: | ||
213 | raise CreatorError("_image is not valid before calling mount()") | ||
214 | return os.path.join(self.__imgdir, self._img_name) | ||
215 | #The location of the image file. | ||
216 | # | ||
217 | #This is the path to the filesystem image. Subclasses may use this path | ||
218 | #in order to package the image in _stage_final_image(). | ||
219 | # | ||
220 | #Note, this directory does not exist before ImageCreator.mount() is called. | ||
221 | # | ||
222 | #Note also, this is a read-only attribute. | ||
223 | _image = property(__get_image) | ||
224 | |||
225 | def __get_blocksize(self): | ||
226 | return self.__blocksize | ||
227 | def __set_blocksize(self, val): | ||
228 | if self._instloops: | ||
229 | raise CreatorError("_blocksize must be set before calling mount()") | ||
230 | try: | ||
231 | self.__blocksize = int(val) | ||
232 | except ValueError: | ||
233 | raise CreatorError("'%s' is not a valid integer value " | ||
234 | "for _blocksize" % val) | ||
235 | #The block size used by the image's filesystem. | ||
236 | # | ||
237 | #This is the block size used when creating the filesystem image. Subclasses | ||
238 | #may change this if they wish to use something other than a 4k block size. | ||
239 | # | ||
240 | #Note, this attribute may only be set before calling mount(). | ||
241 | _blocksize = property(__get_blocksize, __set_blocksize) | ||
242 | |||
243 | def __get_fstype(self): | ||
244 | return self.__fstype | ||
245 | def __set_fstype(self, val): | ||
246 | if val != "ext2" and val != "ext3": | ||
247 | raise CreatorError("Unknown _fstype '%s' supplied" % val) | ||
248 | self.__fstype = val | ||
249 | #The type of filesystem used for the image. | ||
250 | # | ||
251 | #This is the filesystem type used when creating the filesystem image. | ||
252 | #Subclasses may change this if they wish to use something other ext3. | ||
253 | # | ||
254 | #Note, only ext2 and ext3 are currently supported. | ||
255 | # | ||
256 | #Note also, this attribute may only be set before calling mount(). | ||
257 | _fstype = property(__get_fstype, __set_fstype) | ||
258 | |||
259 | def __get_fsopts(self): | ||
260 | return self.__fsopts | ||
261 | def __set_fsopts(self, val): | ||
262 | self.__fsopts = val | ||
263 | #Mount options of filesystem used for the image. | ||
264 | # | ||
265 | #This can be specified by --fsoptions="xxx,yyy" in part command in | ||
266 | #kickstart file. | ||
267 | _fsopts = property(__get_fsopts, __set_fsopts) | ||
268 | |||
269 | |||
270 | # | ||
271 | # Helpers for subclasses | ||
272 | # | ||
273 | def _resparse(self, size=None): | ||
274 | """Rebuild the filesystem image to be as sparse as possible. | ||
275 | |||
276 | This method should be used by subclasses when staging the final image | ||
277 | in order to reduce the actual space taken up by the sparse image file | ||
278 | to be as little as possible. | ||
279 | |||
280 | This is done by resizing the filesystem to the minimal size (thereby | ||
281 | eliminating any space taken up by deleted files) and then resizing it | ||
282 | back to the supplied size. | ||
283 | |||
284 | size -- the size in, in bytes, which the filesystem image should be | ||
285 | resized to after it has been minimized; this defaults to None, | ||
286 | causing the original size specified by the kickstart file to | ||
287 | be used (or 4GiB if not specified in the kickstart). | ||
288 | """ | ||
289 | minsize = 0 | ||
290 | for item in self._instloops: | ||
291 | if item['name'] == self._img_name: | ||
292 | minsize = item['loop'].resparse(size) | ||
293 | else: | ||
294 | item['loop'].resparse(size) | ||
295 | |||
296 | return minsize | ||
297 | |||
298 | def _base_on(self, base_on=None): | ||
299 | if base_on and self._image != base_on: | ||
300 | shutil.copyfile(base_on, self._image) | ||
301 | |||
302 | def _check_imgdir(self): | ||
303 | if self.__imgdir is None: | ||
304 | self.__imgdir = self._mkdtemp() | ||
305 | |||
306 | |||
307 | # | ||
308 | # Actual implementation | ||
309 | # | ||
310 | def _mount_instroot(self, base_on=None): | ||
311 | |||
312 | if base_on and os.path.isfile(base_on): | ||
313 | self.__imgdir = os.path.dirname(base_on) | ||
314 | imgname = os.path.basename(base_on) | ||
315 | self._base_on(base_on) | ||
316 | self._set_image_size(misc.get_file_size(self._image)) | ||
317 | |||
318 | # here, self._instloops must be [] | ||
319 | self._instloops.append({ | ||
320 | "mountpoint": "/", | ||
321 | "label": self.name, | ||
322 | "name": imgname, | ||
323 | "size": self.__image_size or 4096L, | ||
324 | "fstype": self.__fstype or "ext3", | ||
325 | "extopts": None, | ||
326 | "loop": None | ||
327 | }) | ||
328 | |||
329 | self._check_imgdir() | ||
330 | |||
331 | for loop in self._instloops: | ||
332 | fstype = loop['fstype'] | ||
333 | mp = os.path.join(self._instroot, loop['mountpoint'].lstrip('/')) | ||
334 | size = loop['size'] * 1024L * 1024L | ||
335 | imgname = loop['name'] | ||
336 | |||
337 | if fstype in ("ext2", "ext3", "ext4"): | ||
338 | MyDiskMount = fs.ExtDiskMount | ||
339 | elif fstype == "btrfs": | ||
340 | MyDiskMount = fs.BtrfsDiskMount | ||
341 | elif fstype in ("vfat", "msdos"): | ||
342 | MyDiskMount = fs.VfatDiskMount | ||
343 | else: | ||
344 | msger.error('Cannot support fstype: %s' % fstype) | ||
345 | |||
346 | loop['loop'] = MyDiskMount(fs.SparseLoopbackDisk( | ||
347 | os.path.join(self.__imgdir, imgname), | ||
348 | size), | ||
349 | mp, | ||
350 | fstype, | ||
351 | self._blocksize, | ||
352 | loop['label']) | ||
353 | |||
354 | if fstype in ("ext2", "ext3", "ext4"): | ||
355 | loop['loop'].extopts = loop['extopts'] | ||
356 | |||
357 | try: | ||
358 | msger.verbose('Mounting image "%s" on "%s"' % (imgname, mp)) | ||
359 | fs.makedirs(mp) | ||
360 | loop['loop'].mount() | ||
361 | except MountError, e: | ||
362 | raise | ||
363 | |||
364 | def _unmount_instroot(self): | ||
365 | for item in reversed(self._instloops): | ||
366 | try: | ||
367 | item['loop'].cleanup() | ||
368 | except: | ||
369 | pass | ||
370 | |||
371 | def _stage_final_image(self): | ||
372 | |||
373 | if self.pack_to or self.shrink_image: | ||
374 | self._resparse(0) | ||
375 | else: | ||
376 | self._resparse() | ||
377 | |||
378 | for item in self._instloops: | ||
379 | imgfile = os.path.join(self.__imgdir, item['name']) | ||
380 | if item['fstype'] == "ext4": | ||
381 | runner.show('/sbin/tune2fs -O ^huge_file,extents,uninit_bg %s ' | ||
382 | % imgfile) | ||
383 | if self.compress_image: | ||
384 | misc.compressing(imgfile, self.compress_image) | ||
385 | |||
386 | if not self.pack_to: | ||
387 | for item in os.listdir(self.__imgdir): | ||
388 | shutil.move(os.path.join(self.__imgdir, item), | ||
389 | os.path.join(self._outdir, item)) | ||
390 | else: | ||
391 | msger.info("Pack all loop images together to %s" % self.pack_to) | ||
392 | dstfile = os.path.join(self._outdir, self.pack_to) | ||
393 | misc.packing(dstfile, self.__imgdir) | ||
394 | |||
395 | if self.pack_to: | ||
396 | mountfp_xml = os.path.splitext(self.pack_to)[0] | ||
397 | mountfp_xml = misc.strip_end(mountfp_xml, '.tar') + ".xml" | ||
398 | else: | ||
399 | mountfp_xml = self.name + ".xml" | ||
400 | # save mount points mapping file to xml | ||
401 | save_mountpoints(os.path.join(self._outdir, mountfp_xml), | ||
402 | self._instloops, | ||
403 | self.target_arch) | ||
404 | |||
405 | def copy_attachment(self): | ||
406 | if not hasattr(self, '_attachment') or not self._attachment: | ||
407 | return | ||
408 | |||
409 | self._check_imgdir() | ||
410 | |||
411 | msger.info("Copying attachment files...") | ||
412 | for item in self._attachment: | ||
413 | if not os.path.exists(item): | ||
414 | continue | ||
415 | dpath = os.path.join(self.__imgdir, os.path.basename(item)) | ||
416 | msger.verbose("Copy attachment %s to %s" % (item, dpath)) | ||
417 | shutil.copy(item, dpath) | ||
418 | |||