daklib/contents.py

   1 #!/usr/bin/env python
   2 """
   3 Helper code for contents generation.
   4
   5 @contact: Debian FTPMaster <ftpmaster@debian.org>
   6 @copyright: 2011 Torsten Werner <twerner@debian.org>
   7 @license: GNU General Public License version 2 or later
   8 """
   9
  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 from daklib.dbconn import *
  29 from daklib.config import Config
  30 from daklib.threadpool import ThreadPool
  31
  32 from sqlalchemy import desc, or_
  33 from subprocess import Popen, PIPE
  34
  35 import os.path
  36
  37 class ContentsWriter(object):
  38     '''
  39     ContentsWriter writes the Contents-$arch.gz files.
  40     '''
  41     def __init__(self, suite, architecture, overridetype, component = None):
  42         '''
  43         The constructor clones its arguments into a new session object to make
  44         sure that the new ContentsWriter object can be executed in a different
  45         thread.
  46         '''
  47         self.suite = suite.clone()
  48         self.session = self.suite.session()
  49         self.architecture = architecture.clone(self.session)
  50         self.overridetype = overridetype.clone(self.session)
  51         if component is not None:
  52             self.component = component.clone(self.session)
  53         else:
  54             self.component = None
  55
  56     def query(self):
  57         '''
  58         Returns a query object that is doing most of the work.
  59         '''
  60         params = {
  61             'suite':    self.suite.suite_id,
  62             'arch_all': get_architecture('all', self.session).arch_id,
  63             'arch':     self.architecture.arch_id,
  64             'type_id':  self.overridetype.overridetype_id,
  65             'type':     self.overridetype.overridetype,
  66         }
  67
  68         if self.component is not None:
  69             params['component'] = component.component_id
  70             sql = '''
  71 create temp table newest_binaries (
  72     id integer primary key,
  73     package text);
  74
  75 create index newest_binaries_by_package on newest_binaries (package);
  76
  77 insert into newest_binaries (id, package)
  78     select distinct on (package) id, package from binaries
  79         where type = :type and
  80             (architecture = :arch_all or architecture = :arch) and
  81             id in (select bin from bin_associations where suite = :suite)
  82         order by package, version desc;
  83
  84 with
  85
  86 unique_override as
  87     (select o.package, s.section
  88         from override o, section s
  89         where o.suite = :suite and o.type = :type_id and o.section = s.id and
  90         o.component = :component)
  91
  92 select bc.file, substring(o.section from position('/' in o.section) + 1) || '/' || b.package as package
  93     from newest_binaries b, bin_contents bc, unique_override o
  94     where b.id = bc.binary_id and o.package = b.package
  95     order by bc.file, b.package'''
  96
  97         else:
  98             sql = '''
  99 create temp table newest_binaries (
 100     id integer primary key,
 101     package text);
 102
 103 create index newest_binaries_by_package on newest_binaries (package);
 104
 105 insert into newest_binaries (id, package)
 106     select distinct on (package) id, package from binaries
 107         where type = :type and
 108             (architecture = :arch_all or architecture = :arch) and
 109             id in (select bin from bin_associations where suite = :suite)
 110         order by package, version desc;
 111
 112 with
 113
 114 unique_override as
 115     (select distinct on (o.package, s.section) o.package, s.section
 116         from override o, section s
 117         where o.suite = :suite and o.type = :type_id and o.section = s.id
 118         order by o.package, s.section, o.modified desc)
 119
 120 select bc.file, substring(o.section from position('/' in o.section) + 1) || '/' || b.package as package
 121     from newest_binaries b, bin_contents bc, unique_override o
 122     where b.id = bc.binary_id and o.package = b.package
 123     order by bc.file, b.package'''
 124
 125         return self.session.query("file", "package").from_statement(sql). \
 126             params(params)
 127
 128     def formatline(self, filename, package_list):
 129         '''
 130         Returns a formatted string for the filename argument.
 131         '''
 132         package_list = ','.join(package_list)
 133         return "%-55s %s\n" % (filename, package_list)
 134
 135     def fetch(self):
 136         '''
 137         Yields a new line of the Contents-$arch.gz file in filename order.
 138         '''
 139         last_filename = None
 140         package_list = []
 141         for filename, package in self.query().yield_per(100):
 142             if filename != last_filename:
 143                 if last_filename is not None:
 144                     yield self.formatline(last_filename, package_list)
 145                 last_filename = filename
 146                 package_list = []
 147             package_list.append(package)
 148         yield self.formatline(last_filename, package_list)
 149         # end transaction to return connection to pool
 150         self.session.rollback()
 151
 152     def get_list(self):
 153         '''
 154         Returns a list of lines for the Contents-$arch.gz file.
 155         '''
 156         return [item for item in self.fetch()]
 157
 158     def output_filename(self):
 159         '''
 160         Returns the name of the output file.
 161         '''
 162         values = {
 163             'root': Config()['Dir::Root'],
 164             'suite': self.suite.suite_name,
 165             'architecture': self.architecture.arch_string
 166         }
 167         if self.component is None:
 168             return "%(root)s%(suite)s/Contents-%(architecture)s.gz" % values
 169         values['component'] = self.component.component_name
 170         return "%(root)s%(suite)s/%(component)s/Contents-%(architecture)s.gz" % values
 171
 172     def get_header(self):
 173         '''
 174         Returns the header for the Contents files as a string.
 175         '''
 176         header_file = None
 177         try:
 178             filename = os.path.join(Config()['Dir::Templates'], 'contents')
 179             header_file = open(filename)
 180             return header_file.read()
 181         finally:
 182             if header_file:
 183                 header_file.close()
 184
 185     def write_file(self, dummy_arg = None):
 186         '''
 187         Write the output file. The argument dummy_arg is ignored but needed by
 188         our threadpool implementation.
 189         '''
 190         command = ['gzip', '--rsyncable']
 191         output_file = open(self.output_filename(), 'w')
 192         pipe = Popen(command, stdin = PIPE, stdout = output_file).stdin
 193         pipe.write(self.get_header())
 194         for item in self.fetch():
 195             pipe.write(item)
 196         pipe.close()
 197         output_file.close()
 198
 199     @classmethod
 200     def write_all(class_, suite_names = [], force = False):
 201         '''
 202         Writes all Contents files for suites in list suite_names which defaults
 203         to all 'touchable' suites if not specified explicitely. Untouchable
 204         suites will be included if the force argument is set to True.
 205         '''
 206         session = DBConn().session()
 207         suite_query = session.query(Suites)
 208         if len(suite_names) > 0:
 209             suite_query = suite_query.filter(Suite.suitename.in_(suite_names))
 210         if not force:
 211             suite_query = suite_query.filter_by(untouchable = False)
 212         main = get_component('main', session)
 213         non_free = get_component('non-free', session)
 214         deb = get_override_type('deb', session)
 215         udeb = get_override_type('udeb', session)
 216         threadpool = ThreadPool()
 217         for suite in suite_query:
 218             for architecture in suite.architectures:
 219                 # handle 'deb' packages
 220                 writer = ContentsWriter(suite, architecture, deb)
 221                 threadpool.queueTask(writer.write_file)
 222                 # handle 'udeb' packages for 'main' and 'non-free'
 223                 writer = ContentsWriter(suite, architecture, udeb, component = main)
 224                 threadpool.queueTask(writer.write_file)
 225                 writer = ContentsWriter(suite, architecture, udeb, component = non_free)
 226                 threadpool.queueTask(writer.write_file)
 227         threadpool.joinAll()
 228         session.close()
 229
 230
 231 class ContentsScanner(object):
 232     '''
 233     ContentsScanner provides a threadsafe method scan() to scan the contents of
 234     a DBBinary object.
 235     '''
 236     def __init__(self, binary):
 237         '''
 238         The argument binary is the actual DBBinary object that should be
 239         scanned.
 240         '''
 241         self.binary_id = binary.binary_id
 242
 243     def scan(self, dummy_arg = None):
 244         '''
 245         This method does the actual scan and fills in the associated BinContents
 246         property. It commits any changes to the database. The argument dummy_arg
 247         is ignored but needed by our threadpool implementation.
 248         '''
 249         session = DBConn().session()
 250         binary = session.query(DBBinary).get(self.binary_id)
 251         for filename in binary.scan_contents():
 252             binary.contents.append(BinContents(file = filename))
 253         session.commit()
 254         session.close()
 255
 256     @classmethod
 257     def scan_all(class_, limit = None):
 258         '''
 259         The class method scan_all() scans all binaries using multiple threads.
 260         The number of binaries to be scanned can be limited with the limit
 261         argument. Returns the number of processed and remaining packages as a
 262         dict.
 263         '''
 264         session = DBConn().session()
 265         query = session.query(DBBinary).filter(DBBinary.contents == None)
 266         remaining = query.count
 267         if limit is not None:
 268             query = query.limit(limit)
 269         processed = query.count()
 270         threadpool = ThreadPool()
 271         for binary in query.yield_per(100):
 272             threadpool.queueTask(ContentsScanner(binary).scan)
 273         threadpool.joinAll()
 274         remaining = remaining()
 275         session.close()
 276         return { 'processed': processed, 'remaining': remaining }