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
  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 "%-60s%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         try:
 177             filename = os.join(Config()['Dir::Templates'], 'contents')
 178             header_file = open(filename)
 179             return header_file.read()
 180         finally:
 181             if header_file:
 182                 header_file.close()
 183
 184     def write_file(self):
 185         '''
 186         Write the output file.
 187         '''
 188         command = ['gzip', '--rsyncable']
 189         output_file = open(self.output_filename(), 'w')
 190         pipe = Popen(command, stdin = PIPE, stdout = output_file).stdin
 191         pipe.write(self.get_header())
 192         for item in self.fetch():
 193             pipe.write(item)
 194         pipe.close()
 195         output_file.close()
 196
 197
 198 class ContentsScanner(object):
 199     '''
 200     ContentsScanner provides a threadsafe method scan() to scan the contents of
 201     a DBBinary object.
 202     '''
 203     def __init__(self, binary):
 204         '''
 205         The argument binary is the actual DBBinary object that should be
 206         scanned.
 207         '''
 208         self.binary_id = binary.binary_id
 209
 210     def scan(self, dummy_arg = None):
 211         '''
 212         This method does the actual scan and fills in the associated BinContents
 213         property. It commits any changes to the database. The argument dummy_arg
 214         is ignored but needed by our threadpool implementation.
 215         '''
 216         session = DBConn().session()
 217         binary = session.query(DBBinary).get(self.binary_id)
 218         for filename in binary.scan_contents():
 219             binary.contents.append(BinContents(file = filename))
 220         session.commit()
 221         session.close()
 222
 223     @classmethod
 224     def scan_all(class_, limit = None):
 225         '''
 226         The class method scan_all() scans all binaries using multiple threads.
 227         The number of binaries to be scanned can be limited with the limit
 228         argument. Returns the number of processed and remaining packages as a
 229         dict.
 230         '''
 231         session = DBConn().session()
 232         query = session.query(DBBinary).filter(DBBinary.contents == None)
 233         remaining = query.count
 234         if limit is not None:
 235             query = query.limit(limit)
 236         processed = query.count()
 237         threadpool = ThreadPool()
 238         for binary in query.yield_per(100):
 239             threadpool.queueTask(ContentsScanner(binary).scan)
 240         threadpool.joinAll()
 241         remaining = remaining()
 242         session.close()
 243         return { 'processed': processed, 'remaining': remaining }