]> git.decadent.org.uk Git - dak.git/blob - daklib/queue.py
bin_assoc
[dak.git] / daklib / queue.py
1 #!/usr/bin/env python
2 # vim:set et sw=4:
3
4 """
5 Queue utility functions for dak
6
7 @contact: Debian FTP Master <ftpmaster@debian.org>
8 @copyright: 2001 - 2006 James Troup <james@nocrew.org>
9 @copyright: 2009  Joerg Jaspert <joerg@debian.org>
10 @license: GNU General Public License version 2 or later
11 """
12
13 # This program is free software; you can redistribute it and/or modify
14 # it under the terms of the GNU General Public License as published by
15 # the Free Software Foundation; either version 2 of the License, or
16 # (at your option) any later version.
17
18 # This program is distributed in the hope that it will be useful,
19 # but WITHOUT ANY WARRANTY; without even the implied warranty of
20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 # GNU General Public License for more details.
22
23 # You should have received a copy of the GNU General Public License
24 # along with this program; if not, write to the Free Software
25 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26
27 ###############################################################################
28
29 import cPickle
30 import errno
31 import os
32 import pg
33 import stat
34 import sys
35 import time
36 import apt_inst
37 import apt_pkg
38 import utils
39 import database
40 from dak_exceptions import *
41 from regexes import re_default_answer, re_fdnic, re_bin_only_nmu
42
43 from types import *
44
45 ###############################################################################
46
47 # Determine what parts in a .changes are NEW
48
49 def determine_new(changes, files, projectB, warn=1):
50     """
51     Determine what parts in a C{changes} file are NEW.
52
53     @type changes: Upload.Pkg.changes dict
54     @param changes: Changes dictionary
55
56     @type files: Upload.Pkg.files dict
57     @param files: Files dictionary
58
59     @type projectB: pgobject
60     @param projectB: DB handle
61
62     @type warn: bool
63     @param warn: Warn if overrides are added for (old)stable
64
65     @rtype: dict
66     @return: dictionary of NEW components.
67
68     """
69     new = {}
70
71     # Build up a list of potentially new things
72     for file_entry in files.keys():
73         f = files[file_entry]
74         # Skip byhand elements
75         if f["type"] == "byhand":
76             continue
77         pkg = f["package"]
78         priority = f["priority"]
79         section = f["section"]
80         file_type = get_type(f)
81         component = f["component"]
82
83         if file_type == "dsc":
84             priority = "source"
85         if not new.has_key(pkg):
86             new[pkg] = {}
87             new[pkg]["priority"] = priority
88             new[pkg]["section"] = section
89             new[pkg]["type"] = file_type
90             new[pkg]["component"] = component
91             new[pkg]["files"] = []
92         else:
93             old_type = new[pkg]["type"]
94             if old_type != file_type:
95                 # source gets trumped by deb or udeb
96                 if old_type == "dsc":
97                     new[pkg]["priority"] = priority
98                     new[pkg]["section"] = section
99                     new[pkg]["type"] = file_type
100                     new[pkg]["component"] = component
101         new[pkg]["files"].append(file_entry)
102         if f.has_key("othercomponents"):
103             new[pkg]["othercomponents"] = f["othercomponents"]
104
105     for suite in changes["suite"].keys():
106         suite_id = database.get_suite_id(suite)
107         for pkg in new.keys():
108             component_id = database.get_component_id(new[pkg]["component"])
109             type_id = database.get_override_type_id(new[pkg]["type"])
110             q = projectB.query("SELECT package FROM override WHERE package = '%s' AND suite = %s AND component = %s AND type = %s" % (pkg, suite_id, component_id, type_id))
111             ql = q.getresult()
112             if ql:
113                 for file_entry in new[pkg]["files"]:
114                     if files[file_entry].has_key("new"):
115                         del files[file_entry]["new"]
116                 del new[pkg]
117
118     if warn:
119         if changes["suite"].has_key("stable"):
120             print "WARNING: overrides will be added for stable!"
121             if changes["suite"].has_key("oldstable"):
122                 print "WARNING: overrides will be added for OLDstable!"
123         for pkg in new.keys():
124             if new[pkg].has_key("othercomponents"):
125                 print "WARNING: %s already present in %s distribution." % (pkg, new[pkg]["othercomponents"])
126
127     return new
128
129 ################################################################################
130
131 def get_type(file):
132     """
133     Get the file type of C{file}
134
135     @type file: dict
136     @param file: file entry
137
138     @rtype: string
139     @return: filetype
140
141     """
142     # Determine the type
143     if file.has_key("dbtype"):
144         file_type = file["dbtype"]
145     elif file["type"] in [ "orig.tar.gz", "orig.tar.bz2", "tar.gz", "tar.bz2", "diff.gz", "diff.bz2", "dsc" ]:
146         file_type = "dsc"
147     else:
148         utils.fubar("invalid type (%s) for new.  Dazed, confused and sure as heck not continuing." % (file_type))
149
150     # Validate the override type
151     type_id = database.get_override_type_id(file_type)
152     if type_id == -1:
153         utils.fubar("invalid type (%s) for new.  Say wha?" % (file_type))
154
155     return file_type
156
157 ################################################################################
158
159
160
161 def check_valid(new):
162     """
163     Check if section and priority for NEW packages exist in database.
164     Additionally does sanity checks:
165       - debian-installer packages have to be udeb (or source)
166       - non debian-installer packages can not be udeb
167       - source priority can only be assigned to dsc file types
168
169     @type new: dict
170     @param new: Dict of new packages with their section, priority and type.
171
172     """
173     for pkg in new.keys():
174         section = new[pkg]["section"]
175         priority = new[pkg]["priority"]
176         file_type = new[pkg]["type"]
177         new[pkg]["section id"] = database.get_section_id(section)
178         new[pkg]["priority id"] = database.get_priority_id(new[pkg]["priority"])
179         # Sanity checks
180         di = section.find("debian-installer") != -1
181         if (di and file_type not in ("udeb", "dsc")) or (not di and file_type == "udeb"):
182             new[pkg]["section id"] = -1
183         if (priority == "source" and file_type != "dsc") or \
184            (priority != "source" and file_type == "dsc"):
185             new[pkg]["priority id"] = -1
186
187
188 ###############################################################################
189
190 class Pkg:
191     """ Convenience wrapper to carry around all the package information """
192     def __init__(self, **kwds):
193         self.__dict__.update(kwds)
194
195     def update(self, **kwds):
196         self.__dict__.update(kwds)
197
198 ###############################################################################
199
200 class Upload:
201     """
202     Everything that has to do with an upload processed.
203
204     """
205     def __init__(self, Cnf):
206         """
207         Initialize various variables and the global substitution template mappings.
208         Also connect to the DB and initialize the Database module.
209
210         """
211         self.Cnf = Cnf
212         self.accept_count = 0
213         self.accept_bytes = 0L
214         self.reject_message = ""
215         self.pkg = Pkg(changes = {}, dsc = {}, dsc_files = {}, files = {},
216                        legacy_source_untouchable = {})
217
218         # Initialize the substitution template mapping global
219         Subst = self.Subst = {}
220         Subst["__ADMIN_ADDRESS__"] = Cnf["Dinstall::MyAdminAddress"]
221         Subst["__BUG_SERVER__"] = Cnf["Dinstall::BugServer"]
222         Subst["__DISTRO__"] = Cnf["Dinstall::MyDistribution"]
223         Subst["__DAK_ADDRESS__"] = Cnf["Dinstall::MyEmailAddress"]
224
225         self.projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
226         database.init(Cnf, self.projectB)
227
228     ###########################################################################
229
230     def init_vars (self):
231         """ Reset a number of entries from our Pkg object. """
232         self.pkg.changes.clear()
233         self.pkg.dsc.clear()
234         self.pkg.files.clear()
235         self.pkg.dsc_files.clear()
236         self.pkg.legacy_source_untouchable.clear()
237         self.pkg.orig_tar_id = None
238         self.pkg.orig_tar_location = ""
239         self.pkg.orig_tar_gz = None
240
241     ###########################################################################
242
243     def update_vars (self):
244         """
245         Update our Pkg object by reading a previously created cPickle .dak dumpfile.
246         """
247         dump_filename = self.pkg.changes_file[:-8]+".dak"
248         dump_file = utils.open_file(dump_filename)
249         p = cPickle.Unpickler(dump_file)
250
251         self.pkg.changes.update(p.load())
252         self.pkg.dsc.update(p.load())
253         self.pkg.files.update(p.load())
254         self.pkg.dsc_files.update(p.load())
255         self.pkg.legacy_source_untouchable.update(p.load())
256
257         self.pkg.orig_tar_id = p.load()
258         self.pkg.orig_tar_location = p.load()
259
260         dump_file.close()
261
262     ###########################################################################
263
264
265     def dump_vars(self, dest_dir):
266         """
267         Dump our Pkg object into a cPickle file.
268
269         @type dest_dir: string
270         @param dest_dir: Path where the dumpfile should be stored
271
272         @note: This could just dump the dictionaries as is, but I'd like to avoid this so
273                there's some idea of what process-accepted & process-new use from
274                process-unchecked. (JT)
275
276         """
277
278         changes = self.pkg.changes
279         dsc = self.pkg.dsc
280         files = self.pkg.files
281         dsc_files = self.pkg.dsc_files
282         legacy_source_untouchable = self.pkg.legacy_source_untouchable
283         orig_tar_id = self.pkg.orig_tar_id
284         orig_tar_location = self.pkg.orig_tar_location
285
286         dump_filename = os.path.join(dest_dir,self.pkg.changes_file[:-8] + ".dak")
287         dump_file = utils.open_file(dump_filename, 'w')
288         try:
289             os.chmod(dump_filename, 0664)
290         except OSError, e:
291             # chmod may fail when the dumpfile is not owned by the user
292             # invoking dak (like e.g. when NEW is processed by a member
293             # of ftpteam)
294             if errno.errorcode[e.errno] == 'EPERM':
295                 perms = stat.S_IMODE(os.stat(dump_filename)[stat.ST_MODE])
296                 # security precaution, should never happen unless a weird
297                 # umask is set anywhere
298                 if perms & stat.S_IWOTH:
299                     utils.fubar("%s is world writable and chmod failed." % \
300                         (dump_filename,))
301                 # ignore the failed chmod otherwise as the file should
302                 # already have the right privileges and is just, at worst,
303                 # unreadable for world
304             else:
305                 raise
306
307         p = cPickle.Pickler(dump_file, 1)
308         d_changes = {}
309         d_dsc = {}
310         d_files = {}
311         d_dsc_files = {}
312
313         ## files
314         for file_entry in files.keys():
315             d_files[file_entry] = {}
316             for i in [ "package", "version", "architecture", "type", "size",
317                        "md5sum", "sha1sum", "sha256sum", "component",
318                        "location id", "source package", "source version",
319                        "maintainer", "dbtype", "files id", "new",
320                        "section", "priority", "othercomponents",
321                        "pool name", "original component" ]:
322                 if files[file_entry].has_key(i):
323                     d_files[file_entry][i] = files[file_entry][i]
324         ## changes
325         # Mandatory changes fields
326         for i in [ "distribution", "source", "architecture", "version",
327                    "maintainer", "urgency", "fingerprint", "changedby822",
328                    "changedby2047", "changedbyname", "maintainer822",
329                    "maintainer2047", "maintainername", "maintaineremail",
330                    "closes", "changes" ]:
331             d_changes[i] = changes[i]
332         # Optional changes fields
333         for i in [ "changed-by", "filecontents", "format", "process-new note", "adv id", "distribution-version",
334                    "sponsoremail" ]:
335             if changes.has_key(i):
336                 d_changes[i] = changes[i]
337         ## dsc
338         for i in [ "source", "version", "maintainer", "fingerprint",
339                    "uploaders", "bts changelog", "dm-upload-allowed" ]:
340             if dsc.has_key(i):
341                 d_dsc[i] = dsc[i]
342         ## dsc_files
343         for file_entry in dsc_files.keys():
344             d_dsc_files[file_entry] = {}
345             # Mandatory dsc_files fields
346             for i in [ "size", "md5sum" ]:
347                 d_dsc_files[file_entry][i] = dsc_files[file_entry][i]
348             # Optional dsc_files fields
349             for i in [ "files id" ]:
350                 if dsc_files[file_entry].has_key(i):
351                     d_dsc_files[file_entry][i] = dsc_files[file_entry][i]
352
353         for i in [ d_changes, d_dsc, d_files, d_dsc_files,
354                    legacy_source_untouchable, orig_tar_id, orig_tar_location ]:
355             p.dump(i)
356         dump_file.close()
357
358     ###########################################################################
359
360     # Set up the per-package template substitution mappings
361
362     def update_subst (self, reject_message = ""):
363         """ Set up the per-package template substitution mappings """
364
365         Subst = self.Subst
366         changes = self.pkg.changes
367         # If 'dak process-unchecked' crashed out in the right place, architecture may still be a string.
368         if not changes.has_key("architecture") or not isinstance(changes["architecture"], DictType):
369             changes["architecture"] = { "Unknown" : "" }
370         # and maintainer2047 may not exist.
371         if not changes.has_key("maintainer2047"):
372             changes["maintainer2047"] = self.Cnf["Dinstall::MyEmailAddress"]
373
374         Subst["__ARCHITECTURE__"] = " ".join(changes["architecture"].keys())
375         Subst["__CHANGES_FILENAME__"] = os.path.basename(self.pkg.changes_file)
376         Subst["__FILE_CONTENTS__"] = changes.get("filecontents", "")
377
378         # For source uploads the Changed-By field wins; otherwise Maintainer wins.
379         if changes["architecture"].has_key("source") and changes["changedby822"] != "" and (changes["changedby822"] != changes["maintainer822"]):
380             Subst["__MAINTAINER_FROM__"] = changes["changedby2047"]
381             Subst["__MAINTAINER_TO__"] = "%s, %s" % (changes["changedby2047"],
382                                                      changes["maintainer2047"])
383             Subst["__MAINTAINER__"] = changes.get("changed-by", "Unknown")
384         else:
385             Subst["__MAINTAINER_FROM__"] = changes["maintainer2047"]
386             Subst["__MAINTAINER_TO__"] = changes["maintainer2047"]
387             Subst["__MAINTAINER__"] = changes.get("maintainer", "Unknown")
388
389         if "sponsoremail" in changes:
390             Subst["__MAINTAINER_TO__"] += ", %s"%changes["sponsoremail"]
391
392         if self.Cnf.has_key("Dinstall::TrackingServer") and changes.has_key("source"):
393             Subst["__MAINTAINER_TO__"] += "\nBcc: %s@%s" % (changes["source"], self.Cnf["Dinstall::TrackingServer"])
394
395         # Apply any global override of the Maintainer field
396         if self.Cnf.get("Dinstall::OverrideMaintainer"):
397             Subst["__MAINTAINER_TO__"] = self.Cnf["Dinstall::OverrideMaintainer"]
398             Subst["__MAINTAINER_FROM__"] = self.Cnf["Dinstall::OverrideMaintainer"]
399
400         Subst["__REJECT_MESSAGE__"] = reject_message
401         Subst["__SOURCE__"] = changes.get("source", "Unknown")
402         Subst["__VERSION__"] = changes.get("version", "Unknown")
403
404     ###########################################################################
405
406     def build_summaries(self):
407         """ Build a summary of changes the upload introduces. """
408         changes = self.pkg.changes
409         files = self.pkg.files
410
411         byhand = summary = new = ""
412
413         # changes["distribution"] may not exist in corner cases
414         # (e.g. unreadable changes files)
415         if not changes.has_key("distribution") or not isinstance(changes["distribution"], DictType):
416             changes["distribution"] = {}
417
418         override_summary =""
419         file_keys = files.keys()
420         file_keys.sort()
421         for file_entry in file_keys:
422             if files[file_entry].has_key("byhand"):
423                 byhand = 1
424                 summary += file_entry + " byhand\n"
425             elif files[file_entry].has_key("new"):
426                 new = 1
427                 summary += "(new) %s %s %s\n" % (file_entry, files[file_entry]["priority"], files[file_entry]["section"])
428                 if files[file_entry].has_key("othercomponents"):
429                     summary += "WARNING: Already present in %s distribution.\n" % (files[file_entry]["othercomponents"])
430                 if files[file_entry]["type"] == "deb":
431                     deb_fh = utils.open_file(file_entry)
432                     summary += apt_pkg.ParseSection(apt_inst.debExtractControl(deb_fh))["Description"] + '\n'
433                     deb_fh.close()
434             else:
435                 files[file_entry]["pool name"] = utils.poolify (changes.get("source",""), files[file_entry]["component"])
436                 destination = self.Cnf["Dir::PoolRoot"] + files[file_entry]["pool name"] + file_entry
437                 summary += file_entry + "\n  to " + destination + "\n"
438                 if not files[file_entry].has_key("type"):
439                     files[file_entry]["type"] = "unknown"
440                 if files[file_entry]["type"] in ["deb", "udeb", "dsc"]:
441                     # (queue/unchecked), there we have override entries already, use them
442                     # (process-new), there we dont have override entries, use the newly generated ones.
443                     override_prio = files[file_entry].get("override priority", files[file_entry]["priority"])
444                     override_sect = files[file_entry].get("override section", files[file_entry]["section"])
445                     override_summary += "%s - %s %s\n" % (file_entry, override_prio, override_sect)
446
447         short_summary = summary
448
449         # This is for direport's benefit...
450         f = re_fdnic.sub("\n .\n", changes.get("changes",""))
451
452         if byhand or new:
453             summary += "Changes: " + f
454
455         summary += "\n\nOverride entries for your package:\n" + override_summary + "\n"
456
457         summary += self.announce(short_summary, 0)
458
459         return (summary, short_summary)
460
461     ###########################################################################
462
463     def close_bugs (self, summary, action):
464         """
465         Send mail to close bugs as instructed by the closes field in the changes file.
466         Also add a line to summary if any work was done.
467
468         @type summary: string
469         @param summary: summary text, as given by L{build_summaries}
470
471         @type action: bool
472         @param action: Set to false no real action will be done.
473
474         @rtype: string
475         @return: summary. If action was taken, extended by the list of closed bugs.
476
477         """
478         changes = self.pkg.changes
479         Subst = self.Subst
480         Cnf = self.Cnf
481
482         bugs = changes["closes"].keys()
483
484         if not bugs:
485             return summary
486
487         bugs.sort()
488         summary += "Closing bugs: "
489         for bug in bugs:
490             summary += "%s " % (bug)
491             if action:
492                 Subst["__BUG_NUMBER__"] = bug
493                 if changes["distribution"].has_key("stable"):
494                     Subst["__STABLE_WARNING__"] = """
495 Note that this package is not part of the released stable Debian
496 distribution.  It may have dependencies on other unreleased software,
497 or other instabilities.  Please take care if you wish to install it.
498 The update will eventually make its way into the next released Debian
499 distribution."""
500                 else:
501                     Subst["__STABLE_WARNING__"] = ""
502                     mail_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-unchecked.bug-close")
503                     utils.send_mail (mail_message)
504         if action:
505             self.Logger.log(["closing bugs"]+bugs)
506         summary += "\n"
507
508         return summary
509
510     ###########################################################################
511
512     def announce (self, short_summary, action):
513         """
514         Send an announce mail about a new upload.
515
516         @type short_summary: string
517         @param short_summary: Short summary text to include in the mail
518
519         @type action: bool
520         @param action: Set to false no real action will be done.
521
522         @rtype: string
523         @return: Textstring about action taken.
524
525         """
526         Subst = self.Subst
527         Cnf = self.Cnf
528         changes = self.pkg.changes
529
530         # Only do announcements for source uploads with a recent dpkg-dev installed
531         if float(changes.get("format", 0)) < 1.6 or not changes["architecture"].has_key("source"):
532             return ""
533
534         lists_done = {}
535         summary = ""
536         Subst["__SHORT_SUMMARY__"] = short_summary
537
538         for dist in changes["distribution"].keys():
539             announce_list = Cnf.Find("Suite::%s::Announce" % (dist))
540             if announce_list == "" or lists_done.has_key(announce_list):
541                 continue
542             lists_done[announce_list] = 1
543             summary += "Announcing to %s\n" % (announce_list)
544
545             if action:
546                 Subst["__ANNOUNCE_LIST_ADDRESS__"] = announce_list
547                 if Cnf.get("Dinstall::TrackingServer") and changes["architecture"].has_key("source"):
548                     Subst["__ANNOUNCE_LIST_ADDRESS__"] = Subst["__ANNOUNCE_LIST_ADDRESS__"] + "\nBcc: %s@%s" % (changes["source"], Cnf["Dinstall::TrackingServer"])
549                 mail_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-unchecked.announce")
550                 utils.send_mail (mail_message)
551
552         if Cnf.FindB("Dinstall::CloseBugs"):
553             summary = self.close_bugs(summary, action)
554
555         return summary
556
557     ###########################################################################
558
559     def accept (self, summary, short_summary):
560         """
561         Accept an upload.
562
563         This moves all files referenced from the .changes into the I{accepted}
564         queue, sends the accepted mail, announces to lists, closes bugs and
565         also checks for override disparities. If enabled it will write out
566         the version history for the BTS Version Tracking and will finally call
567         L{queue_build}.
568
569         @type summary: string
570         @param summary: Summary text
571
572         @type short_summary: string
573         @param short_summary: Short summary
574
575         """
576
577         Cnf = self.Cnf
578         Subst = self.Subst
579         files = self.pkg.files
580         changes = self.pkg.changes
581         changes_file = self.pkg.changes_file
582         dsc = self.pkg.dsc
583
584         print "Accepting."
585         self.Logger.log(["Accepting changes",changes_file])
586
587         self.dump_vars(Cnf["Dir::Queue::Accepted"])
588
589         # Move all the files into the accepted directory
590         utils.move(changes_file, Cnf["Dir::Queue::Accepted"])
591         file_keys = files.keys()
592         for file_entry in file_keys:
593             utils.move(file_entry, Cnf["Dir::Queue::Accepted"])
594             self.accept_bytes += float(files[file_entry]["size"])
595         self.accept_count += 1
596
597         # Send accept mail, announce to lists, close bugs and check for
598         # override disparities
599         if not Cnf["Dinstall::Options::No-Mail"]:
600             Subst["__SUITE__"] = ""
601             Subst["__SUMMARY__"] = summary
602             mail_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-unchecked.accepted")
603             utils.send_mail(mail_message)
604             self.announce(short_summary, 1)
605
606
607         ## Helper stuff for DebBugs Version Tracking
608         if Cnf.Find("Dir::Queue::BTSVersionTrack"):
609             # ??? once queue/* is cleared on *.d.o and/or reprocessed
610             # the conditionalization on dsc["bts changelog"] should be
611             # dropped.
612
613             # Write out the version history from the changelog
614             if changes["architecture"].has_key("source") and \
615                dsc.has_key("bts changelog"):
616
617                 (fd, temp_filename) = utils.temp_filename(Cnf["Dir::Queue::BTSVersionTrack"], prefix=".")
618                 version_history = os.fdopen(fd, 'w')
619                 version_history.write(dsc["bts changelog"])
620                 version_history.close()
621                 filename = "%s/%s" % (Cnf["Dir::Queue::BTSVersionTrack"],
622                                       changes_file[:-8]+".versions")
623                 os.rename(temp_filename, filename)
624                 os.chmod(filename, 0644)
625
626             # Write out the binary -> source mapping.
627             (fd, temp_filename) = utils.temp_filename(Cnf["Dir::Queue::BTSVersionTrack"], prefix=".")
628             debinfo = os.fdopen(fd, 'w')
629             for file_entry in file_keys:
630                 f = files[file_entry]
631                 if f["type"] == "deb":
632                     line = " ".join([f["package"], f["version"],
633                                      f["architecture"], f["source package"],
634                                      f["source version"]])
635                     debinfo.write(line+"\n")
636             debinfo.close()
637             filename = "%s/%s" % (Cnf["Dir::Queue::BTSVersionTrack"],
638                                   changes_file[:-8]+".debinfo")
639             os.rename(temp_filename, filename)
640             os.chmod(filename, 0644)
641
642         self.queue_build("accepted", Cnf["Dir::Queue::Accepted"])
643
644     ###########################################################################
645
646     def queue_build (self, queue, path):
647         """
648         Prepare queue_build database table used for incoming autobuild support.
649
650         @type queue: string
651         @param queue: queue name
652
653         @type path: string
654         @param path: path for the queue file entries/link destinations
655         """
656
657         Cnf = self.Cnf
658         Subst = self.Subst
659         files = self.pkg.files
660         changes = self.pkg.changes
661         changes_file = self.pkg.changes_file
662         dsc = self.pkg.dsc
663         file_keys = files.keys()
664
665         ## Special support to enable clean auto-building of queued packages
666         queue_id = database.get_or_set_queue_id(queue)
667
668         self.projectB.query("BEGIN WORK")
669         for suite in changes["distribution"].keys():
670             if suite not in Cnf.ValueList("Dinstall::QueueBuildSuites"):
671                 continue
672             suite_id = database.get_suite_id(suite)
673             dest_dir = Cnf["Dir::QueueBuild"]
674             if Cnf.FindB("Dinstall::SecurityQueueBuild"):
675                 dest_dir = os.path.join(dest_dir, suite)
676             for file_entry in file_keys:
677                 src = os.path.join(path, file_entry)
678                 dest = os.path.join(dest_dir, file_entry)
679                 if Cnf.FindB("Dinstall::SecurityQueueBuild"):
680                     # Copy it since the original won't be readable by www-data
681                     utils.copy(src, dest)
682                 else:
683                     # Create a symlink to it
684                     os.symlink(src, dest)
685                 # Add it to the list of packages for later processing by apt-ftparchive
686                 self.projectB.query("INSERT INTO queue_build (suite, queue, filename, in_queue) VALUES (%s, %s, '%s', 't')" % (suite_id, queue_id, dest))
687             # If the .orig.tar.gz is in the pool, create a symlink to
688             # it (if one doesn't already exist)
689             if self.pkg.orig_tar_id:
690                 # Determine the .orig.tar.gz file name
691                 for dsc_file in self.pkg.dsc_files.keys():
692                     if dsc_file.endswith(".orig.tar.gz"):
693                         filename = dsc_file
694                 dest = os.path.join(dest_dir, filename)
695                 # If it doesn't exist, create a symlink
696                 if not os.path.exists(dest):
697                     # Find the .orig.tar.gz in the pool
698                     q = self.projectB.query("SELECT l.path, f.filename from location l, files f WHERE f.id = %s and f.location = l.id" % (self.pkg.orig_tar_id))
699                     ql = q.getresult()
700                     if not ql:
701                         utils.fubar("[INTERNAL ERROR] Couldn't find id %s in files table." % (self.pkg.orig_tar_id))
702                     src = os.path.join(ql[0][0], ql[0][1])
703                     os.symlink(src, dest)
704                     # Add it to the list of packages for later processing by apt-ftparchive
705                     self.projectB.query("INSERT INTO queue_build (suite, queue, filename, in_queue) VALUES (%s, %s, '%s', 't')" % (suite_id, queue_id, dest))
706                 # if it does, update things to ensure it's not removed prematurely
707                 else:
708                     self.projectB.query("UPDATE queue_build SET in_queue = 't', last_used = NULL WHERE filename = '%s' AND suite = %s" % (dest, suite_id))
709
710         self.projectB.query("COMMIT WORK")
711
712     ###########################################################################
713
714     def check_override (self):
715         """
716         Checks override entries for validity. Mails "Override disparity" warnings,
717         if that feature is enabled.
718
719         Abandons the check if
720           - this is a non-sourceful upload
721           - override disparity checks are disabled
722           - mail sending is disabled
723
724         """
725         Subst = self.Subst
726         changes = self.pkg.changes
727         files = self.pkg.files
728         Cnf = self.Cnf
729
730         # Abandon the check if:
731         #  a) it's a non-sourceful upload
732         #  b) override disparity checks have been disabled
733         #  c) we're not sending mail
734         if not changes["architecture"].has_key("source") or \
735            not Cnf.FindB("Dinstall::OverrideDisparityCheck") or \
736            Cnf["Dinstall::Options::No-Mail"]:
737             return
738
739         summary = ""
740         file_keys = files.keys()
741         file_keys.sort()
742         for file_entry in file_keys:
743             if not files[file_entry].has_key("new") and files[file_entry]["type"] == "deb":
744                 section = files[file_entry]["section"]
745                 override_section = files[file_entry]["override section"]
746                 if section.lower() != override_section.lower() and section != "-":
747                     summary += "%s: package says section is %s, override says %s.\n" % (file_entry, section, override_section)
748                 priority = files[file_entry]["priority"]
749                 override_priority = files[file_entry]["override priority"]
750                 if priority != override_priority and priority != "-":
751                     summary += "%s: package says priority is %s, override says %s.\n" % (file_entry, priority, override_priority)
752
753         if summary == "":
754             return
755
756         Subst["__SUMMARY__"] = summary
757         mail_message = utils.TemplateSubst(Subst,self.Cnf["Dir::Templates"]+"/process-unchecked.override-disparity")
758         utils.send_mail(mail_message)
759
760     ###########################################################################
761
762     def force_reject (self, files):
763         """
764         Forcefully move files from the current directory to the
765         reject directory.  If any file already exists in the reject
766         directory it will be moved to the morgue to make way for
767         the new file.
768
769         @type files: dict
770         @param files: file dictionary
771
772         """
773
774         Cnf = self.Cnf
775
776         for file_entry in files:
777             # Skip any files which don't exist or which we don't have permission to copy.
778             if os.access(file_entry,os.R_OK) == 0:
779                 continue
780             dest_file = os.path.join(Cnf["Dir::Queue::Reject"], file_entry)
781             try:
782                 dest_fd = os.open(dest_file, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
783             except OSError, e:
784                 # File exists?  Let's try and move it to the morgue
785                 if errno.errorcode[e.errno] == 'EEXIST':
786                     morgue_file = os.path.join(Cnf["Dir::Morgue"],Cnf["Dir::MorgueReject"],file_entry)
787                     try:
788                         morgue_file = utils.find_next_free(morgue_file)
789                     except NoFreeFilenameError:
790                         # Something's either gone badly Pete Tong, or
791                         # someone is trying to exploit us.
792                         utils.warn("**WARNING** failed to move %s from the reject directory to the morgue." % (file_entry))
793                         return
794                     utils.move(dest_file, morgue_file, perms=0660)
795                     try:
796                         dest_fd = os.open(dest_file, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
797                     except OSError, e:
798                         # Likewise
799                         utils.warn("**WARNING** failed to claim %s in the reject directory." % (file_entry))
800                         return
801                 else:
802                     raise
803             # If we got here, we own the destination file, so we can
804             # safely overwrite it.
805             utils.move(file_entry, dest_file, 1, perms=0660)
806             os.close(dest_fd)
807
808     ###########################################################################
809
810     def do_reject (self, manual = 0, reject_message = ""):
811         """
812         Reject an upload. If called without a reject message or C{manual} is
813         true, spawn an editor so the user can write one.
814
815         @type manual: bool
816         @param manual: manual or automated rejection
817
818         @type reject_message: string
819         @param reject_message: A reject message
820
821         @return: 0
822
823         """
824         # If we weren't given a manual rejection message, spawn an
825         # editor so the user can add one in...
826         if manual and not reject_message:
827             (fd, temp_filename) = utils.temp_filename()
828             editor = os.environ.get("EDITOR","vi")
829             answer = 'E'
830             while answer == 'E':
831                 os.system("%s %s" % (editor, temp_filename))
832                 temp_fh = utils.open_file(temp_filename)
833                 reject_message = "".join(temp_fh.readlines())
834                 temp_fh.close()
835                 print "Reject message:"
836                 print utils.prefix_multi_line_string(reject_message,"  ",include_blank_lines=1)
837                 prompt = "[R]eject, Edit, Abandon, Quit ?"
838                 answer = "XXX"
839                 while prompt.find(answer) == -1:
840                     answer = utils.our_raw_input(prompt)
841                     m = re_default_answer.search(prompt)
842                     if answer == "":
843                         answer = m.group(1)
844                     answer = answer[:1].upper()
845             os.unlink(temp_filename)
846             if answer == 'A':
847                 return 1
848             elif answer == 'Q':
849                 sys.exit(0)
850
851         print "Rejecting.\n"
852
853         Cnf = self.Cnf
854         Subst = self.Subst
855         pkg = self.pkg
856
857         reason_filename = pkg.changes_file[:-8] + ".reason"
858         reason_filename = Cnf["Dir::Queue::Reject"] + '/' + reason_filename
859
860         # Move all the files into the reject directory
861         reject_files = pkg.files.keys() + [pkg.changes_file]
862         self.force_reject(reject_files)
863
864         # If we fail here someone is probably trying to exploit the race
865         # so let's just raise an exception ...
866         if os.path.exists(reason_filename):
867             os.unlink(reason_filename)
868         reason_fd = os.open(reason_filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
869
870         if not manual:
871             Subst["__REJECTOR_ADDRESS__"] = Cnf["Dinstall::MyEmailAddress"]
872             Subst["__MANUAL_REJECT_MESSAGE__"] = ""
873             Subst["__CC__"] = "X-DAK-Rejection: automatic (moo)\nX-Katie-Rejection: automatic (moo)"
874             os.write(reason_fd, reject_message)
875             reject_mail_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/queue.rejected")
876         else:
877             # Build up the rejection email
878             user_email_address = utils.whoami() + " <%s>" % (Cnf["Dinstall::MyAdminAddress"])
879
880             Subst["__REJECTOR_ADDRESS__"] = user_email_address
881             Subst["__MANUAL_REJECT_MESSAGE__"] = reject_message
882             Subst["__CC__"] = "Cc: " + Cnf["Dinstall::MyEmailAddress"]
883             reject_mail_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/queue.rejected")
884             # Write the rejection email out as the <foo>.reason file
885             os.write(reason_fd, reject_mail_message)
886
887         os.close(reason_fd)
888
889         # Send the rejection mail if appropriate
890         if not Cnf["Dinstall::Options::No-Mail"]:
891             utils.send_mail(reject_mail_message)
892
893         self.Logger.log(["rejected", pkg.changes_file])
894         return 0
895
896     ################################################################################
897
898     def source_exists (self, package, source_version, suites = ["any"]):
899         """
900         Ensure that source exists somewhere in the archive for the binary
901         upload being processed.
902           1. exact match     => 1.0-3
903           2. bin-only NMU    => 1.0-3+b1 , 1.0-3.1+b1
904
905         @type package: string
906         @param package: package source name
907
908         @type source_version: string
909         @param source_version: expected source version
910
911         @type suites: list
912         @param suites: list of suites to check in, default I{any}
913
914         @rtype: int
915         @return: returns 1 if a source with expected version is found, otherwise 0
916
917         """
918         okay = 1
919         for suite in suites:
920             if suite == "any":
921                 que = "SELECT s.version FROM source s WHERE s.source = '%s'" % \
922                     (package)
923             else:
924                 # source must exist in suite X, or in some other suite that's
925                 # mapped to X, recursively... silent-maps are counted too,
926                 # unreleased-maps aren't.
927                 maps = self.Cnf.ValueList("SuiteMappings")[:]
928                 maps.reverse()
929                 maps = [ m.split() for m in maps ]
930                 maps = [ (x[1], x[2]) for x in maps
931                                 if x[0] == "map" or x[0] == "silent-map" ]
932                 s = [suite]
933                 for x in maps:
934                     if x[1] in s and x[0] not in s:
935                         s.append(x[0])
936
937                 que = "SELECT s.version FROM source s JOIN src_associations sa ON (s.id = sa.source) JOIN suite su ON (sa.suite = su.id) WHERE s.source = '%s' AND (%s)" % (package, " OR ".join(["su.suite_name = '%s'" % a for a in s]))
938             q = self.projectB.query(que)
939
940             # Reduce the query results to a list of version numbers
941             ql = [ i[0] for i in q.getresult() ]
942
943             # Try (1)
944             if source_version in ql:
945                 continue
946
947             # Try (2)
948             orig_source_version = re_bin_only_nmu.sub('', source_version)
949             if orig_source_version in ql:
950                 continue
951
952             # No source found...
953             okay = 0
954             break
955         return okay
956
957     ################################################################################
958
959     def in_override_p (self, package, component, suite, binary_type, file):
960         """
961         Check if a package already has override entries in the DB
962
963         @type package: string
964         @param package: package name
965
966         @type component: string
967         @param component: database id of the component, as returned by L{database.get_component_id}
968
969         @type suite: int
970         @param suite: database id of the suite, as returned by L{database.get_suite_id}
971
972         @type binary_type: string
973         @param binary_type: type of the package
974
975         @type file: string
976         @param file: filename we check
977
978         @return: the database result. But noone cares anyway.
979
980         """
981         files = self.pkg.files
982
983         if binary_type == "": # must be source
984             file_type = "dsc"
985         else:
986             file_type = binary_type
987
988         # Override suite name; used for example with proposed-updates
989         if self.Cnf.Find("Suite::%s::OverrideSuite" % (suite)) != "":
990             suite = self.Cnf["Suite::%s::OverrideSuite" % (suite)]
991
992         # Avoid <undef> on unknown distributions
993         suite_id = database.get_suite_id(suite)
994         if suite_id == -1:
995             return None
996         component_id = database.get_component_id(component)
997         type_id = database.get_override_type_id(file_type)
998
999         q = self.projectB.query("SELECT s.section, p.priority FROM override o, section s, priority p WHERE package = '%s' AND suite = %s AND component = %s AND type = %s AND o.section = s.id AND o.priority = p.id"
1000                            % (package, suite_id, component_id, type_id))
1001         result = q.getresult()
1002         # If checking for a source package fall back on the binary override type
1003         if file_type == "dsc" and not result:
1004             deb_type_id = database.get_override_type_id("deb")
1005             udeb_type_id = database.get_override_type_id("udeb")
1006             q = self.projectB.query("SELECT s.section, p.priority FROM override o, section s, priority p WHERE package = '%s' AND suite = %s AND component = %s AND (type = %s OR type = %s) AND o.section = s.id AND o.priority = p.id"
1007                                % (package, suite_id, component_id, deb_type_id, udeb_type_id))
1008             result = q.getresult()
1009
1010         # Remember the section and priority so we can check them later if appropriate
1011         if result:
1012             files[file]["override section"] = result[0][0]
1013             files[file]["override priority"] = result[0][1]
1014
1015         return result
1016
1017     ################################################################################
1018
1019     def reject (self, str, prefix="Rejected: "):
1020         """
1021         Add C{str} to reject_message. Adds C{prefix}, by default "Rejected: "
1022
1023         @type str: string
1024         @param str: Reject text
1025
1026         @type prefix: string
1027         @param prefix: Prefix text, default Rejected:
1028
1029         """
1030         if str:
1031             # Unlike other rejects we add new lines first to avoid trailing
1032             # new lines when this message is passed back up to a caller.
1033             if self.reject_message:
1034                 self.reject_message += "\n"
1035             self.reject_message += prefix + str
1036
1037     ################################################################################
1038
1039     def get_anyversion(self, query_result, suite):
1040         """ """
1041         anyversion=None
1042         anysuite = [suite] + self.Cnf.ValueList("Suite::%s::VersionChecks::Enhances" % (suite))
1043         for (v, s) in query_result:
1044             if s in [ x.lower() for x in anysuite ]:
1045                 if not anyversion or apt_pkg.VersionCompare(anyversion, v) <= 0:
1046                     anyversion=v
1047         return anyversion
1048
1049     ################################################################################
1050
1051     def cross_suite_version_check(self, query_result, file, new_version,
1052             sourceful=False):
1053         """
1054         Ensure versions are newer than existing packages in target
1055         suites and that cross-suite version checking rules as
1056         set out in the conf file are satisfied.
1057
1058         """
1059
1060         # Check versions for each target suite
1061         for target_suite in self.pkg.changes["distribution"].keys():
1062             must_be_newer_than = [ i.lower() for i in self.Cnf.ValueList("Suite::%s::VersionChecks::MustBeNewerThan" % (target_suite)) ]
1063             must_be_older_than = [ i.lower() for i in self.Cnf.ValueList("Suite::%s::VersionChecks::MustBeOlderThan" % (target_suite)) ]
1064             # Enforce "must be newer than target suite" even if conffile omits it
1065             if target_suite not in must_be_newer_than:
1066                 must_be_newer_than.append(target_suite)
1067             for entry in query_result:
1068                 existent_version = entry[0]
1069                 suite = entry[1]
1070                 if suite in must_be_newer_than and sourceful and \
1071                    apt_pkg.VersionCompare(new_version, existent_version) < 1:
1072                     self.reject("%s: old version (%s) in %s >= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite))
1073                 if suite in must_be_older_than and \
1074                    apt_pkg.VersionCompare(new_version, existent_version) > -1:
1075                     ch = self.pkg.changes
1076                     cansave = 0
1077                     if ch.get('distribution-version', {}).has_key(suite):
1078                     # we really use the other suite, ignoring the conflicting one ...
1079                         addsuite = ch["distribution-version"][suite]
1080
1081                         add_version = self.get_anyversion(query_result, addsuite)
1082                         target_version = self.get_anyversion(query_result, target_suite)
1083
1084                         if not add_version:
1085                             # not add_version can only happen if we map to a suite
1086                             # that doesn't enhance the suite we're propup'ing from.
1087                             # so "propup-ver x a b c; map a d" is a problem only if
1088                             # d doesn't enhance a.
1089                             #
1090                             # i think we could always propagate in this case, rather
1091                             # than complaining. either way, this isn't a REJECT issue
1092                             #
1093                             # And - we really should complain to the dorks who configured dak
1094                             self.reject("%s is mapped to, but not enhanced by %s - adding anyways" % (suite, addsuite), "Warning: ")
1095                             self.pkg.changes.setdefault("propdistribution", {})
1096                             self.pkg.changes["propdistribution"][addsuite] = 1
1097                             cansave = 1
1098                         elif not target_version:
1099                             # not targets_version is true when the package is NEW
1100                             # we could just stick with the "...old version..." REJECT
1101                             # for this, I think.
1102                             self.reject("Won't propogate NEW packages.")
1103                         elif apt_pkg.VersionCompare(new_version, add_version) < 0:
1104                             # propogation would be redundant. no need to reject though.
1105                             self.reject("ignoring versionconflict: %s: old version (%s) in %s <= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite), "Warning: ")
1106                             cansave = 1
1107                         elif apt_pkg.VersionCompare(new_version, add_version) > 0 and \
1108                              apt_pkg.VersionCompare(add_version, target_version) >= 0:
1109                             # propogate!!
1110                             self.reject("Propogating upload to %s" % (addsuite), "Warning: ")
1111                             self.pkg.changes.setdefault("propdistribution", {})
1112                             self.pkg.changes["propdistribution"][addsuite] = 1
1113                             cansave = 1
1114
1115                     if not cansave:
1116                         self.reject("%s: old version (%s) in %s <= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite))
1117
1118     ################################################################################
1119
1120     def check_binary_against_db(self, file):
1121         """
1122
1123         """
1124         self.reject_message = ""
1125         files = self.pkg.files
1126
1127         # Ensure version is sane
1128         q = self.projectB.query("""
1129 SELECT b.version, su.suite_name FROM binaries b, bin_associations ba, suite su,
1130                                      architecture a
1131  WHERE b.package = '%s' AND (a.arch_string = '%s' OR a.arch_string = 'all')
1132    AND ba.bin = b.id AND ba.suite = su.id AND b.architecture = a.id"""
1133                                 % (files[file]["package"],
1134                                    files[file]["architecture"]))
1135         self.cross_suite_version_check(q.getresult(), file,
1136             files[file]["version"], sourceful=False)
1137
1138         # Check for any existing copies of the file
1139         q = self.projectB.query("""
1140 SELECT b.id FROM binaries b, architecture a
1141  WHERE b.package = '%s' AND b.version = '%s' AND a.arch_string = '%s'
1142    AND a.id = b.architecture"""
1143                                 % (files[file]["package"],
1144                                    files[file]["version"],
1145                                    files[file]["architecture"]))
1146         if q.getresult():
1147             self.reject("%s: can not overwrite existing copy already in the archive." % (file))
1148
1149         return self.reject_message
1150
1151     ################################################################################
1152
1153     def check_source_against_db(self, file):
1154         """
1155         """
1156         self.reject_message = ""
1157         dsc = self.pkg.dsc
1158
1159         # Ensure version is sane
1160         q = self.projectB.query("""
1161 SELECT s.version, su.suite_name FROM source s, src_associations sa, suite su
1162  WHERE s.source = '%s' AND sa.source = s.id AND sa.suite = su.id""" % (dsc.get("source")))
1163         self.cross_suite_version_check(q.getresult(), file, dsc.get("version"),
1164             sourceful=True)
1165
1166         return self.reject_message
1167
1168     ################################################################################
1169
1170
1171     def check_dsc_against_db(self, file):
1172         """
1173
1174         @warning: NB: this function can remove entries from the 'files' index [if
1175          the .orig.tar.gz is a duplicate of the one in the archive]; if
1176          you're iterating over 'files' and call this function as part of
1177          the loop, be sure to add a check to the top of the loop to
1178          ensure you haven't just tried to dereference the deleted entry.
1179
1180         """
1181         self.reject_message = ""
1182         files = self.pkg.files
1183         dsc_files = self.pkg.dsc_files
1184         legacy_source_untouchable = self.pkg.legacy_source_untouchable
1185         self.pkg.orig_tar_gz = None
1186
1187         # Try and find all files mentioned in the .dsc.  This has
1188         # to work harder to cope with the multiple possible
1189         # locations of an .orig.tar.gz.
1190         # The ordering on the select is needed to pick the newest orig
1191         # when it exists in multiple places.
1192         for dsc_file in dsc_files.keys():
1193             found = None
1194             if files.has_key(dsc_file):
1195                 actual_md5 = files[dsc_file]["md5sum"]
1196                 actual_size = int(files[dsc_file]["size"])
1197                 found = "%s in incoming" % (dsc_file)
1198                 # Check the file does not already exist in the archive
1199                 q = self.projectB.query("SELECT f.size, f.md5sum, l.path, f.filename FROM files f, location l WHERE f.filename LIKE '%%%s%%' AND l.id = f.location ORDER BY f.id DESC" % (dsc_file))
1200                 ql = q.getresult()
1201                 # Strip out anything that isn't '%s' or '/%s$'
1202                 for i in ql:
1203                     if i[3] != dsc_file and i[3][-(len(dsc_file)+1):] != '/'+dsc_file:
1204                         ql.remove(i)
1205
1206                 # "[dak] has not broken them.  [dak] has fixed a
1207                 # brokenness.  Your crappy hack exploited a bug in
1208                 # the old dinstall.
1209                 #
1210                 # "(Come on!  I thought it was always obvious that
1211                 # one just doesn't release different files with
1212                 # the same name and version.)"
1213                 #                        -- ajk@ on d-devel@l.d.o
1214
1215                 if ql:
1216                     # Ignore exact matches for .orig.tar.gz
1217                     match = 0
1218                     if dsc_file.endswith(".orig.tar.gz"):
1219                         for i in ql:
1220                             if files.has_key(dsc_file) and \
1221                                int(files[dsc_file]["size"]) == int(i[0]) and \
1222                                files[dsc_file]["md5sum"] == i[1]:
1223                                 self.reject("ignoring %s, since it's already in the archive." % (dsc_file), "Warning: ")
1224                                 del files[dsc_file]
1225                                 self.pkg.orig_tar_gz = i[2] + i[3]
1226                                 match = 1
1227
1228                     if not match:
1229                         self.reject("can not overwrite existing copy of '%s' already in the archive." % (dsc_file))
1230             elif dsc_file.endswith(".orig.tar.gz"):
1231                 # Check in the pool
1232                 q = self.projectB.query("SELECT l.path, f.filename, l.type, f.id, l.id FROM files f, location l WHERE f.filename LIKE '%%%s%%' AND l.id = f.location" % (dsc_file))
1233                 ql = q.getresult()
1234                 # Strip out anything that isn't '%s' or '/%s$'
1235                 for i in ql:
1236                     if i[1] != dsc_file and i[1][-(len(dsc_file)+1):] != '/'+dsc_file:
1237                         ql.remove(i)
1238
1239                 if ql:
1240                     # Unfortunately, we may get more than one match here if,
1241                     # for example, the package was in potato but had an -sa
1242                     # upload in woody.  So we need to choose the right one.
1243
1244                     # default to something sane in case we don't match any or have only one
1245                     x = ql[0]
1246
1247                     if len(ql) > 1:
1248                         for i in ql:
1249                             old_file = i[0] + i[1]
1250                             old_file_fh = utils.open_file(old_file)
1251                             actual_md5 = apt_pkg.md5sum(old_file_fh)
1252                             old_file_fh.close()
1253                             actual_size = os.stat(old_file)[stat.ST_SIZE]
1254                             if actual_md5 == dsc_files[dsc_file]["md5sum"] and actual_size == int(dsc_files[dsc_file]["size"]):
1255                                 x = i
1256                             else:
1257                                 legacy_source_untouchable[i[3]] = ""
1258
1259                     old_file = x[0] + x[1]
1260                     old_file_fh = utils.open_file(old_file)
1261                     actual_md5 = apt_pkg.md5sum(old_file_fh)
1262                     old_file_fh.close()
1263                     actual_size = os.stat(old_file)[stat.ST_SIZE]
1264                     found = old_file
1265                     suite_type = x[2]
1266                     # need this for updating dsc_files in install()
1267                     dsc_files[dsc_file]["files id"] = x[3]
1268                     # See install() in process-accepted...
1269                     self.pkg.orig_tar_id = x[3]
1270                     self.pkg.orig_tar_gz = old_file
1271                     if suite_type == "legacy" or suite_type == "legacy-mixed":
1272                         self.pkg.orig_tar_location = "legacy"
1273                     else:
1274                         self.pkg.orig_tar_location = x[4]
1275                 else:
1276                     # Not there? Check the queue directories...
1277
1278                     in_unchecked = os.path.join(self.Cnf["Dir::Queue::Unchecked"],dsc_file)
1279                     # See process_it() in 'dak process-unchecked' for explanation of this
1280                     # in_unchecked check dropped by ajt 2007-08-28, how did that
1281                     # ever make sense?
1282                     if os.path.exists(in_unchecked) and False:
1283                         return (self.reject_message, in_unchecked)
1284                     else:
1285                         for directory in [ "Accepted", "New", "Byhand", "ProposedUpdates", "OldProposedUpdates" ]:
1286                             in_otherdir = os.path.join(self.Cnf["Dir::Queue::%s" % (directory)],dsc_file)
1287                             if os.path.exists(in_otherdir):
1288                                 in_otherdir_fh = utils.open_file(in_otherdir)
1289                                 actual_md5 = apt_pkg.md5sum(in_otherdir_fh)
1290                                 in_otherdir_fh.close()
1291                                 actual_size = os.stat(in_otherdir)[stat.ST_SIZE]
1292                                 found = in_otherdir
1293                                 self.pkg.orig_tar_gz = in_otherdir
1294
1295                     if not found:
1296                         self.reject("%s refers to %s, but I can't find it in the queue or in the pool." % (file, dsc_file))
1297                         self.pkg.orig_tar_gz = -1
1298                         continue
1299             else:
1300                 self.reject("%s refers to %s, but I can't find it in the queue." % (file, dsc_file))
1301                 continue
1302             if actual_md5 != dsc_files[dsc_file]["md5sum"]:
1303                 self.reject("md5sum for %s doesn't match %s." % (found, file))
1304             if actual_size != int(dsc_files[dsc_file]["size"]):
1305                 self.reject("size for %s doesn't match %s." % (found, file))
1306
1307         return (self.reject_message, None)
1308
1309     def do_query(self, query):
1310         """
1311         Executes a database query. Writes statistics / timing to stderr.
1312
1313         @type query: string
1314         @param query: database query string, passed unmodified
1315
1316         @return: db result
1317
1318         @warning: The query is passed B{unmodified}, so be careful what you use this for.
1319         """
1320         sys.stderr.write("query: \"%s\" ... " % (query))
1321         before = time.time()
1322         r = self.projectB.query(query)
1323         time_diff = time.time()-before
1324         sys.stderr.write("took %.3f seconds.\n" % (time_diff))
1325         return r