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