dak/generate_filelist.py

   1 #!/usr/bin/python
   2
   3 """
   4 Generate file lists for apt-ftparchive.
   5
   6 @contact: Debian FTP Master <ftpmaster@debian.org>
   7 @copyright: 2009  Torsten Werner <twerner@debian.org>
   8 @copyright: 2011  Ansgar Burchardt <ansgar@debian.org>
   9 @license: GNU General Public License version 2 or later
  10 """
  11
  12 # This program is free software; you can redistribute it and/or modify
  13 # it under the terms of the GNU General Public License as published by
  14 # the Free Software Foundation; either version 2 of the License, or
  15 # (at your option) any later version.
  16
  17 # This program is distributed in the hope that it will be useful,
  18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 # GNU General Public License for more details.
  21
  22 # You should have received a copy of the GNU General Public License
  23 # along with this program; if not, write to the Free Software
  24 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25
  26 ################################################################################
  27
  28 # Ganneff> Please go and try to lock mhy now. After than try to lock NEW.
  29 # twerner> !lock mhy
  30 # dak> twerner: You suck, this is already locked by Ganneff
  31 # Ganneff> now try with NEW
  32 # twerner> !lock NEW
  33 # dak> twerner: also locked NEW
  34 # mhy> Ganneff: oy, stop using me for locks and highlighting me you tall muppet
  35 # Ganneff> hehe :)
  36
  37 ################################################################################
  38
  39 from daklib.dbconn import *
  40 from daklib.config import Config
  41 from daklib import utils, daklog
  42 from daklib.dakmultiprocessing import DakProcessPool, PROC_STATUS_SUCCESS, PROC_STATUS_SIGNALRAISED
  43 import apt_pkg, os, stat, sys
  44
  45 from daklib.lists import getSources, getBinaries, getArchAll
  46
  47 def listPath(suite, component, architecture = None, type = None,
  48         incremental_mode = False):
  49     """returns full path to the list file"""
  50     suffixMap = { 'deb': "binary-",
  51                   'udeb': "debian-installer_binary-" }
  52     if architecture:
  53         suffix = suffixMap[type] + architecture.arch_string
  54     else:
  55         suffix = "source"
  56     filename = "%s_%s_%s.list" % \
  57         (suite.suite_name, component.component_name, suffix)
  58     pathname = os.path.join(Config()["Dir::Lists"], filename)
  59     file = utils.open_file(pathname, "a")
  60     timestamp = None
  61     if incremental_mode:
  62         timestamp = os.fstat(file.fileno())[stat.ST_MTIME]
  63     else:
  64         file.seek(0)
  65         file.truncate()
  66     return (file, timestamp)
  67
  68 def writeSourceList(suite_id, component_id, incremental_mode):
  69     session = DBConn().session()
  70     suite = Suite.get(suite_id, session)
  71     component = Component.get(component_id, session)
  72     (file, timestamp) = listPath(suite, component,
  73             incremental_mode = incremental_mode)
  74
  75     message = "sources list for %s %s" % (suite.suite_name, component.component_name)
  76
  77     for _, filename in getSources(suite, component, session, timestamp):
  78         file.write(filename + '\n')
  79     session.rollback()
  80     file.close()
  81     return (PROC_STATUS_SUCCESS, message)
  82
  83 def writeAllList(suite_id, component_id, architecture_id, type, incremental_mode):
  84     session = DBConn().session()
  85     suite = Suite.get(suite_id, session)
  86     component = Component.get(component_id, session)
  87     architecture = Architecture.get(architecture_id, session)
  88     (file, timestamp) = listPath(suite, component, architecture, type,
  89             incremental_mode)
  90
  91     message = "all list for %s %s (arch=%s, type=%s)" % (suite.suite_name, component.component_name, architecture.arch_string, type)
  92
  93     for _, filename in getArchAll(suite, component, architecture, type,
  94             session, timestamp):
  95         file.write(filename + '\n')
  96     session.rollback()
  97     file.close()
  98     return (PROC_STATUS_SUCCESS, message)
  99
 100 def writeBinaryList(suite_id, component_id, architecture_id, type, incremental_mode):
 101     session = DBConn().session()
 102     suite = Suite.get(suite_id, session)
 103     component = Component.get(component_id, session)
 104     architecture = Architecture.get(architecture_id, session)
 105     (file, timestamp) = listPath(suite, component, architecture, type,
 106             incremental_mode)
 107
 108     message = "binary list for %s %s (arch=%s, type=%s)" % (suite.suite_name, component.component_name, architecture.arch_string, type)
 109
 110     for _, filename in getBinaries(suite, component, architecture, type,
 111             session, timestamp):
 112         file.write(filename + '\n')
 113     session.rollback()
 114     file.close()
 115     return (PROC_STATUS_SUCCESS, message)
 116
 117 def usage():
 118     print """Usage: dak generate_filelist [OPTIONS]
 119 Create filename lists for apt-ftparchive.
 120
 121   -s, --suite=SUITE            act on this suite
 122   -c, --component=COMPONENT    act on this component
 123   -a, --architecture=ARCH      act on this architecture
 124   -h, --help                   show this help and exit
 125   -i, --incremental            activate incremental mode
 126
 127 ARCH, COMPONENT and SUITE can be comma (or space) separated list, e.g.
 128     --suite=testing,unstable
 129
 130 Incremental mode appends only newer files to existing lists."""
 131     sys.exit()
 132
 133 def main():
 134     cnf = Config()
 135     Logger = daklog.Logger('generate-filelist')
 136     Arguments = [('h', "help",         "Filelist::Options::Help"),
 137                  ('s', "suite",        "Filelist::Options::Suite", "HasArg"),
 138                  ('c', "component",    "Filelist::Options::Component", "HasArg"),
 139                  ('a', "architecture", "Filelist::Options::Architecture", "HasArg"),
 140                  ('i', "incremental",  "Filelist::Options::Incremental")]
 141     session = DBConn().session()
 142     query_suites = session.query(Suite)
 143     suites = [suite.suite_name for suite in query_suites]
 144     if not cnf.has_key('Filelist::Options::Suite'):
 145         cnf['Filelist::Options::Suite'] = ','.join(suites).encode()
 146     query_components = session.query(Component)
 147     components = \
 148         [component.component_name for component in query_components]
 149     if not cnf.has_key('Filelist::Options::Component'):
 150         cnf['Filelist::Options::Component'] = ','.join(components).encode()
 151     query_architectures = session.query(Architecture)
 152     architectures = \
 153         [architecture.arch_string for architecture in query_architectures]
 154     if not cnf.has_key('Filelist::Options::Architecture'):
 155         cnf['Filelist::Options::Architecture'] = ','.join(architectures).encode()
 156     cnf['Filelist::Options::Help'] = ''
 157     cnf['Filelist::Options::Incremental'] = ''
 158     apt_pkg.parse_commandline(cnf.Cnf, Arguments, sys.argv)
 159     Options = cnf.subtree("Filelist::Options")
 160     if Options['Help']:
 161         usage()
 162     pool = DakProcessPool()
 163     query_suites = query_suites. \
 164         filter(Suite.suite_name.in_(utils.split_args(Options['Suite'])))
 165     query_components = query_components. \
 166         filter(Component.component_name.in_(utils.split_args(Options['Component'])))
 167     query_architectures = query_architectures. \
 168         filter(Architecture.arch_string.in_(utils.split_args(Options['Architecture'])))
 169
 170     def parse_results(message):
 171         # Split out into (code, msg)
 172         code, msg = message
 173         if code == PROC_STATUS_SUCCESS:
 174             Logger.log([msg])
 175         elif code == PROC_STATUS_SIGNALRAISED:
 176             Logger.log(['E: Subprocess recieved signal ', msg])
 177         else:
 178             Logger.log(['E: ', msg])
 179
 180     for suite in query_suites:
 181         suite_id = suite.suite_id
 182         for component in query_components:
 183             component_id = component.component_id
 184             for architecture in query_architectures:
 185                 architecture_id = architecture.arch_id
 186                 if architecture not in suite.architectures:
 187                     pass
 188                 elif architecture.arch_string == 'source':
 189                     pool.apply_async(writeSourceList,
 190                         (suite_id, component_id, Options['Incremental']), callback=parse_results)
 191                 elif architecture.arch_string == 'all':
 192                     pool.apply_async(writeAllList,
 193                         (suite_id, component_id, architecture_id, 'deb',
 194                             Options['Incremental']), callback=parse_results)
 195                     pool.apply_async(writeAllList,
 196                         (suite_id, component_id, architecture_id, 'udeb',
 197                             Options['Incremental']), callback=parse_results)
 198                 else: # arch any
 199                     pool.apply_async(writeBinaryList,
 200                         (suite_id, component_id, architecture_id, 'deb',
 201                             Options['Incremental']), callback=parse_results)
 202                     pool.apply_async(writeBinaryList,
 203                         (suite_id, component_id, architecture_id, 'udeb',
 204                             Options['Incremental']), callback=parse_results)
 205     pool.close()
 206     pool.join()
 207
 208     # this script doesn't change the database
 209     session.close()
 210
 211     Logger.close()
 212
 213     sys.exit(pool.overall_status())
 214
 215 if __name__ == '__main__':
 216     main()
 217