mic/creator.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, sys, re
  19 from optparse import SUPPRESS_HELP
  20
  21 from mic import msger
  22 from mic.utils import cmdln, errors, rpmmisc
  23 from conf import configmgr
  24 from plugin import pluginmgr
  25
  26 class Creator(cmdln.Cmdln):
  27     """${name}: create an image
  28
  29     Usage:
  30         ${name} SUBCOMMAND <ksfile> [OPTS]
  31
  32     ${command_list}
  33     ${option_list}
  34     """
  35
  36     name = 'mic create(cr)'
  37
  38     def __init__(self, *args, **kwargs):
  39         cmdln.Cmdln.__init__(self, *args, **kwargs)
  40         self._subcmds = []
  41
  42         # get cmds from pluginmgr
  43         # mix-in do_subcmd interface
  44         for subcmd, klass in pluginmgr.get_plugins('imager').iteritems():
  45             if not hasattr(klass, 'do_create'):
  46                 msger.warning("Unsurpport subcmd: %s" % subcmd)
  47                 continue
  48
  49             func = getattr(klass, 'do_create')
  50             setattr(self.__class__, "do_"+subcmd, func)
  51             self._subcmds.append(subcmd)
  52
  53     def get_optparser(self):
  54         optparser = cmdln.CmdlnOptionParser(self)
  55         optparser.add_option('-d', '--debug', action='store_true', dest='debug',
  56                              help=SUPPRESS_HELP)
  57         optparser.add_option('-v', '--verbose', action='store_true',
  58                              dest='verbose',
  59                              help=SUPPRESS_HELP)
  60         optparser.add_option('', '--logfile', type='string', dest='logfile',
  61                              default=None,
  62                              help='Path of logfile')
  63         optparser.add_option('-c', '--config', type='string', dest='config',
  64                              default=None,
  65                              help='Specify config file for mic')
  66         optparser.add_option('-k', '--cachedir', type='string', action='store',
  67                              dest='cachedir', default=None,
  68                              help='Cache directory to store the downloaded')
  69         optparser.add_option('-o', '--outdir', type='string', action='store',
  70                              dest='outdir', default=None,
  71                              help='Output directory')
  72         optparser.add_option('-A', '--arch', type='string', dest='arch',
  73                              default=None,
  74                              help='Specify repo architecture')
  75         optparser.add_option('', '--release', type='string', dest='release',
  76                              default=None, metavar='RID',
  77                              help='Generate a release of RID with all necessary'
  78                                   ' files, when @BUILD_ID@ is contained in '
  79                                   'kickstart file, it will be replaced by RID')
  80         optparser.add_option("", "--record-pkgs", type="string",
  81                              dest="record_pkgs", default=None,
  82                              help='Record the info of installed packages, '
  83                                   'multiple values can be specified which '
  84                                   'joined by ",", valid values: "name", '
  85                                   '"content", "license"')
  86         optparser.add_option('', '--pkgmgr', type='string', dest='pkgmgr',
  87                              default=None,
  88                              help='Specify backend package manager')
  89         optparser.add_option('', '--local-pkgs-path', type='string',
  90                              dest='local_pkgs_path', default=None,
  91                              help='Path for local pkgs(rpms) to be installed')
  92         optparser.add_option('', '--runtime', type='string',
  93                              dest='runtime', default=None,
  94                              help='Specify  runtime mode, avaiable: bootstrap')
  95         # --taring-to is alias to --pack-to
  96         optparser.add_option('', '--taring-to', type='string',
  97                              dest='pack_to', default=None,
  98                              help=SUPPRESS_HELP)
  99         optparser.add_option('', '--pack-to', type='string',
 100                              dest='pack_to', default=None,
 101                              help='Pack the images together into the specified'
 102                                   ' achive, extension supported: .zip, .tar, '
 103                                   '.tar.gz, .tar.bz2, etc. by default, .tar '
 104                                   'will be used')
 105         optparser.add_option('', '--copy-kernel', action='store_true',
 106                              dest='copy_kernel',
 107                              help='Copy kernel files from image /boot directory'
 108                                   ' to the image output directory.')
 109         return optparser
 110
 111     def preoptparse(self, argv):
 112         optparser = self.get_optparser()
 113
 114         largs = []
 115         rargs = []
 116         while argv:
 117             arg = argv.pop(0)
 118
 119             if arg in ('-h', '--help'):
 120                 rargs.append(arg)
 121
 122             elif optparser.has_option(arg):
 123                 largs.append(arg)
 124
 125                 if optparser.get_option(arg).takes_value():
 126                     try:
 127                         largs.append(argv.pop(0))
 128                     except IndexError:
 129                         raise errors.Usage("%s option requires an argument" % arg)
 130
 131             else:
 132                 if arg.startswith("--"):
 133                     if "=" in arg:
 134                         opt = arg.split("=")[0]
 135                     else:
 136                         opt = None
 137                 elif arg.startswith("-") and len(arg) > 2:
 138                     opt = arg[0:2]
 139                 else:
 140                     opt = None
 141
 142                 if opt and optparser.has_option(opt):
 143                     largs.append(arg)
 144                 else:
 145                     rargs.append(arg)
 146
 147         return largs + rargs
 148
 149     def postoptparse(self):
 150         abspath = lambda pth: os.path.abspath(os.path.expanduser(pth))
 151
 152         if self.options.verbose:
 153             msger.set_loglevel('verbose')
 154         if self.options.debug:
 155             msger.set_loglevel('debug')
 156
 157         if self.options.logfile:
 158             msger.set_interactive(False)
 159             msger.set_logfile(self.options.logfile)
 160             configmgr.create['logfile'] = self.options.logfile
 161
 162         if self.options.config:
 163             configmgr.reset()
 164             configmgr._siteconf = self.options.config
 165
 166         if self.options.outdir is not None:
 167             configmgr.create['outdir'] = abspath(self.options.outdir)
 168         if self.options.cachedir is not None:
 169             configmgr.create['cachedir'] = abspath(self.options.cachedir)
 170         os.environ['ZYPP_LOCKFILE_ROOT'] = configmgr.create['cachedir']
 171         if self.options.local_pkgs_path is not None:
 172             if not os.path.exists(self.options.local_pkgs_path):
 173                 msger.error('Local pkgs directory: \'%s\' not exist' \
 174                               % self.options.local_pkgs_path)
 175             configmgr.create['local_pkgs_path'] = self.options.local_pkgs_path
 176
 177         if self.options.release:
 178             configmgr.create['release'] = self.options.release
 179
 180         if self.options.record_pkgs:
 181             configmgr.create['record_pkgs'] = []
 182             for infotype in self.options.record_pkgs.split(','):
 183                 if infotype not in ('name', 'content', 'license'):
 184                     raise errors.Usage('Invalid pkg recording: %s, valid ones:'
 185                                        ' "name", "content", "license"' \
 186                                        % infotype)
 187
 188                 configmgr.create['record_pkgs'].append(infotype)
 189
 190         if self.options.arch is not None:
 191             supported_arch = sorted(rpmmisc.archPolicies.keys(), reverse=True)
 192             if self.options.arch in supported_arch:
 193                 configmgr.create['arch'] = self.options.arch
 194             else:
 195                 raise errors.Usage('Invalid architecture: "%s".\n'
 196                                    '  Supported architectures are: \n'
 197                                    '  %s' % (self.options.arch,
 198                                                ', '.join(supported_arch)))
 199
 200         if self.options.pkgmgr is not None:
 201             configmgr.create['pkgmgr'] = self.options.pkgmgr
 202
 203         if self.options.runtime:
 204             configmgr.create['runtime'] = self.options.runtime
 205
 206         if self.options.pack_to is not None:
 207             configmgr.create['pack_to'] = self.options.pack_to
 208
 209         if self.options.copy_kernel:
 210             configmgr.create['copy_kernel'] = self.options.copy_kernel
 211
 212     def main(self, argv=None):
 213         if argv is None:
 214             argv = sys.argv
 215         else:
 216             argv = argv[:] # don't modify caller's list
 217
 218         self.optparser = self.get_optparser()
 219         if self.optparser:
 220             try:
 221                 argv = self.preoptparse(argv)
 222                 self.options, args = self.optparser.parse_args(argv)
 223
 224             except cmdln.CmdlnUserError, ex:
 225                 msg = "%s: %s\nTry '%s help' for info.\n"\
 226                       % (self.name, ex, self.name)
 227                 msger.error(msg)
 228
 229             except cmdln.StopOptionProcessing, ex:
 230                 return 0
 231         else:
 232             # optparser=None means no process for opts
 233             self.options, args = None, argv[1:]
 234
 235         if not args:
 236             return self.emptyline()
 237
 238         self.postoptparse()
 239
 240         if os.geteuid() != 0 and args[0] != 'help':
 241             msger.error('root permission is required to continue, abort')
 242
 243         return self.cmd(args)
 244
 245     def do_auto(self, subcmd, opts, *args):
 246         """${cmd_name}: auto detect image type from magic header
 247
 248         Usage:
 249             ${name} ${cmd_name} <ksfile>
 250
 251         ${cmd_option_list}
 252         """
 253         def parse_magic_line(re_str, pstr, ptype='mic'):
 254             ptn = re.compile(re_str)
 255             m = ptn.match(pstr)
 256             if not m or not m.groups():
 257                 return None
 258
 259             inline_argv = m.group(1).strip()
 260             if ptype == 'mic':
 261                 m2 = re.search('(?P<format>\w+)', inline_argv)
 262             elif ptype == 'mic2':
 263                 m2 = re.search('(-f|--format(=)?)\s*(?P<format>\w+)',
 264                                inline_argv)
 265             else:
 266                 return None
 267
 268             if m2:
 269                 cmdname = m2.group('format')
 270                 inline_argv = inline_argv.replace(m2.group(0), '')
 271                 return (cmdname, inline_argv)
 272
 273             return None
 274
 275         if not args:
 276             self.do_help(['help', subcmd])
 277             return None
 278
 279         if len(args) != 1:
 280             raise errors.Usage("Extra arguments given")
 281
 282         if not os.path.exists(args[0]):
 283             raise errors.CreatorError("Can't find the file: %s" % args[0])
 284
 285         with open(args[0], 'r') as rf:
 286             first_line = rf.readline()
 287
 288         mic_re = '^#\s*-\*-mic-options-\*-\s+(.*)\s+-\*-mic-options-\*-'
 289         mic2_re = '^#\s*-\*-mic2-options-\*-\s+(.*)\s+-\*-mic2-options-\*-'
 290
 291         result = parse_magic_line(mic_re, first_line, 'mic') \
 292                  or parse_magic_line(mic2_re, first_line, 'mic2')
 293         if not result:
 294             raise errors.KsError("Invalid magic line in file: %s" % args[0])
 295
 296         if result[0] not in self._subcmds:
 297             raise errors.KsError("Unsupport format '%s' in %s"
 298                                  % (result[0], args[0]))
 299
 300         argv = ' '.join(result + args).split()
 301         self.main(argv)
 302