commands/source.py

   1 #!/usr/bin/env python
   2 #-*- coding:utf-8 -*-
   3 #  Copyright (C) 2010-2012  CEA/DEN
   4 #
   5 #  This library is free software; you can redistribute it and/or
   6 #  modify it under the terms of the GNU Lesser General Public
   7 #  License as published by the Free Software Foundation; either
   8 #  version 2.1 of the License.
   9 #
  10 #  This library is distributed in the hope that it will be useful,
  11 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 #  Lesser General Public License for more details.
  14 #
  15 #  You should have received a copy of the GNU Lesser General Public
  16 #  License along with this library; if not, write to the Free Software
  17 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18
  19 import os
  20 import shutil
  21
  22 import src
  23
  24 # Define all possible option for log command :  sat log <options>
  25 parser = src.options.Options()
  26 parser.add_option('m', 'module', 'list2', 'modules',
  27     _('modules to get the sources. This option can be'
  28     ' passed several time to get the sources of several modules.'))
  29 parser.add_option('', 'no_sample', 'boolean', 'no_sample',
  30     _("do not prepare sample modules."))
  31
  32 def prepare_for_dev(config, module_info, source_dir, logger, pad):
  33
  34     retcode = 'N\A'
  35     # if module sources dir does not exists in dev,
  36     # get it in checkout mode
  37     if not os.path.exists(module_info.source_dir):
  38         retcode = get_module_sources(config, module_info, True, source_dir, logger, pad, checkout=True)
  39         logger.write("\n", 3, False)
  40         logger.write(" " * (pad+2), 3, False) # +2 because module name is followed by ': '
  41
  42     logger.write('dev: %s ... ' % src.printcolors.printcInfo(module_info.source_dir), 3, False)
  43     logger.flush()
  44
  45     return retcode
  46
  47 def prepare_from_git(module_info, source_dir, logger, pad, is_dev=False):
  48     '''Prepares a module from git
  49     '''
  50     coflag = 'git'
  51
  52     if is_dev and 'repo_dev' in module_info.git_info:
  53         coflag = src.printcolors.printcHighlight(coflag.upper())
  54         repo_git = module_info.git_info.repo_dev
  55     else:
  56         repo_git = module_info.git_info.repo
  57
  58
  59     logger.write('%s:%s' % (coflag, src.printcolors.printcInfo(repo_git)), 3, False)
  60     logger.write(' ' * (pad + 50 - len(repo_git)), 3, False)
  61     logger.write(' tag:%s' % src.printcolors.printcInfo(module_info.git_info.tag), 3, False)
  62     logger.write(' %s. ' % ('.' * (10 - len(module_info.git_info.tag))), 3, False)
  63     logger.flush()
  64     logger.write('\n', 5, False)
  65     retcode = src.system.git_extract(repo_git,
  66                                  module_info.git_info.tag,
  67                                  source_dir, logger)
  68     return retcode
  69
  70 def prepare_from_archive(module_info, source_dir, logger):
  71     # check archive exists
  72     if not os.path.exists(module_info.archive_info.archive_name):
  73         raise src.SatException(_("Archive not found: '%s'") % module_info.archive_info.archive_name)
  74
  75     logger.write('arc:%s ... ' % src.printcolors.printcInfo(module_info.archive_info.archive_name), 3, False)
  76     logger.flush()
  77     retcode, NameExtractedDirectory = src.system.archive_extract(module_info.archive_info.archive_name,
  78                                      source_dir.dir(), logger)
  79
  80     # Rename the source directory if it does not match with module_info.source_dir
  81     if NameExtractedDirectory.replace('/', '') != os.path.basename(module_info.source_dir):
  82         shutil.move(os.path.join(os.path.dirname(module_info.source_dir), NameExtractedDirectory), module_info.source_dir)
  83
  84     return retcode
  85
  86 def get_module_sources(config, module_info, is_dev, source_dir, logger, pad, checkout=False):
  87     '''Get the module sources.
  88
  89     '''
  90     if not checkout and is_dev:
  91         return prepare_for_dev(config, module_info, source_dir, logger, pad)
  92
  93     if module_info.get_method == "git":
  94         return prepare_from_git(module_info, source_dir, logger, pad, is_dev)
  95
  96     if module_info.get_method == "archive":
  97         return prepare_from_archive(module_info, source_dir, logger)
  98     '''
  99     if module_info.get_method == "cvs":
 100         cvs_user = common.get_cfg_param(module_info.cvs_info, "cvs_user", config.USER.cvs_user)
 101         return prepare_from_cvs(cvs_user, module_info, source_dir, checkout, logger, pad)
 102
 103     if module_info.get_method == "svn":
 104         svn_user = common.get_cfg_param(module_info.svn_info, "svn_user", config.USER.svn_user)
 105         return prepare_from_svn(svn_user, module_info, source_dir, checkout, logger)
 106
 107     if module_info.get_method == "dir":
 108         return prepare_from_dir(module_info, source_dir, logger)
 109     '''
 110
 111     if len(module_info.get_method) == 0:
 112         # skip
 113         logger.write('%s ...' % _("ignored"), 3, False)
 114         return True
 115
 116     #
 117     logger.write(_("Unknown get_mehtod %(get)s for module %(module)s") % \
 118         { 'get': module_info.get_method, 'module': module_info.name }, 3, False)
 119     logger.write(" ... ", 3, False)
 120     logger.flush()
 121     return False
 122
 123 def get_all_module_sources(config, modules, logger):
 124     '''Get all the module sources.
 125
 126     '''
 127
 128     results = dict()
 129     good_result = 0
 130
 131     max_module_name_len = 1
 132     if len(modules) > 0:
 133         max_module_name_len = max(map(lambda l: len(l), modules[0])) + 4
 134     for module in modules:
 135         module_name = module[0]
 136         module_info = module[1]
 137         source_dir = src.Path(module_info.source_dir)
 138
 139         logger.write('%s: ' % src.printcolors.printcLabel(module_name), 3)
 140         logger.write(' ' * (max_module_name_len - len(module_name)), 3, False)
 141         logger.write("\n", 4, False)
 142
 143         is_dev = "dev_modules" in config.APPLICATION and module_name in config.APPLICATION.dev_modules
 144         if source_dir.exists() and not is_dev:
 145             logger.write("  " + _('remove %s') % source_dir, 4)
 146             logger.write("\n  ", 4, False)
 147             source_dir.rm()
 148
 149         retcode = get_module_sources(config, module_info, is_dev, source_dir, logger, max_module_name_len, checkout=False)
 150
 151         '''
 152         if 'no_rpath' in module_info.keys():
 153             if module_info.no_rpath:
 154                 hack_no_rpath(config, module_info, logger)
 155         '''
 156
 157         # show results
 158         results[module_name] = retcode
 159         if retcode == 'N\A':
 160             res =src.printcolors.printc(src.OK_STATUS) + src.printcolors.printcWarning(_(' source directory already exists'))
 161             good_result = good_result + 1
 162         elif retcode:
 163             res = src.OK_STATUS
 164             good_result = good_result + 1
 165         else:
 166             res = src.KO_STATUS
 167
 168         logger.write('%s\n' % src.printcolors.printc(res), 3, False)
 169
 170     return good_result, results
 171
 172 def run(args, runner, logger):
 173     '''method that is called when salomeTools is called with source parameter.
 174     '''
 175     # Parse the options
 176     (options, args) = parser.parse_args(args)
 177
 178     # check that the command has been called with an application
 179     src.check_config_has_application( runner.cfg )
 180
 181     logger.write(_('Preparing sources of product %s\n') %
 182                         src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
 183     src.printcolors.print_value(logger, 'out_dir',
 184                                 runner.cfg.APPLICATION.out_dir, 2)
 185     logger.write("\n", 2, False)
 186
 187     if options.modules is None:
 188         modules = runner.cfg.APPLICATION.modules
 189     else:
 190         modules = options.modules
 191         for m in modules:
 192             if m not in runner.cfg.APPLICATION.modules:
 193                 raise src.SatException(_("Module %(module)s not defined in product %(product)s") %
 194                     { 'module': m, 'product': runner.cfg.VARS.product} )
 195
 196     modules_infos = src.module.get_modules_infos(modules, runner.cfg)
 197
 198
 199     if options.no_sample:
 200         modules_infos = filter(lambda l: not src.module.module_is_sample(l[1]),
 201                          modules_infos)
 202
 203     good_result, results = get_all_module_sources(runner.cfg, modules_infos, logger)
 204
 205     status = src.OK_STATUS
 206     details = []
 207
 208     logger.write("\n", 2, False)
 209     if good_result == len(modules):
 210         res_count = "%d / %d" % (good_result, good_result)
 211     else:
 212         status = src.KO_STATUS
 213         res_count = "%d / %d" % (good_result, len(modules))
 214
 215         for module in results:
 216             if results[module] == 0 or results[module] is None:
 217                 details.append(module)
 218
 219     result = len(modules) - good_result
 220
 221     # write results
 222     logger.write(_("Preparing of product's sources:"), 1)
 223     logger.write(" " + src.printcolors.printc(status), 1, False)
 224     logger.write(" (%s)\n" % res_count, 1, False)
 225
 226     if len(details) > 0:
 227         logger.write(_("Following sources haven't been prepared:\n"), 2)
 228         logger.write(" ".join(details), 2)
 229         logger.write("\n", 2, False)
 230
 231     return result