plugins/imager/raw_plugin.py

   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 shutil
  20 import re
  21 import tempfile
  22
  23 from mic import chroot, msger, rt_util
  24 from mic.utils import misc, fs_related, errors, runner, cmdln
  25 from mic.conf import configmgr
  26 from mic.plugin import pluginmgr
  27 from mic.utils.partitionedfs import PartitionedMount
  28
  29 import mic.imager.raw as raw
  30
  31 from mic.pluginbase import ImagerPlugin
  32 class RawPlugin(ImagerPlugin):
  33     name = 'raw'
  34
  35     @classmethod
  36     @cmdln.option("--compress-disk-image", dest="compress_image", type='choice',
  37                   choices=("gz", "bz2"), default=None,
  38                   help="Same with --compress-image")
  39     @cmdln.option("--compress-image", dest="compress_image", type='choice',
  40                   choices=("gz", "bz2"), default = None,
  41                   help="Compress all raw images before package")
  42     def do_create(self, subcmd, opts, *args):
  43         """${cmd_name}: create raw image
  44
  45         Usage:
  46             ${name} ${cmd_name} <ksfile> [OPTS]
  47
  48         ${cmd_option_list}
  49         """
  50
  51         if not args:
  52             raise errors.Usage("need one argument as the path of ks file")
  53
  54         if len(args) != 1:
  55             raise errors.Usage("Extra arguments given")
  56
  57         creatoropts = configmgr.create
  58         ksconf = args[0]
  59
  60         if not os.path.exists(ksconf):
  61             raise errors.CreatorError("Can't find the file: %s" % ksconf)
  62
  63         recording_pkgs = []
  64         if len(creatoropts['record_pkgs']) > 0:
  65             recording_pkgs = creatoropts['record_pkgs']
  66
  67         if creatoropts['release'] is not None:
  68             if 'name' not in recording_pkgs:
  69                 recording_pkgs.append('name')
  70
  71         ksconf = misc.normalize_ksfile(ksconf,
  72                                        creatoropts['release'],
  73                                        creatoropts['arch'])
  74
  75         configmgr._ksconf = ksconf
  76
  77         # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
  78         if creatoropts['release'] is not None:
  79             creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name'])
  80
  81         # try to find the pkgmgr
  82         pkgmgr = None
  83         for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
  84             if key == creatoropts['pkgmgr']:
  85                 pkgmgr = pcls
  86                 break
  87
  88         if not pkgmgr:
  89             pkgmgrs = pluginmgr.get_plugins('backend').keys()
  90             raise errors.CreatorError("Can't find package manager: %s (availables: %s)" % (creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
  91
  92         if creatoropts['runtime']:
  93             rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts, ksconf, None)
  94
  95         creator = raw.RawImageCreator(creatoropts, pkgmgr, opts.compress_image)
  96
  97         if len(recording_pkgs) > 0:
  98             creator._recording_pkgs = recording_pkgs
  99
 100         images = ["%s-%s.raw" % (creator.name, part['name'])
 101                   for part in creator.get_diskinfo()]
 102         self.check_image_exists(creator.destdir,
 103                                 creator.pack_to,
 104                                 images,
 105                                 creatoropts['release'])
 106
 107         try:
 108             creator.check_depend_tools()
 109             creator.mount(None, creatoropts["cachedir"])
 110             creator.install()
 111             creator.configure(creatoropts["repomd"])
 112             creator.copy_kernel()
 113             creator.unmount()
 114             creator.package(creatoropts["outdir"])
 115             if creatoropts['release'] is not None:
 116                 creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release'])
 117             creator.print_outimage_info()
 118
 119         except errors.CreatorError:
 120             raise
 121         finally:
 122             creator.cleanup()
 123
 124         msger.info("Finished.")
 125         return 0
 126
 127     @classmethod
 128     def do_chroot(cls, target):
 129         img = target
 130         imgsize = misc.get_file_size(img) * 1024L * 1024L
 131         partedcmd = fs_related.find_binary_path("parted")
 132         disk = fs_related.SparseLoopbackDisk(img, imgsize)
 133         imgmnt = misc.mkdtemp()
 134         imgloop = PartitionedMount({'/dev/sdb':disk}, imgmnt, skipformat = True)
 135         img_fstype = "ext3"
 136
 137         # Check the partitions from raw disk.
 138         root_mounted = False
 139         partition_mounts = 0
 140         for line in runner.outs([partedcmd,"-s",img,"unit","B","print"]).splitlines():
 141             line = line.strip()
 142
 143             # Lines that start with number are the partitions,
 144             # because parted can be translated we can't refer to any text lines.
 145             if not line or not line[0].isdigit():
 146                 continue
 147
 148             # Some vars have extra , as list seperator.
 149             line = line.replace(",","")
 150
 151             # Example of parted output lines that are handled:
 152             # Number  Start        End          Size         Type     File system     Flags
 153             #  1      512B         3400000511B  3400000000B  primary
 154             #  2      3400531968B  3656384511B  255852544B   primary  linux-swap(v1)
 155             #  3      3656384512B  3720347647B  63963136B    primary  fat16           boot, lba
 156
 157             partition_info = re.split("\s+",line)
 158
 159             size = partition_info[3].split("B")[0]
 160
 161             if len(partition_info) < 6 or partition_info[5] in ["boot"]:
 162                 # No filesystem can be found from partition line. Assuming
 163                 # btrfs, because that is the only MeeGo fs that parted does
 164                 # not recognize properly.
 165                 # TODO: Can we make better assumption?
 166                 fstype = "btrfs"
 167             elif partition_info[5] in ["ext2","ext3","ext4","btrfs"]:
 168                 fstype = partition_info[5]
 169             elif partition_info[5] in ["fat16","fat32"]:
 170                 fstype = "vfat"
 171             elif "swap" in partition_info[5]:
 172                 fstype = "swap"
 173             else:
 174                 raise errors.CreatorError("Could not recognize partition fs type '%s'." % partition_info[5])
 175
 176             if not root_mounted and fstype in ["ext2","ext3","ext4","btrfs"]:
 177                 # TODO: Check that this is actually the valid root partition from /etc/fstab
 178                 mountpoint = "/"
 179                 root_mounted = True
 180             elif fstype == "swap":
 181                 mountpoint = "swap"
 182             else:
 183                 # TODO: Assing better mount points for the rest of the partitions.
 184                 partition_mounts += 1
 185                 mountpoint = "/media/partition_%d" % partition_mounts
 186
 187             if "boot" in partition_info:
 188                 boot = True
 189             else:
 190                 boot = False
 191
 192             msger.verbose("Size: %s Bytes, fstype: %s, mountpoint: %s, boot: %s" % (size, fstype, mountpoint, boot))
 193             # TODO: add_partition should take bytes as size parameter.
 194             imgloop.add_partition((int)(size)/1024/1024, "/dev/sdb", mountpoint, fstype = fstype, boot = boot)
 195
 196         try:
 197             imgloop.mount()
 198
 199         except errors.MountError:
 200             imgloop.cleanup()
 201             raise
 202
 203         try:
 204             chroot.chroot(imgmnt, None,  "/bin/env HOME=/root /bin/bash")
 205         except:
 206             raise errors.CreatorError("Failed to chroot to %s." %img)
 207         finally:
 208             chroot.cleanup_after_chroot("img", imgloop, None, imgmnt)
 209
 210     @classmethod
 211     def do_unpack(cls, srcimg):
 212         srcimgsize = (misc.get_file_size(srcimg)) * 1024L * 1024L
 213         srcmnt = misc.mkdtemp("srcmnt")
 214         disk = fs_related.SparseLoopbackDisk(srcimg, srcimgsize)
 215         srcloop = PartitionedMount({'/dev/sdb':disk}, srcmnt, skipformat = True)
 216
 217         srcloop.add_partition(srcimgsize/1024/1024, "/dev/sdb", "/", "ext3", boot=False)
 218         try:
 219             srcloop.mount()
 220
 221         except errors.MountError:
 222             srcloop.cleanup()
 223             raise
 224
 225         image = os.path.join(tempfile.mkdtemp(dir = "/var/tmp", prefix = "tmp"), "target.img")
 226         args = ['dd', "if=%s" % srcloop.partitions[0]['device'], "of=%s" % image]
 227
 228         msger.info("`dd` image ...")
 229         rc = runner.show(args)
 230         srcloop.cleanup()
 231         shutil.rmtree(os.path.dirname(srcmnt), ignore_errors = True)
 232
 233         if rc != 0:
 234             raise errors.CreatorError("Failed to dd")
 235         else:
 236             return image