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 errno
  30 import os
  31 import pg
  32 import stat
  33 import sys
  34 import time
  35 import apt_inst
  36 import apt_pkg
  37 import utils
  38 import commands
  39 import shutil
  40 import textwrap
  41 import tempfile
  42 from types import *
  43
  44 import yaml
  45
  46 from dak_exceptions import *
  47 from changes import *
  48 from regexes import *
  49 from config import Config
  50 from holding import Holding
  51 from dbconn import *
  52 from summarystats import SummaryStats
  53 from utils import parse_changes, check_dsc_files
  54 from textutils import fix_maintainer
  55 from binary import Binary
  56
  57 ###############################################################################
  58
  59 def get_type(f, session):
  60     """
  61     Get the file type of C{f}
  62
  63     @type f: dict
  64     @param f: file entry from Changes object
  65
  66     @type session: SQLA Session
  67     @param session: SQL Alchemy session object
  68
  69     @rtype: string
  70     @return: filetype
  71
  72     """
  73     # Determine the type
  74     if f.has_key("dbtype"):
  75         file_type = f["dbtype"]
  76     elif re_source_ext.match(f["type"]):
  77         file_type = "dsc"
  78     else:
  79         utils.fubar("invalid type (%s) for new.  Dazed, confused and sure as heck not continuing." % (file_type))
  80
  81     # Validate the override type
  82     type_id = get_override_type(file_type, session)
  83     if type_id is None:
  84         utils.fubar("invalid type (%s) for new.  Say wha?" % (file_type))
  85
  86     return file_type
  87
  88 ################################################################################
  89
  90 # Determine what parts in a .changes are NEW
  91
  92 def determine_new(changes, files, warn=1):
  93     """
  94     Determine what parts in a C{changes} file are NEW.
  95
  96     @type changes: Upload.Pkg.changes dict
  97     @param changes: Changes dictionary
  98
  99     @type files: Upload.Pkg.files dict
 100     @param files: Files dictionary
 101
 102     @type warn: bool
 103     @param warn: Warn if overrides are added for (old)stable
 104
 105     @rtype: dict
 106     @return: dictionary of NEW components.
 107
 108     """
 109     new = {}
 110
 111     session = DBConn().session()
 112
 113     # Build up a list of potentially new things
 114     for name, f in files.items():
 115         # Skip byhand elements
 116         if f["type"] == "byhand":
 117             continue
 118         pkg = f["package"]
 119         priority = f["priority"]
 120         section = f["section"]
 121         file_type = get_type(f, session)
 122         component = f["component"]
 123
 124         if file_type == "dsc":
 125             priority = "source"
 126
 127         if not new.has_key(pkg):
 128             new[pkg] = {}
 129             new[pkg]["priority"] = priority
 130             new[pkg]["section"] = section
 131             new[pkg]["type"] = file_type
 132             new[pkg]["component"] = component
 133             new[pkg]["files"] = []
 134         else:
 135             old_type = new[pkg]["type"]
 136             if old_type != file_type:
 137                 # source gets trumped by deb or udeb
 138                 if old_type == "dsc":
 139                     new[pkg]["priority"] = priority
 140                     new[pkg]["section"] = section
 141                     new[pkg]["type"] = file_type
 142                     new[pkg]["component"] = component
 143
 144         new[pkg]["files"].append(name)
 145
 146         if f.has_key("othercomponents"):
 147             new[pkg]["othercomponents"] = f["othercomponents"]
 148
 149     for suite in changes["suite"].keys():
 150         for pkg in new.keys():
 151             ql = get_override(pkg, suite, new[pkg]["component"], new[pkg]["type"], session)
 152             if len(ql) > 0:
 153                 for file_entry in new[pkg]["files"]:
 154                     if files[file_entry].has_key("new"):
 155                         del files[file_entry]["new"]
 156                 del new[pkg]
 157
 158     if warn:
 159         for s in ['stable', 'oldstable']:
 160             if changes["suite"].has_key(s):
 161                 print "WARNING: overrides will be added for %s!" % s
 162         for pkg in new.keys():
 163             if new[pkg].has_key("othercomponents"):
 164                 print "WARNING: %s already present in %s distribution." % (pkg, new[pkg]["othercomponents"])
 165
 166     session.close()
 167
 168     return new
 169
 170 ################################################################################
 171
 172 def check_valid(new):
 173     """
 174     Check if section and priority for NEW packages exist in database.
 175     Additionally does sanity checks:
 176       - debian-installer packages have to be udeb (or source)
 177       - non debian-installer packages can not be udeb
 178       - source priority can only be assigned to dsc file types
 179
 180     @type new: dict
 181     @param new: Dict of new packages with their section, priority and type.
 182
 183     """
 184     for pkg in new.keys():
 185         section_name = new[pkg]["section"]
 186         priority_name = new[pkg]["priority"]
 187         file_type = new[pkg]["type"]
 188
 189         section = get_section(section_name)
 190         if section is None:
 191             new[pkg]["section id"] = -1
 192         else:
 193             new[pkg]["section id"] = section.section_id
 194
 195         priority = get_priority(priority_name)
 196         if priority is None:
 197             new[pkg]["priority id"] = -1
 198         else:
 199             new[pkg]["priority id"] = priority.priority_id
 200
 201         # Sanity checks
 202         di = section_name.find("debian-installer") != -1
 203
 204         # If d-i, we must be udeb and vice-versa
 205         if     (di and file_type not in ("udeb", "dsc")) or \
 206            (not di and file_type == "udeb"):
 207             new[pkg]["section id"] = -1
 208
 209         # If dsc we need to be source and vice-versa
 210         if (priority == "source" and file_type != "dsc") or \
 211            (priority != "source" and file_type == "dsc"):
 212             new[pkg]["priority id"] = -1
 213
 214 ###############################################################################
 215
 216 def check_status(files):
 217     new = byhand = 0
 218     for f in files.keys():
 219         if files[f]["type"] == "byhand":
 220             byhand = 1
 221         elif files[f].has_key("new"):
 222             new = 1
 223     return (new, byhand)
 224
 225 ###############################################################################
 226
 227 # Used by Upload.check_timestamps
 228 class TarTime(object):
 229     def __init__(self, future_cutoff, past_cutoff):
 230         self.reset()
 231         self.future_cutoff = future_cutoff
 232         self.past_cutoff = past_cutoff
 233
 234     def reset(self):
 235         self.future_files = {}
 236         self.ancient_files = {}
 237
 238     def callback(self, Kind, Name, Link, Mode, UID, GID, Size, MTime, Major, Minor):
 239         if MTime > self.future_cutoff:
 240             self.future_files[Name] = MTime
 241         if MTime < self.past_cutoff:
 242             self.ancient_files[Name] = MTime
 243
 244 ###############################################################################
 245
 246 class Upload(object):
 247     """
 248     Everything that has to do with an upload processed.
 249
 250     """
 251     def __init__(self):
 252         self.logger = None
 253         self.pkg = Changes()
 254         self.reset()
 255
 256     ###########################################################################
 257
 258     def reset (self):
 259         """ Reset a number of internal variables."""
 260
 261         # Initialize the substitution template map
 262         cnf = Config()
 263         self.Subst = {}
 264         self.Subst["__ADMIN_ADDRESS__"] = cnf["Dinstall::MyAdminAddress"]
 265         self.Subst["__BUG_SERVER__"] = cnf["Dinstall::BugServer"]
 266         self.Subst["__DISTRO__"] = cnf["Dinstall::MyDistribution"]
 267         self.Subst["__DAK_ADDRESS__"] = cnf["Dinstall::MyEmailAddress"]
 268
 269         self.rejects = []
 270         self.warnings = []
 271         self.notes = []
 272
 273         self.pkg.reset()
 274
 275     def package_info(self):
 276         msg = ''
 277
 278         if len(self.rejects) > 0:
 279             msg += "Reject Reasons:\n"
 280             msg += "\n".join(self.rejects)
 281
 282         if len(self.warnings) > 0:
 283             msg += "Warnings:\n"
 284             msg += "\n".join(self.warnings)
 285
 286         if len(self.notes) > 0:
 287             msg += "Notes:\n"
 288             msg += "\n".join(self.notes)
 289
 290         return msg
 291
 292     ###########################################################################
 293     def update_subst(self):
 294         """ Set up the per-package template substitution mappings """
 295
 296         cnf = Config()
 297
 298         # If 'dak process-unchecked' crashed out in the right place, architecture may still be a string.
 299         if not self.pkg.changes.has_key("architecture") or not \
 300            isinstance(self.pkg.changes["architecture"], DictType):
 301             self.pkg.changes["architecture"] = { "Unknown" : "" }
 302
 303         # and maintainer2047 may not exist.
 304         if not self.pkg.changes.has_key("maintainer2047"):
 305             self.pkg.changes["maintainer2047"] = cnf["Dinstall::MyEmailAddress"]
 306
 307         self.Subst["__ARCHITECTURE__"] = " ".join(self.pkg.changes["architecture"].keys())
 308         self.Subst["__CHANGES_FILENAME__"] = os.path.basename(self.pkg.changes_file)
 309         self.Subst["__FILE_CONTENTS__"] = self.pkg.changes.get("filecontents", "")
 310
 311         # For source uploads the Changed-By field wins; otherwise Maintainer wins.
 312         if self.pkg.changes["architecture"].has_key("source") and \
 313            self.pkg.changes["changedby822"] != "" and \
 314            (self.pkg.changes["changedby822"] != self.pkg.changes["maintainer822"]):
 315
 316             self.Subst["__MAINTAINER_FROM__"] = self.pkg.changes["changedby2047"]
 317             self.Subst["__MAINTAINER_TO__"] = "%s, %s" % (self.pkg.changes["changedby2047"], self.pkg.changes["maintainer2047"])
 318             self.Subst["__MAINTAINER__"] = self.pkg.changes.get("changed-by", "Unknown")
 319         else:
 320             self.Subst["__MAINTAINER_FROM__"] = self.pkg.changes["maintainer2047"]
 321             self.Subst["__MAINTAINER_TO__"] = self.pkg.changes["maintainer2047"]
 322             self.Subst["__MAINTAINER__"] = self.pkg.changes.get("maintainer", "Unknown")
 323
 324         if "sponsoremail" in self.pkg.changes:
 325             self.Subst["__MAINTAINER_TO__"] += ", %s" % self.pkg.changes["sponsoremail"]
 326
 327         if cnf.has_key("Dinstall::TrackingServer") and self.pkg.changes.has_key("source"):
 328             self.Subst["__MAINTAINER_TO__"] += "\nBcc: %s@%s" % (self.pkg.changes["source"], cnf["Dinstall::TrackingServer"])
 329
 330         # Apply any global override of the Maintainer field
 331         if cnf.get("Dinstall::OverrideMaintainer"):
 332             self.Subst["__MAINTAINER_TO__"] = cnf["Dinstall::OverrideMaintainer"]
 333             self.Subst["__MAINTAINER_FROM__"] = cnf["Dinstall::OverrideMaintainer"]
 334
 335         self.Subst["__REJECT_MESSAGE__"] = self.package_info()
 336         self.Subst["__SOURCE__"] = self.pkg.changes.get("source", "Unknown")
 337         self.Subst["__VERSION__"] = self.pkg.changes.get("version", "Unknown")
 338
 339     ###########################################################################
 340     def load_changes(self, filename):
 341         """
 342         @rtype: boolean
 343         @rvalue: whether the changes file was valid or not.  We may want to
 344                  reject even if this is True (see what gets put in self.rejects).
 345                  This is simply to prevent us even trying things later which will
 346                  fail because we couldn't properly parse the file.
 347         """
 348         Cnf = Config()
 349         self.pkg.changes_file = filename
 350
 351         # Parse the .changes field into a dictionary
 352         try:
 353             self.pkg.changes.update(parse_changes(filename))
 354         except CantOpenError:
 355             self.rejects.append("%s: can't read file." % (filename))
 356             return False
 357         except ParseChangesError, line:
 358             self.rejects.append("%s: parse error, can't grok: %s." % (filename, line))
 359             return False
 360         except ChangesUnicodeError:
 361             self.rejects.append("%s: changes file not proper utf-8" % (filename))
 362             return False
 363
 364         # Parse the Files field from the .changes into another dictionary
 365         try:
 366             self.pkg.files.update(utils.build_file_list(self.pkg.changes))
 367         except ParseChangesError, line:
 368             self.rejects.append("%s: parse error, can't grok: %s." % (filename, line))
 369             return False
 370         except UnknownFormatError, format:
 371             self.rejects.append("%s: unknown format '%s'." % (filename, format))
 372             return False
 373
 374         # Check for mandatory fields
 375         for i in ("distribution", "source", "binary", "architecture",
 376                   "version", "maintainer", "files", "changes", "description"):
 377             if not self.pkg.changes.has_key(i):
 378                 # Avoid undefined errors later
 379                 self.rejects.append("%s: Missing mandatory field `%s'." % (filename, i))
 380                 return False
 381
 382         # Strip a source version in brackets from the source field
 383         if re_strip_srcver.search(self.pkg.changes["source"]):
 384             self.pkg.changes["source"] = re_strip_srcver.sub('', self.pkg.changes["source"])
 385
 386         # Ensure the source field is a valid package name.
 387         if not re_valid_pkg_name.match(self.pkg.changes["source"]):
 388             self.rejects.append("%s: invalid source name '%s'." % (filename, self.pkg.changes["source"]))
 389
 390         # Split multi-value fields into a lower-level dictionary
 391         for i in ("architecture", "distribution", "binary", "closes"):
 392             o = self.pkg.changes.get(i, "")
 393             if o != "":
 394                 del self.pkg.changes[i]
 395
 396             self.pkg.changes[i] = {}
 397
 398             for j in o.split():
 399                 self.pkg.changes[i][j] = 1
 400
 401         # Fix the Maintainer: field to be RFC822/2047 compatible
 402         try:
 403             (self.pkg.changes["maintainer822"],
 404              self.pkg.changes["maintainer2047"],
 405              self.pkg.changes["maintainername"],
 406              self.pkg.changes["maintaineremail"]) = \
 407                    fix_maintainer (self.pkg.changes["maintainer"])
 408         except ParseMaintError, msg:
 409             self.rejects.append("%s: Maintainer field ('%s') failed to parse: %s" \
 410                    % (filename, changes["maintainer"], msg))
 411
 412         # ...likewise for the Changed-By: field if it exists.
 413         try:
 414             (self.pkg.changes["changedby822"],
 415              self.pkg.changes["changedby2047"],
 416              self.pkg.changes["changedbyname"],
 417              self.pkg.changes["changedbyemail"]) = \
 418                    fix_maintainer (self.pkg.changes.get("changed-by", ""))
 419         except ParseMaintError, msg:
 420             self.pkg.changes["changedby822"] = ""
 421             self.pkg.changes["changedby2047"] = ""
 422             self.pkg.changes["changedbyname"] = ""
 423             self.pkg.changes["changedbyemail"] = ""
 424
 425             self.rejects.append("%s: Changed-By field ('%s') failed to parse: %s" \
 426                    % (filename, changes["changed-by"], msg))
 427
 428         # Ensure all the values in Closes: are numbers
 429         if self.pkg.changes.has_key("closes"):
 430             for i in self.pkg.changes["closes"].keys():
 431                 if re_isanum.match (i) == None:
 432                     self.rejects.append(("%s: `%s' from Closes field isn't a number." % (filename, i)))
 433
 434         # chopversion = no epoch; chopversion2 = no epoch and no revision (e.g. for .orig.tar.gz comparison)
 435         self.pkg.changes["chopversion"] = re_no_epoch.sub('', self.pkg.changes["version"])
 436         self.pkg.changes["chopversion2"] = re_no_revision.sub('', self.pkg.changes["chopversion"])
 437
 438         # Check there isn't already a changes file of the same name in one
 439         # of the queue directories.
 440         base_filename = os.path.basename(filename)
 441         for d in [ "Accepted", "Byhand", "Done", "New", "ProposedUpdates", "OldProposedUpdates" ]:
 442             if os.path.exists(os.path.join(Cnf["Dir::Queue::%s" % (d) ], base_filename)):
 443                 self.rejects.append("%s: a file with this name already exists in the %s directory." % (base_filename, d))
 444
 445         # Check the .changes is non-empty
 446         if not self.pkg.files:
 447             self.rejects.append("%s: nothing to do (Files field is empty)." % (base_filename))
 448             return False
 449
 450         # Changes was syntactically valid even if we'll reject
 451         return True
 452
 453     ###########################################################################
 454
 455     def check_distributions(self):
 456         "Check and map the Distribution field"
 457
 458         Cnf = Config()
 459
 460         # Handle suite mappings
 461         for m in Cnf.ValueList("SuiteMappings"):
 462             args = m.split()
 463             mtype = args[0]
 464             if mtype == "map" or mtype == "silent-map":
 465                 (source, dest) = args[1:3]
 466                 if self.pkg.changes["distribution"].has_key(source):
 467                     del self.pkg.changes["distribution"][source]
 468                     self.pkg.changes["distribution"][dest] = 1
 469                     if mtype != "silent-map":
 470                         self.notes.append("Mapping %s to %s." % (source, dest))
 471                 if self.pkg.changes.has_key("distribution-version"):
 472                     if self.pkg.changes["distribution-version"].has_key(source):
 473                         self.pkg.changes["distribution-version"][source]=dest
 474             elif mtype == "map-unreleased":
 475                 (source, dest) = args[1:3]
 476                 if self.pkg.changes["distribution"].has_key(source):
 477                     for arch in self.pkg.changes["architecture"].keys():
 478                         if arch not in [ a.arch_string for a in get_suite_architectures(source) ]:
 479                             self.notes.append("Mapping %s to %s for unreleased architecture %s." % (source, dest, arch))
 480                             del self.pkg.changes["distribution"][source]
 481                             self.pkg.changes["distribution"][dest] = 1
 482                             break
 483             elif mtype == "ignore":
 484                 suite = args[1]
 485                 if self.pkg.changes["distribution"].has_key(suite):
 486                     del self.pkg.changes["distribution"][suite]
 487                     self.warnings.append("Ignoring %s as a target suite." % (suite))
 488             elif mtype == "reject":
 489                 suite = args[1]
 490                 if self.pkg.changes["distribution"].has_key(suite):
 491                     self.rejects.append("Uploads to %s are not accepted." % (suite))
 492             elif mtype == "propup-version":
 493                 # give these as "uploaded-to(non-mapped) suites-to-add-when-upload-obsoletes"
 494                 #
 495                 # changes["distribution-version"] looks like: {'testing': 'testing-proposed-updates'}
 496                 if self.pkg.changes["distribution"].has_key(args[1]):
 497                     self.pkg.changes.setdefault("distribution-version", {})
 498                     for suite in args[2:]:
 499                         self.pkg.changes["distribution-version"][suite] = suite
 500
 501         # Ensure there is (still) a target distribution
 502         if len(self.pkg.changes["distribution"].keys()) < 1:
 503             self.rejects.append("No valid distribution remaining.")
 504
 505         # Ensure target distributions exist
 506         for suite in self.pkg.changes["distribution"].keys():
 507             if not Cnf.has_key("Suite::%s" % (suite)):
 508                 self.rejects.append("Unknown distribution `%s'." % (suite))
 509
 510     ###########################################################################
 511
 512     def binary_file_checks(self, f, session):
 513         cnf = Config()
 514         entry = self.pkg.files[f]
 515
 516         # Extract package control information
 517         deb_file = utils.open_file(f)
 518         try:
 519             control = apt_pkg.ParseSection(apt_inst.debExtractControl(deb_file))
 520         except:
 521             self.rejects.append("%s: debExtractControl() raised %s." % (f, sys.exc_type))
 522             deb_file.close()
 523             # Can't continue, none of the checks on control would work.
 524             return
 525
 526         # Check for mandantory "Description:"
 527         deb_file.seek(0)
 528         try:
 529             apt_pkg.ParseSection(apt_inst.debExtractControl(deb_file))["Description"] + '\n'
 530         except:
 531             self.rejects.append("%s: Missing Description in binary package" % (f))
 532             return
 533
 534         deb_file.close()
 535
 536         # Check for mandatory fields
 537         for field in [ "Package", "Architecture", "Version" ]:
 538             if control.Find(field) == None:
 539                 # Can't continue
 540                 self.rejects.append("%s: No %s field in control." % (f, field))
 541                 return
 542
 543         # Ensure the package name matches the one give in the .changes
 544         if not self.pkg.changes["binary"].has_key(control.Find("Package", "")):
 545             self.rejects.append("%s: control file lists name as `%s', which isn't in changes file." % (f, control.Find("Package", "")))
 546
 547         # Validate the package field
 548         package = control.Find("Package")
 549         if not re_valid_pkg_name.match(package):
 550             self.rejects.append("%s: invalid package name '%s'." % (f, package))
 551
 552         # Validate the version field
 553         version = control.Find("Version")
 554         if not re_valid_version.match(version):
 555             self.rejects.append("%s: invalid version number '%s'." % (f, version))
 556
 557         # Ensure the architecture of the .deb is one we know about.
 558         default_suite = cnf.get("Dinstall::DefaultSuite", "Unstable")
 559         architecture = control.Find("Architecture")
 560         upload_suite = self.pkg.changes["distribution"].keys()[0]
 561
 562         if      architecture not in [a.arch_string for a in get_suite_architectures(default_suite, session)] \
 563             and architecture not in [a.arch_string for a in get_suite_architectures(upload_suite, session)]:
 564             self.rejects.append("Unknown architecture '%s'." % (architecture))
 565
 566         # Ensure the architecture of the .deb is one of the ones
 567         # listed in the .changes.
 568         if not self.pkg.changes["architecture"].has_key(architecture):
 569             self.rejects.append("%s: control file lists arch as `%s', which isn't in changes file." % (f, architecture))
 570
 571         # Sanity-check the Depends field
 572         depends = control.Find("Depends")
 573         if depends == '':
 574             self.rejects.append("%s: Depends field is empty." % (f))
 575
 576         # Sanity-check the Provides field
 577         provides = control.Find("Provides")
 578         if provides:
 579             provide = re_spacestrip.sub('', provides)
 580             if provide == '':
 581                 self.rejects.append("%s: Provides field is empty." % (f))
 582             prov_list = provide.split(",")
 583             for prov in prov_list:
 584                 if not re_valid_pkg_name.match(prov):
 585                     self.rejects.append("%s: Invalid Provides field content %s." % (f, prov))
 586
 587         # Check the section & priority match those given in the .changes (non-fatal)
 588         if     control.Find("Section") and entry["section"] != "" \
 589            and entry["section"] != control.Find("Section"):
 590             self.warnings.append("%s control file lists section as `%s', but changes file has `%s'." % \
 591                                 (f, control.Find("Section", ""), entry["section"]))
 592         if control.Find("Priority") and entry["priority"] != "" \
 593            and entry["priority"] != control.Find("Priority"):
 594             self.warnings.append("%s control file lists priority as `%s', but changes file has `%s'." % \
 595                                 (f, control.Find("Priority", ""), entry["priority"]))
 596
 597         entry["package"] = package
 598         entry["architecture"] = architecture
 599         entry["version"] = version
 600         entry["maintainer"] = control.Find("Maintainer", "")
 601
 602         if f.endswith(".udeb"):
 603             self.pkg.files[f]["dbtype"] = "udeb"
 604         elif f.endswith(".deb"):
 605             self.pkg.files[f]["dbtype"] = "deb"
 606         else:
 607             self.rejects.append("%s is neither a .deb or a .udeb." % (f))
 608
 609         entry["source"] = control.Find("Source", entry["package"])
 610
 611         # Get the source version
 612         source = entry["source"]
 613         source_version = ""
 614
 615         if source.find("(") != -1:
 616             m = re_extract_src_version.match(source)
 617             source = m.group(1)
 618             source_version = m.group(2)
 619
 620         if not source_version:
 621             source_version = self.pkg.files[f]["version"]
 622
 623         entry["source package"] = source
 624         entry["source version"] = source_version
 625
 626         # Ensure the filename matches the contents of the .deb
 627         m = re_isadeb.match(f)
 628
 629         #  package name
 630         file_package = m.group(1)
 631         if entry["package"] != file_package:
 632             self.rejects.append("%s: package part of filename (%s) does not match package name in the %s (%s)." % \
 633                                 (f, file_package, entry["dbtype"], entry["package"]))
 634         epochless_version = re_no_epoch.sub('', control.Find("Version"))
 635
 636         #  version
 637         file_version = m.group(2)
 638         if epochless_version != file_version:
 639             self.rejects.append("%s: version part of filename (%s) does not match package version in the %s (%s)." % \
 640                                 (f, file_version, entry["dbtype"], epochless_version))
 641
 642         #  architecture
 643         file_architecture = m.group(3)
 644         if entry["architecture"] != file_architecture:
 645             self.rejects.append("%s: architecture part of filename (%s) does not match package architecture in the %s (%s)." % \
 646                                 (f, file_architecture, entry["dbtype"], entry["architecture"]))
 647
 648         # Check for existent source
 649         source_version = entry["source version"]
 650         source_package = entry["source package"]
 651         if self.pkg.changes["architecture"].has_key("source"):
 652             if source_version != self.pkg.changes["version"]:
 653                 self.rejects.append("source version (%s) for %s doesn't match changes version %s." % \
 654                                     (source_version, f, self.pkg.changes["version"]))
 655         else:
 656             # Check in the SQL database
 657             if not source_exists(source_package, source_version, self.pkg.changes["distribution"].keys(), session):
 658                 # Check in one of the other directories
 659                 source_epochless_version = re_no_epoch.sub('', source_version)
 660                 dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version)
 661                 if os.path.exists(os.path.join(cnf["Dir::Queue::Byhand"], dsc_filename)):
 662                     entry["byhand"] = 1
 663                 elif os.path.exists(os.path.join(cnf["Dir::Queue::New"], dsc_filename)):
 664                     entry["new"] = 1
 665                 else:
 666                     dsc_file_exists = False
 667                     for myq in ["Accepted", "Embargoed", "Unembargoed", "ProposedUpdates", "OldProposedUpdates"]:
 668                         if cnf.has_key("Dir::Queue::%s" % (myq)):
 669                             if os.path.exists(os.path.join(cnf["Dir::Queue::" + myq], dsc_filename)):
 670                                 dsc_file_exists = True
 671                                 break
 672
 673                     if not dsc_file_exists:
 674                         self.rejects.append("no source found for %s %s (%s)." % (source_package, source_version, f))
 675
 676         # Check the version and for file overwrites
 677         self.check_binary_against_db(f, session)
 678
 679         # Temporarily disable contents generation until we change the table storage layout
 680         #b = Binary(f)
 681         #b.scan_package()
 682         #if len(b.rejects) > 0:
 683         #    for j in b.rejects:
 684         #        self.rejects.append(j)
 685
 686     def source_file_checks(self, f, session):
 687         entry = self.pkg.files[f]
 688
 689         m = re_issource.match(f)
 690         if not m:
 691             return
 692
 693         entry["package"] = m.group(1)
 694         entry["version"] = m.group(2)
 695         entry["type"] = m.group(3)
 696
 697         # Ensure the source package name matches the Source filed in the .changes
 698         if self.pkg.changes["source"] != entry["package"]:
 699             self.rejects.append("%s: changes file doesn't say %s for Source" % (f, entry["package"]))
 700
 701         # Ensure the source version matches the version in the .changes file
 702         if re_is_orig_source.match(f):
 703             changes_version = self.pkg.changes["chopversion2"]
 704         else:
 705             changes_version = self.pkg.changes["chopversion"]
 706
 707         if changes_version != entry["version"]:
 708             self.rejects.append("%s: should be %s according to changes file." % (f, changes_version))
 709
 710         # Ensure the .changes lists source in the Architecture field
 711         if not self.pkg.changes["architecture"].has_key("source"):
 712             self.rejects.append("%s: changes file doesn't list `source' in Architecture field." % (f))
 713
 714         # Check the signature of a .dsc file
 715         if entry["type"] == "dsc":
 716             # check_signature returns either:
 717             #  (None, [list, of, rejects]) or (signature, [])
 718             (self.pkg.dsc["fingerprint"], rejects) = utils.check_signature(f)
 719             for j in rejects:
 720                 self.rejects.append(j)
 721
 722         entry["architecture"] = "source"
 723
 724     def per_suite_file_checks(self, f, suite, session):
 725         cnf = Config()
 726         entry = self.pkg.files[f]
 727         archive = utils.where_am_i()
 728
 729         # Skip byhand
 730         if entry.has_key("byhand"):
 731             return
 732
 733         # Check we have fields we need to do these checks
 734         oktogo = True
 735         for m in ['component', 'package', 'priority', 'size', 'md5sum']:
 736             if not entry.has_key(m):
 737                 self.rejects.append("file '%s' does not have field %s set" % (f, m))
 738                 oktogo = False
 739
 740         if not oktogo:
 741             return
 742
 743         # Handle component mappings
 744         for m in cnf.ValueList("ComponentMappings"):
 745             (source, dest) = m.split()
 746             if entry["component"] == source:
 747                 entry["original component"] = source
 748                 entry["component"] = dest
 749
 750         # Ensure the component is valid for the target suite
 751         if cnf.has_key("Suite:%s::Components" % (suite)) and \
 752            entry["component"] not in cnf.ValueList("Suite::%s::Components" % (suite)):
 753             self.rejects.append("unknown component `%s' for suite `%s'." % (entry["component"], suite))
 754             return
 755
 756         # Validate the component
 757         if not get_component(entry["component"], session):
 758             self.rejects.append("file '%s' has unknown component '%s'." % (f, component))
 759             return
 760
 761         # See if the package is NEW
 762         if not self.in_override_p(entry["package"], entry["component"], suite, entry.get("dbtype",""), f, session):
 763             entry["new"] = 1
 764
 765         # Validate the priority
 766         if entry["priority"].find('/') != -1:
 767             self.rejects.append("file '%s' has invalid priority '%s' [contains '/']." % (f, entry["priority"]))
 768
 769         # Determine the location
 770         location = cnf["Dir::Pool"]
 771         l = get_location(location, entry["component"], archive, session)
 772         if l is None:
 773             self.rejects.append("[INTERNAL ERROR] couldn't determine location (Component: %s, Archive: %s)" % (component, archive))
 774             entry["location id"] = -1
 775         else:
 776             entry["location id"] = l.location_id
 777
 778         # Check the md5sum & size against existing files (if any)
 779         entry["pool name"] = utils.poolify(self.pkg.changes["source"], entry["component"])
 780
 781         found, poolfile = check_poolfile(os.path.join(entry["pool name"], f),
 782                                          entry["size"], entry["md5sum"], entry["location id"])
 783
 784         if found is None:
 785             self.rejects.append("INTERNAL ERROR, get_files_id() returned multiple matches for %s." % (f))
 786         elif found is False and poolfile is not None:
 787             self.rejects.append("md5sum and/or size mismatch on existing copy of %s." % (f))
 788         else:
 789             if poolfile is None:
 790                 entry["files id"] = None
 791             else:
 792                 entry["files id"] = poolfile.file_id
 793
 794         # Check for packages that have moved from one component to another
 795         entry['suite'] = suite
 796         res = get_binary_components(self.pkg.files[f]['package'], suite, entry["architecture"], session)
 797         if res.rowcount > 0:
 798             entry["othercomponents"] = res.fetchone()[0]
 799
 800     def check_files(self, action=True):
 801         archive = utils.where_am_i()
 802         file_keys = self.pkg.files.keys()
 803         holding = Holding()
 804         cnf = Config()
 805
 806         # XXX: As far as I can tell, this can no longer happen - see
 807         #      comments by AJ in old revisions - mhy
 808         # if reprocess is 2 we've already done this and we're checking
 809         # things again for the new .orig.tar.gz.
 810         # [Yes, I'm fully aware of how disgusting this is]
 811         if action and self.reprocess < 2:
 812             cwd = os.getcwd()
 813             os.chdir(self.pkg.directory)
 814             for f in file_keys:
 815                 ret = holding.copy_to_holding(f)
 816                 if ret is not None:
 817                     # XXX: Should we bail out here or try and continue?
 818                     self.rejects.append(ret)
 819
 820             os.chdir(cwd)
 821
 822         # Check there isn't already a .changes or .dak file of the same name in
 823         # the proposed-updates "CopyChanges" or "CopyDotDak" storage directories.
 824         # [NB: this check must be done post-suite mapping]
 825         base_filename = os.path.basename(self.pkg.changes_file)
 826         dot_dak_filename = base_filename[:-8] + ".dak"
 827
 828         for suite in self.pkg.changes["distribution"].keys():
 829             copychanges = "Suite::%s::CopyChanges" % (suite)
 830             if cnf.has_key(copychanges) and \
 831                    os.path.exists(os.path.join(cnf[copychanges], base_filename)):
 832                 self.rejects.append("%s: a file with this name already exists in %s" \
 833                            % (base_filename, cnf[copychanges]))
 834
 835             copy_dot_dak = "Suite::%s::CopyDotDak" % (suite)
 836             if cnf.has_key(copy_dot_dak) and \
 837                    os.path.exists(os.path.join(cnf[copy_dot_dak], dot_dak_filename)):
 838                 self.rejects.append("%s: a file with this name already exists in %s" \
 839                            % (dot_dak_filename, Cnf[copy_dot_dak]))
 840
 841         self.reprocess = 0
 842         has_binaries = False
 843         has_source = False
 844
 845         session = DBConn().session()
 846
 847         for f, entry in self.pkg.files.items():
 848             # Ensure the file does not already exist in one of the accepted directories
 849             for d in [ "Accepted", "Byhand", "New", "ProposedUpdates", "OldProposedUpdates", "Embargoed", "Unembargoed" ]:
 850                 if not cnf.has_key("Dir::Queue::%s" % (d)): continue
 851                 if os.path.exists(cnf["Dir::Queue::%s" % (d) ] + '/' + f):
 852                     self.rejects.append("%s file already exists in the %s directory." % (f, d))
 853
 854             if not re_taint_free.match(f):
 855                 self.rejects.append("!!WARNING!! tainted filename: '%s'." % (f))
 856
 857             # Check the file is readable
 858             if os.access(f, os.R_OK) == 0:
 859                 # When running in -n, copy_to_holding() won't have
 860                 # generated the reject_message, so we need to.
 861                 if action:
 862                     if os.path.exists(f):
 863                         self.rejects.append("Can't read `%s'. [permission denied]" % (f))
 864                     else:
 865                         self.rejects.append("Can't read `%s'. [file not found]" % (f))
 866                 entry["type"] = "unreadable"
 867                 continue
 868
 869             # If it's byhand skip remaining checks
 870             if entry["section"] == "byhand" or entry["section"][:4] == "raw-":
 871                 entry["byhand"] = 1
 872                 entry["type"] = "byhand"
 873
 874             # Checks for a binary package...
 875             elif re_isadeb.match(f):
 876                 has_binaries = True
 877                 entry["type"] = "deb"
 878
 879                 # This routine appends to self.rejects/warnings as appropriate
 880                 self.binary_file_checks(f, session)
 881
 882             # Checks for a source package...
 883             elif re_issource.match(f):
 884                 has_source = True
 885
 886                 # This routine appends to self.rejects/warnings as appropriate
 887                 self.source_file_checks(f, session)
 888
 889             # Not a binary or source package?  Assume byhand...
 890             else:
 891                 entry["byhand"] = 1
 892                 entry["type"] = "byhand"
 893
 894             # Per-suite file checks
 895             entry["oldfiles"] = {}
 896             for suite in self.pkg.changes["distribution"].keys():
 897                 self.per_suite_file_checks(f, suite, session)
 898
 899         session.close()
 900
 901         # If the .changes file says it has source, it must have source.
 902         if self.pkg.changes["architecture"].has_key("source"):
 903             if not has_source:
 904                 self.rejects.append("no source found and Architecture line in changes mention source.")
 905
 906             if not has_binaries and cnf.FindB("Dinstall::Reject::NoSourceOnly"):
 907                 self.rejects.append("source only uploads are not supported.")
 908
 909     ###########################################################################
 910     def check_dsc(self, action=True, session=None):
 911         """Returns bool indicating whether or not the source changes are valid"""
 912         # Ensure there is source to check
 913         if not self.pkg.changes["architecture"].has_key("source"):
 914             return True
 915
 916         # Find the .dsc
 917         dsc_filename = None
 918         for f, entry in self.pkg.files.items():
 919             if entry["type"] == "dsc":
 920                 if dsc_filename:
 921                     self.rejects.append("can not process a .changes file with multiple .dsc's.")
 922                     return False
 923                 else:
 924                     dsc_filename = f
 925
 926         # If there isn't one, we have nothing to do. (We have reject()ed the upload already)
 927         if not dsc_filename:
 928             self.rejects.append("source uploads must contain a dsc file")
 929             return False
 930
 931         # Parse the .dsc file
 932         try:
 933             self.pkg.dsc.update(utils.parse_changes(dsc_filename, signing_rules=1))
 934         except CantOpenError:
 935             # if not -n copy_to_holding() will have done this for us...
 936             if not action:
 937                 self.rejects.append("%s: can't read file." % (dsc_filename))
 938         except ParseChangesError, line:
 939             self.rejects.append("%s: parse error, can't grok: %s." % (dsc_filename, line))
 940         except InvalidDscError, line:
 941             self.rejects.append("%s: syntax error on line %s." % (dsc_filename, line))
 942         except ChangesUnicodeError:
 943             self.rejects.append("%s: dsc file not proper utf-8." % (dsc_filename))
 944
 945         # Build up the file list of files mentioned by the .dsc
 946         try:
 947             self.pkg.dsc_files.update(utils.build_file_list(self.pkg.dsc, is_a_dsc=1))
 948         except NoFilesFieldError:
 949             self.rejects.append("%s: no Files: field." % (dsc_filename))
 950             return False
 951         except UnknownFormatError, format:
 952             self.rejects.append("%s: unknown format '%s'." % (dsc_filename, format))
 953             return False
 954         except ParseChangesError, line:
 955             self.rejects.append("%s: parse error, can't grok: %s." % (dsc_filename, line))
 956             return False
 957
 958         # Enforce mandatory fields
 959         for i in ("format", "source", "version", "binary", "maintainer", "architecture", "files"):
 960             if not self.pkg.dsc.has_key(i):
 961                 self.rejects.append("%s: missing mandatory field `%s'." % (dsc_filename, i))
 962                 return False
 963
 964         # Validate the source and version fields
 965         if not re_valid_pkg_name.match(self.pkg.dsc["source"]):
 966             self.rejects.append("%s: invalid source name '%s'." % (dsc_filename, self.pkg.dsc["source"]))
 967         if not re_valid_version.match(self.pkg.dsc["version"]):
 968             self.rejects.append("%s: invalid version number '%s'." % (dsc_filename, self.pkg.dsc["version"]))
 969
 970         # Only a limited list of source formats are allowed in each suite
 971         for dist in self.pkg.changes["distribution"].keys():
 972             allowed = [ x.format_name for x in get_suite_src_formats(dist, session) ]
 973             if self.pkg.dsc["format"] not in allowed:
 974                 self.rejects.append("%s: source format '%s' not allowed in %s (accepted: %s) " % (dsc_filename, self.pkg.dsc["format"], dist, ", ".join(allowed)))
 975
 976         # Validate the Maintainer field
 977         try:
 978             # We ignore the return value
 979             fix_maintainer(self.pkg.dsc["maintainer"])
 980         except ParseMaintError, msg:
 981             self.rejects.append("%s: Maintainer field ('%s') failed to parse: %s" \
 982                                  % (dsc_filename, self.pkg.dsc["maintainer"], msg))
 983
 984         # Validate the build-depends field(s)
 985         for field_name in [ "build-depends", "build-depends-indep" ]:
 986             field = self.pkg.dsc.get(field_name)
 987             if field:
 988                 # Have apt try to parse them...
 989                 try:
 990                     apt_pkg.ParseSrcDepends(field)
 991                 except:
 992                     self.rejects.append("%s: invalid %s field (can not be parsed by apt)." % (dsc_filename, field_name.title()))
 993
 994         # Ensure the version number in the .dsc matches the version number in the .changes
 995         epochless_dsc_version = re_no_epoch.sub('', self.pkg.dsc["version"])
 996         changes_version = self.pkg.files[dsc_filename]["version"]
 997
 998         if epochless_dsc_version != self.pkg.files[dsc_filename]["version"]:
 999             self.rejects.append("version ('%s') in .dsc does not match version ('%s') in .changes." % (epochless_dsc_version, changes_version))
1000
1001         # Ensure the Files field contain only what's expected
1002         self.rejects.extend(check_dsc_files(dsc_filename, self.pkg.dsc, self.pkg.dsc_files))
1003
1004         # Ensure source is newer than existing source in target suites
1005         session = DBConn().session()
1006         self.check_source_against_db(dsc_filename, session)
1007         self.check_dsc_against_db(dsc_filename, session)
1008         session.close()
1009
1010         return True
1011
1012     ###########################################################################
1013
1014     def get_changelog_versions(self, source_dir):
1015         """Extracts a the source package and (optionally) grabs the
1016         version history out of debian/changelog for the BTS."""
1017
1018         cnf = Config()
1019
1020         # Find the .dsc (again)
1021         dsc_filename = None
1022         for f in self.pkg.files.keys():
1023             if self.pkg.files[f]["type"] == "dsc":
1024                 dsc_filename = f
1025
1026         # If there isn't one, we have nothing to do. (We have reject()ed the upload already)
1027         if not dsc_filename:
1028             return
1029
1030         # Create a symlink mirror of the source files in our temporary directory
1031         for f in self.pkg.files.keys():
1032             m = re_issource.match(f)
1033             if m:
1034                 src = os.path.join(source_dir, f)
1035                 # If a file is missing for whatever reason, give up.
1036                 if not os.path.exists(src):
1037                     return
1038                 ftype = m.group(3)
1039                 if re_is_orig_source.match(f) and pkg.orig_files.has_key(f) and \
1040                    pkg.orig_files[f].has_key("path"):
1041                     continue
1042                 dest = os.path.join(os.getcwd(), f)
1043                 os.symlink(src, dest)
1044
1045         # If the orig files are not a part of the upload, create symlinks to the
1046         # existing copies.
1047         for orig_file in self.pkg.orig_files.keys():
1048             if not self.pkg.orig_files[orig_file].has_key("path"):
1049                 continue
1050             dest = os.path.join(os.getcwd(), os.path.basename(orig_file))
1051             os.symlink(self.pkg.orig_files[orig_file]["path"], dest)
1052
1053         # Extract the source
1054         cmd = "dpkg-source -sn -x %s" % (dsc_filename)
1055         (result, output) = commands.getstatusoutput(cmd)
1056         if (result != 0):
1057             self.rejects.append("'dpkg-source -x' failed for %s [return code: %s]." % (dsc_filename, result))
1058             self.rejects.append(utils.prefix_multi_line_string(output, " [dpkg-source output:] "))
1059             return
1060
1061         if not cnf.Find("Dir::Queue::BTSVersionTrack"):
1062             return
1063
1064         # Get the upstream version
1065         upstr_version = re_no_epoch.sub('', self.pkg.dsc["version"])
1066         if re_strip_revision.search(upstr_version):
1067             upstr_version = re_strip_revision.sub('', upstr_version)
1068
1069         # Ensure the changelog file exists
1070         changelog_filename = "%s-%s/debian/changelog" % (self.pkg.dsc["source"], upstr_version)
1071         if not os.path.exists(changelog_filename):
1072             self.rejects.append("%s: debian/changelog not found in extracted source." % (dsc_filename))
1073             return
1074
1075         # Parse the changelog
1076         self.pkg.dsc["bts changelog"] = ""
1077         changelog_file = utils.open_file(changelog_filename)
1078         for line in changelog_file.readlines():
1079             m = re_changelog_versions.match(line)
1080             if m:
1081                 self.pkg.dsc["bts changelog"] += line
1082         changelog_file.close()
1083
1084         # Check we found at least one revision in the changelog
1085         if not self.pkg.dsc["bts changelog"]:
1086             self.rejects.append("%s: changelog format not recognised (empty version tree)." % (dsc_filename))
1087
1088     def check_source(self):
1089         # XXX: I'm fairly sure reprocess == 2 can never happen
1090         #      AJT disabled the is_incoming check years ago - mhy
1091         #      We should probably scrap or rethink the whole reprocess thing
1092         # Bail out if:
1093         #    a) there's no source
1094         # or b) reprocess is 2 - we will do this check next time when orig
1095         #       tarball is in 'files'
1096         # or c) the orig files are MIA
1097         if not self.pkg.changes["architecture"].has_key("source") or self.reprocess == 2 \
1098            or len(self.pkg.orig_files) == 0:
1099             return
1100
1101         tmpdir = utils.temp_dirname()
1102
1103         # Move into the temporary directory
1104         cwd = os.getcwd()
1105         os.chdir(tmpdir)
1106
1107         # Get the changelog version history
1108         self.get_changelog_versions(cwd)
1109
1110         # Move back and cleanup the temporary tree
1111         os.chdir(cwd)
1112
1113         try:
1114             shutil.rmtree(tmpdir)
1115         except OSError, e:
1116             if e.errno != errno.EACCES:
1117                 print "foobar"
1118                 utils.fubar("%s: couldn't remove tmp dir for source tree." % (self.pkg.dsc["source"]))
1119
1120             self.rejects.append("%s: source tree could not be cleanly removed." % (self.pkg.dsc["source"]))
1121             # We probably have u-r or u-w directories so chmod everything
1122             # and try again.
1123             cmd = "chmod -R u+rwx %s" % (tmpdir)
1124             result = os.system(cmd)
1125             if result != 0:
1126                 utils.fubar("'%s' failed with result %s." % (cmd, result))
1127             shutil.rmtree(tmpdir)
1128         except Exception, e:
1129             print "foobar2 (%s)" % e
1130             utils.fubar("%s: couldn't remove tmp dir for source tree." % (self.pkg.dsc["source"]))
1131
1132     ###########################################################################
1133     def ensure_hashes(self):
1134         # Make sure we recognise the format of the Files: field in the .changes
1135         format = self.pkg.changes.get("format", "0.0").split(".", 1)
1136         if len(format) == 2:
1137             format = int(format[0]), int(format[1])
1138         else:
1139             format = int(float(format[0])), 0
1140
1141         # We need to deal with the original changes blob, as the fields we need
1142         # might not be in the changes dict serialised into the .dak anymore.
1143         orig_changes = utils.parse_deb822(self.pkg.changes['filecontents'])
1144
1145         # Copy the checksums over to the current changes dict.  This will keep
1146         # the existing modifications to it intact.
1147         for field in orig_changes:
1148             if field.startswith('checksums-'):
1149                 self.pkg.changes[field] = orig_changes[field]
1150
1151         # Check for unsupported hashes
1152         for j in utils.check_hash_fields(".changes", self.pkg.changes):
1153             self.rejects.append(j)
1154
1155         for j in utils.check_hash_fields(".dsc", self.pkg.dsc):
1156             self.rejects.append(j)
1157
1158         # We have to calculate the hash if we have an earlier changes version than
1159         # the hash appears in rather than require it exist in the changes file
1160         for hashname, hashfunc, version in utils.known_hashes:
1161             # TODO: Move _ensure_changes_hash into this class
1162             for j in utils._ensure_changes_hash(self.pkg.changes, format, version, self.pkg.files, hashname, hashfunc):
1163                 self.rejects.append(j)
1164             if "source" in self.pkg.changes["architecture"]:
1165                 # TODO: Move _ensure_dsc_hash into this class
1166                 for j in utils._ensure_dsc_hash(self.pkg.dsc, self.pkg.dsc_files, hashname, hashfunc):
1167                     self.rejects.append(j)
1168
1169     def check_hashes(self):
1170         for m in utils.check_hash(".changes", self.pkg.files, "md5", apt_pkg.md5sum):
1171             self.rejects.append(m)
1172
1173         for m in utils.check_size(".changes", self.pkg.files):
1174             self.rejects.append(m)
1175
1176         for m in utils.check_hash(".dsc", self.pkg.dsc_files, "md5", apt_pkg.md5sum):
1177             self.rejects.append(m)
1178
1179         for m in utils.check_size(".dsc", self.pkg.dsc_files):
1180             self.rejects.append(m)
1181
1182         self.ensure_hashes()
1183
1184     ###########################################################################
1185     def check_lintian(self):
1186         # Only check some distributions
1187         valid_dist = False
1188         for dist in ('unstable', 'experimental'):
1189             if dist in self.pkg.changes['distribution']:
1190                 valid_dist = True
1191                 break
1192
1193         if not valid_dist:
1194             return
1195
1196         cnf = Config()
1197         tagfile = cnf.get("Dinstall::LintianTags")
1198         if tagfile is None:
1199             # We don't have a tagfile, so just don't do anything.
1200             return
1201         # Parse the yaml file
1202         sourcefile = file(tagfile, 'r')
1203         sourcecontent = sourcefile.read()
1204         sourcefile.close()
1205         try:
1206             lintiantags = yaml.load(sourcecontent)['lintian']
1207         except yaml.YAMLError, msg:
1208             utils.fubar("Can not read the lintian tags file %s, YAML error: %s." % (tagfile, msg))
1209             return
1210
1211         # Now setup the input file for lintian. lintian wants "one tag per line" only,
1212         # so put it together like it. We put all types of tags in one file and then sort
1213         # through lintians output later to see if its a fatal tag we detected, or not.
1214         # So we only run lintian once on all tags, even if we might reject on some, but not
1215         # reject on others.
1216         # Additionally build up a set of tags
1217         tags = set()
1218         (fd, temp_filename) = utils.temp_filename()
1219         temptagfile = os.fdopen(fd, 'w')
1220         for tagtype in lintiantags:
1221             for tag in lintiantags[tagtype]:
1222                 temptagfile.write("%s\n" % tag)
1223                 tags.add(tag)
1224         temptagfile.close()
1225
1226         # So now we should look at running lintian at the .changes file, capturing output
1227         # to then parse it.
1228         command = "lintian --show-overrides --tags-from-file %s %s" % (temp_filename, self.pkg.changes_file)
1229         (result, output) = commands.getstatusoutput(command)
1230         # We are done with lintian, remove our tempfile
1231         os.unlink(temp_filename)
1232         if (result == 2):
1233             utils.warn("lintian failed for %s [return code: %s]." % (self.pkg.changes_file, result))
1234             utils.warn(utils.prefix_multi_line_string(output, " [possible output:] "))
1235
1236         if len(output) == 0:
1237             return
1238
1239         # We have output of lintian, this package isn't clean. Lets parse it and see if we
1240         # are having a victim for a reject.
1241         # W: tzdata: binary-without-manpage usr/sbin/tzconfig
1242         for line in output.split('\n'):
1243             m = re_parse_lintian.match(line)
1244             if m is None:
1245                 continue
1246
1247             etype = m.group(1)
1248             epackage = m.group(2)
1249             etag = m.group(3)
1250             etext = m.group(4)
1251
1252             # So lets check if we know the tag at all.
1253             if etag not in tags:
1254                 continue
1255
1256             if etype == 'O':
1257                 # We know it and it is overriden. Check that override is allowed.
1258                 if etag in lintiantags['warning']:
1259                     # The tag is overriden, and it is allowed to be overriden.
1260                     # Don't add a reject message.
1261                     pass
1262                 elif etag in lintiantags['error']:
1263                     # The tag is overriden - but is not allowed to be
1264                     self.rejects.append("%s: Overriden tag %s found, but this tag may not be overwritten." % (epackage, etag))
1265             else:
1266                 # Tag is known, it is not overriden, direct reject.
1267                 self.rejects.append("%s: Found lintian output: '%s %s', automatically rejected package." % (epackage, etag, etext))
1268                 # Now tell if they *might* override it.
1269                 if etag in lintiantags['warning']:
1270                     self.rejects.append("%s: If you have a good reason, you may override this lintian tag." % (epackage))
1271
1272     ###########################################################################
1273     def check_urgency(self):
1274         cnf = Config()
1275         if self.pkg.changes["architecture"].has_key("source"):
1276             if not self.pkg.changes.has_key("urgency"):
1277                 self.pkg.changes["urgency"] = cnf["Urgency::Default"]
1278             self.pkg.changes["urgency"] = self.pkg.changes["urgency"].lower()
1279             if self.pkg.changes["urgency"] not in cnf.ValueList("Urgency::Valid"):
1280                 self.warnings.append("%s is not a valid urgency; it will be treated as %s by testing." % \
1281                                      (self.pkg.changes["urgency"], cnf["Urgency::Default"]))
1282                 self.pkg.changes["urgency"] = cnf["Urgency::Default"]
1283
1284     ###########################################################################
1285
1286     # Sanity check the time stamps of files inside debs.
1287     # [Files in the near future cause ugly warnings and extreme time
1288     #  travel can cause errors on extraction]
1289
1290     def check_timestamps(self):
1291         Cnf = Config()
1292
1293         future_cutoff = time.time() + int(Cnf["Dinstall::FutureTimeTravelGrace"])
1294         past_cutoff = time.mktime(time.strptime(Cnf["Dinstall::PastCutoffYear"],"%Y"))
1295         tar = TarTime(future_cutoff, past_cutoff)
1296
1297         for filename, entry in self.pkg.files.items():
1298             if entry["type"] == "deb":
1299                 tar.reset()
1300                 try:
1301                     deb_file = utils.open_file(filename)
1302                     apt_inst.debExtract(deb_file, tar.callback, "control.tar.gz")
1303                     deb_file.seek(0)
1304                     try:
1305                         apt_inst.debExtract(deb_file, tar.callback, "data.tar.gz")
1306                     except SystemError, e:
1307                         # If we can't find a data.tar.gz, look for data.tar.bz2 instead.
1308                         if not re.search(r"Cannot f[ui]nd chunk data.tar.gz$", str(e)):
1309                             raise
1310                         deb_file.seek(0)
1311                         apt_inst.debExtract(deb_file,tar.callback,"data.tar.bz2")
1312
1313                     deb_file.close()
1314
1315                     future_files = tar.future_files.keys()
1316                     if future_files:
1317                         num_future_files = len(future_files)
1318                         future_file = future_files[0]
1319                         future_date = tar.future_files[future_file]
1320                         self.rejects.append("%s: has %s file(s) with a time stamp too far into the future (e.g. %s [%s])."
1321                                % (filename, num_future_files, future_file, time.ctime(future_date)))
1322
1323                     ancient_files = tar.ancient_files.keys()
1324                     if ancient_files:
1325                         num_ancient_files = len(ancient_files)
1326                         ancient_file = ancient_files[0]
1327                         ancient_date = tar.ancient_files[ancient_file]
1328                         self.rejects.append("%s: has %s file(s) with a time stamp too ancient (e.g. %s [%s])."
1329                                % (filename, num_ancient_files, ancient_file, time.ctime(ancient_date)))
1330                 except:
1331                     self.rejects.append("%s: deb contents timestamp check failed [%s: %s]" % (filename, sys.exc_type, sys.exc_value))
1332
1333     def check_if_upload_is_sponsored(self, uid_email, uid_name):
1334         if uid_email in [self.pkg.changes["maintaineremail"], self.pkg.changes["changedbyemail"]]:
1335             sponsored = False
1336         elif uid_name in [self.pkg.changes["maintainername"], self.pkg.changes["changedbyname"]]:
1337             sponsored = False
1338             if uid_name == "":
1339                 sponsored = True
1340         else:
1341             sponsored = True
1342             if ("source" in self.pkg.changes["architecture"] and uid_email and utils.is_email_alias(uid_email)):
1343                 sponsor_addresses = utils.gpg_get_key_addresses(self.pkg.changes["fingerprint"])
1344                 if (self.pkg.changes["maintaineremail"] not in sponsor_addresses and
1345                     self.pkg.changes["changedbyemail"] not in sponsor_addresses):
1346                         self.pkg.changes["sponsoremail"] = uid_email
1347
1348         return sponsored
1349
1350
1351     ###########################################################################
1352     # check_signed_by_key checks
1353     ###########################################################################
1354
1355     def check_signed_by_key(self):
1356         """Ensure the .changes is signed by an authorized uploader."""
1357         session = DBConn().session()
1358
1359         # First of all we check that the person has proper upload permissions
1360         # and that this upload isn't blocked
1361         fpr = get_fingerprint(self.pkg.changes['fingerprint'], session=session)
1362
1363         if fpr is None:
1364             self.rejects.append("Cannot find fingerprint %s" % self.pkg.changes["fingerprint"])
1365             return
1366
1367         # TODO: Check that import-keyring adds UIDs properly
1368         if not fpr.uid:
1369             self.rejects.append("Cannot find uid for fingerprint %s.  Please contact ftpmaster@debian.org" % fpr.fingerprint)
1370             return
1371
1372         # Check that the fingerprint which uploaded has permission to do so
1373         self.check_upload_permissions(fpr, session)
1374
1375         # Check that this package is not in a transition
1376         self.check_transition(session)
1377
1378         session.close()
1379
1380
1381     def check_upload_permissions(self, fpr, session):
1382         # Check any one-off upload blocks
1383         self.check_upload_blocks(fpr, session)
1384
1385         # Start with DM as a special case
1386         # DM is a special case unfortunately, so we check it first
1387         # (keys with no source access get more access than DMs in one
1388         #  way; DMs can only upload for their packages whether source
1389         #  or binary, whereas keys with no access might be able to
1390         #  upload some binaries)
1391         if fpr.source_acl.access_level == 'dm':
1392             self.check_dm_source_upload(fpr, session)
1393         else:
1394             # Check source-based permissions for other types
1395             if self.pkg.changes["architecture"].has_key("source"):
1396                 if fpr.source_acl.access_level is None:
1397                     rej = 'Fingerprint %s may not upload source' % fpr.fingerprint
1398                     rej += '\nPlease contact ftpmaster if you think this is incorrect'
1399                     self.rejects.append(rej)
1400                     return
1401             else:
1402                 # If not a DM, we allow full upload rights
1403                 uid_email = "%s@debian.org" % (fpr.uid.uid)
1404                 self.check_if_upload_is_sponsored(uid_email, fpr.uid.name)
1405
1406
1407         # Check binary upload permissions
1408         # By this point we know that DMs can't have got here unless they
1409         # are allowed to deal with the package concerned so just apply
1410         # normal checks
1411         if fpr.binary_acl.access_level == 'full':
1412             return
1413
1414         # Otherwise we're in the map case
1415         tmparches = self.pkg.changes["architecture"].copy()
1416         tmparches.pop('source', None)
1417
1418         for bam in fpr.binary_acl_map:
1419             tmparches.pop(bam.architecture.arch_string, None)
1420
1421         if len(tmparches.keys()) > 0:
1422             if fpr.binary_reject:
1423                 rej = ".changes file contains files of architectures not permitted for fingerprint %s" % fpr.fingerprint
1424                 rej += "\narchitectures involved are: ", ",".join(tmparches.keys())
1425                 self.rejects.append(rej)
1426             else:
1427                 # TODO: This is where we'll implement reject vs throw away binaries later
1428                 rej = "Uhm.  I'm meant to throw away the binaries now but that's not implemented yet"
1429                 rej += "\nPlease complain to ftpmaster@debian.org as this shouldn't have been turned on"
1430                 rej += "\nFingerprint: %s", (fpr.fingerprint)
1431                 self.rejects.append(rej)
1432
1433
1434     def check_upload_blocks(self, fpr, session):
1435         """Check whether any upload blocks apply to this source, source
1436            version, uid / fpr combination"""
1437
1438         def block_rej_template(fb):
1439             rej = 'Manual upload block in place for package %s' % fb.source
1440             if fb.version is not None:
1441                 rej += ', version %s' % fb.version
1442             return rej
1443
1444         for fb in session.query(UploadBlock).filter_by(source = self.pkg.changes['source']).all():
1445             # version is None if the block applies to all versions
1446             if fb.version is None or fb.version == self.pkg.changes['version']:
1447                 # Check both fpr and uid - either is enough to cause a reject
1448                 if fb.fpr is not None:
1449                     if fb.fpr.fingerprint == fpr.fingerprint:
1450                         self.rejects.append(block_rej_template(fb) + ' for fingerprint %s\nReason: %s' % (fpr.fingerprint, fb.reason))
1451                 if fb.uid is not None:
1452                     if fb.uid == fpr.uid:
1453                         self.rejects.append(block_rej_template(fb) + ' for uid %s\nReason: %s' % (fb.uid.uid, fb.reason))
1454
1455
1456     def check_dm_upload(self, fpr, session):
1457         # Quoth the GR (http://www.debian.org/vote/2007/vote_003):
1458         ## none of the uploaded packages are NEW
1459         rej = False
1460         for f in self.pkg.files.keys():
1461             if self.pkg.files[f].has_key("byhand"):
1462                 self.rejects.append("%s may not upload BYHAND file %s" % (uid, f))
1463                 rej = True
1464             if self.pkg.files[f].has_key("new"):
1465                 self.rejects.append("%s may not upload NEW file %s" % (uid, f))
1466                 rej = True
1467
1468         if rej:
1469             return
1470
1471         ## the most recent version of the package uploaded to unstable or
1472         ## experimental includes the field "DM-Upload-Allowed: yes" in the source
1473         ## section of its control file
1474         q = session.query(DBSource).filter_by(source=self.pkg.changes["source"])
1475         q = q.join(SrcAssociation)
1476         q = q.join(Suite).filter(Suite.suite_name.in_(['unstable', 'experimental']))
1477         q = q.order_by(desc('source.version')).limit(1)
1478
1479         r = q.all()
1480
1481         if len(r) != 1:
1482             rej = "Could not find existing source package %s in unstable or experimental and this is a DM upload" % self.pkg.changes["source"]
1483             self.rejects.append(rej)
1484             return
1485
1486         r = r[0]
1487         if not r.dm_upload_allowed:
1488             rej = "Source package %s does not have 'DM-Upload-Allowed: yes' in its most recent version (%s)" % (self.pkg.changes["source"], r.version)
1489             self.rejects.append(rej)
1490             return
1491
1492         ## the Maintainer: field of the uploaded .changes file corresponds with
1493         ## the owner of the key used (ie, non-developer maintainers may not sponsor
1494         ## uploads)
1495         if self.check_if_upload_is_sponsored(fpr.uid.uid, fpr.uid.name):
1496             self.rejects.append("%s (%s) is not authorised to sponsor uploads" % (fpr.uid.uid, fpr.fingerprint))
1497
1498         ## the most recent version of the package uploaded to unstable or
1499         ## experimental lists the uploader in the Maintainer: or Uploaders: fields (ie,
1500         ## non-developer maintainers cannot NMU or hijack packages)
1501
1502         # srcuploaders includes the maintainer
1503         accept = False
1504         for sup in r.srcuploaders:
1505             (rfc822, rfc2047, name, email) = sup.maintainer.get_split_maintainer()
1506             # Eww - I hope we never have two people with the same name in Debian
1507             if email == fpr.uid.uid or name == fpr.uid.name:
1508                 accept = True
1509                 break
1510
1511         if not accept:
1512             self.rejects.append("%s is not in Maintainer or Uploaders of source package %s" % (fpr.uid.uid, self.pkg.changes["source"]))
1513             return
1514
1515         ## none of the packages are being taken over from other source packages
1516         for b in self.pkg.changes["binary"].keys():
1517             for suite in self.pkg.changes["distribution"].keys():
1518                 q = session.query(DBSource)
1519                 q = q.join(DBBinary).filter_by(package=b)
1520                 q = q.join(BinAssociation).join(Suite).filter_by(suite_name=suite)
1521
1522                 for s in q.all():
1523                     if s.source != self.pkg.changes["source"]:
1524                         self.rejects.append("%s may not hijack %s from source package %s in suite %s" % (fpr.uid.uid, b, s, suite))
1525
1526
1527
1528     def check_transition(self, session):
1529         cnf = Config()
1530
1531         sourcepkg = self.pkg.changes["source"]
1532
1533         # No sourceful upload -> no need to do anything else, direct return
1534         # We also work with unstable uploads, not experimental or those going to some
1535         # proposed-updates queue
1536         if "source" not in self.pkg.changes["architecture"] or \
1537            "unstable" not in self.pkg.changes["distribution"]:
1538             return
1539
1540         # Also only check if there is a file defined (and existant) with
1541         # checks.
1542         transpath = cnf.get("Dinstall::Reject::ReleaseTransitions", "")
1543         if transpath == "" or not os.path.exists(transpath):
1544             return
1545
1546         # Parse the yaml file
1547         sourcefile = file(transpath, 'r')
1548         sourcecontent = sourcefile.read()
1549         try:
1550             transitions = yaml.load(sourcecontent)
1551         except yaml.YAMLError, msg:
1552             # This shouldn't happen, there is a wrapper to edit the file which
1553             # checks it, but we prefer to be safe than ending up rejecting
1554             # everything.
1555             utils.warn("Not checking transitions, the transitions file is broken: %s." % (msg))
1556             return
1557
1558         # Now look through all defined transitions
1559         for trans in transitions:
1560             t = transitions[trans]
1561             source = t["source"]
1562             expected = t["new"]
1563
1564             # Will be None if nothing is in testing.
1565             current = get_source_in_suite(source, "testing", session)
1566             if current is not None:
1567                 compare = apt_pkg.VersionCompare(current.version, expected)
1568
1569             if current is None or compare < 0:
1570                 # This is still valid, the current version in testing is older than
1571                 # the new version we wait for, or there is none in testing yet
1572
1573                 # Check if the source we look at is affected by this.
1574                 if sourcepkg in t['packages']:
1575                     # The source is affected, lets reject it.
1576
1577                     rejectmsg = "%s: part of the %s transition.\n\n" % (
1578                         sourcepkg, trans)
1579
1580                     if current is not None:
1581                         currentlymsg = "at version %s" % (current.version)
1582                     else:
1583                         currentlymsg = "not present in testing"
1584
1585                     rejectmsg += "Transition description: %s\n\n" % (t["reason"])
1586
1587                     rejectmsg += "\n".join(textwrap.wrap("""Your package
1588 is part of a testing transition designed to get %s migrated (it is
1589 currently %s, we need version %s).  This transition is managed by the
1590 Release Team, and %s is the Release-Team member responsible for it.
1591 Please mail debian-release@lists.debian.org or contact %s directly if you
1592 need further assistance.  You might want to upload to experimental until this
1593 transition is done."""
1594                             % (source, currentlymsg, expected,t["rm"], t["rm"])))
1595
1596                     self.rejects.append(rejectmsg)
1597                     return
1598
1599     ###########################################################################
1600     # End check_signed_by_key checks
1601     ###########################################################################
1602
1603     def build_summaries(self):
1604         """ Build a summary of changes the upload introduces. """
1605
1606         (byhand, new, summary, override_summary) = self.pkg.file_summary()
1607
1608         short_summary = summary
1609
1610         # This is for direport's benefit...
1611         f = re_fdnic.sub("\n .\n", self.pkg.changes.get("changes", ""))
1612
1613         if byhand or new:
1614             summary += "Changes: " + f
1615
1616         summary += "\n\nOverride entries for your package:\n" + override_summary + "\n"
1617
1618         summary += self.announce(short_summary, 0)
1619
1620         return (summary, short_summary)
1621
1622     ###########################################################################
1623
1624     def close_bugs(self, summary, action):
1625         """
1626         Send mail to close bugs as instructed by the closes field in the changes file.
1627         Also add a line to summary if any work was done.
1628
1629         @type summary: string
1630         @param summary: summary text, as given by L{build_summaries}
1631
1632         @type action: bool
1633         @param action: Set to false no real action will be done.
1634
1635         @rtype: string
1636         @return: summary. If action was taken, extended by the list of closed bugs.
1637
1638         """
1639
1640         template = os.path.join(Config()["Dir::Templates"], 'process-unchecked.bug-close')
1641
1642         bugs = self.pkg.changes["closes"].keys()
1643
1644         if not bugs:
1645             return summary
1646
1647         bugs.sort()
1648         summary += "Closing bugs: "
1649         for bug in bugs:
1650             summary += "%s " % (bug)
1651             if action:
1652                 self.update_subst()
1653                 self.Subst["__BUG_NUMBER__"] = bug
1654                 if self.pkg.changes["distribution"].has_key("stable"):
1655                     self.Subst["__STABLE_WARNING__"] = """
1656 Note that this package is not part of the released stable Debian
1657 distribution.  It may have dependencies on other unreleased software,
1658 or other instabilities.  Please take care if you wish to install it.
1659 The update will eventually make its way into the next released Debian
1660 distribution."""
1661                 else:
1662                     self.Subst["__STABLE_WARNING__"] = ""
1663                 mail_message = utils.TemplateSubst(self.Subst, template)
1664                 utils.send_mail(mail_message)
1665
1666                 # Clear up after ourselves
1667                 del self.Subst["__BUG_NUMBER__"]
1668                 del self.Subst["__STABLE_WARNING__"]
1669
1670         if action and self.logger:
1671             self.logger.log(["closing bugs"] + bugs)
1672
1673         summary += "\n"
1674
1675         return summary
1676
1677     ###########################################################################
1678
1679     def announce(self, short_summary, action):
1680         """
1681         Send an announce mail about a new upload.
1682
1683         @type short_summary: string
1684         @param short_summary: Short summary text to include in the mail
1685
1686         @type action: bool
1687         @param action: Set to false no real action will be done.
1688
1689         @rtype: string
1690         @return: Textstring about action taken.
1691
1692         """
1693
1694         cnf = Config()
1695         announcetemplate = os.path.join(cnf["Dir::Templates"], 'process-unchecked.announce')
1696
1697         # Only do announcements for source uploads with a recent dpkg-dev installed
1698         if float(self.pkg.changes.get("format", 0)) < 1.6 or not \
1699            self.pkg.changes["architecture"].has_key("source"):
1700             return ""
1701
1702         lists_done = {}
1703         summary = ""
1704
1705         self.Subst["__SHORT_SUMMARY__"] = short_summary
1706
1707         for dist in self.pkg.changes["distribution"].keys():
1708             announce_list = cnf.Find("Suite::%s::Announce" % (dist))
1709             if announce_list == "" or lists_done.has_key(announce_list):
1710                 continue
1711
1712             lists_done[announce_list] = 1
1713             summary += "Announcing to %s\n" % (announce_list)
1714
1715             if action:
1716                 self.update_subst()
1717                 self.Subst["__ANNOUNCE_LIST_ADDRESS__"] = announce_list
1718                 if cnf.get("Dinstall::TrackingServer") and \
1719                    self.pkg.changes["architecture"].has_key("source"):
1720                     trackingsendto = "Bcc: %s@%s" % (self.pkg.changes["source"], cnf["Dinstall::TrackingServer"])
1721                     self.Subst["__ANNOUNCE_LIST_ADDRESS__"] += "\n" + trackingsendto
1722
1723                 mail_message = utils.TemplateSubst(self.Subst, announcetemplate)
1724                 utils.send_mail(mail_message)
1725
1726                 del self.Subst["__ANNOUNCE_LIST_ADDRESS__"]
1727
1728         if cnf.FindB("Dinstall::CloseBugs"):
1729             summary = self.close_bugs(summary, action)
1730
1731         del self.Subst["__SHORT_SUMMARY__"]
1732
1733         return summary
1734
1735     ###########################################################################
1736
1737     def accept (self, summary, short_summary, targetdir=None):
1738         """
1739         Accept an upload.
1740
1741         This moves all files referenced from the .changes into the I{accepted}
1742         queue, sends the accepted mail, announces to lists, closes bugs and
1743         also checks for override disparities. If enabled it will write out
1744         the version history for the BTS Version Tracking and will finally call
1745         L{queue_build}.
1746
1747         @type summary: string
1748         @param summary: Summary text
1749
1750         @type short_summary: string
1751         @param short_summary: Short summary
1752
1753         """
1754
1755         cnf = Config()
1756         stats = SummaryStats()
1757
1758         accepttemplate = os.path.join(cnf["Dir::Templates"], 'process-unchecked.accepted')
1759
1760         if targetdir is None:
1761             targetdir = cnf["Dir::Queue::Accepted"]
1762
1763         print "Accepting."
1764         if self.logger:
1765             self.logger.log(["Accepting changes", self.pkg.changes_file])
1766
1767         self.pkg.write_dot_dak(targetdir)
1768
1769         # Move all the files into the accepted directory
1770         utils.move(self.pkg.changes_file, targetdir)
1771
1772         for name, entry in sorted(self.pkg.files.items()):
1773             utils.move(name, targetdir)
1774             stats.accept_bytes += float(entry["size"])
1775
1776         stats.accept_count += 1
1777
1778         # Send accept mail, announce to lists, close bugs and check for
1779         # override disparities
1780         if not cnf["Dinstall::Options::No-Mail"]:
1781             self.update_subst()
1782             self.Subst["__SUITE__"] = ""
1783             self.Subst["__SUMMARY__"] = summary
1784             mail_message = utils.TemplateSubst(self.Subst, accepttemplate)
1785             utils.send_mail(mail_message)
1786             self.announce(short_summary, 1)
1787
1788         ## Helper stuff for DebBugs Version Tracking
1789         if cnf.Find("Dir::Queue::BTSVersionTrack"):
1790             # ??? once queue/* is cleared on *.d.o and/or reprocessed
1791             # the conditionalization on dsc["bts changelog"] should be
1792             # dropped.
1793
1794             # Write out the version history from the changelog
1795             if self.pkg.changes["architecture"].has_key("source") and \
1796                self.pkg.dsc.has_key("bts changelog"):
1797
1798                 (fd, temp_filename) = utils.temp_filename(cnf["Dir::Queue::BTSVersionTrack"], prefix=".")
1799                 version_history = os.fdopen(fd, 'w')
1800                 version_history.write(self.pkg.dsc["bts changelog"])
1801                 version_history.close()
1802                 filename = "%s/%s" % (cnf["Dir::Queue::BTSVersionTrack"],
1803                                       self.pkg.changes_file[:-8]+".versions")
1804                 os.rename(temp_filename, filename)
1805                 os.chmod(filename, 0644)
1806
1807             # Write out the binary -> source mapping.
1808             (fd, temp_filename) = utils.temp_filename(cnf["Dir::Queue::BTSVersionTrack"], prefix=".")
1809             debinfo = os.fdopen(fd, 'w')
1810             for name, entry in sorted(self.pkg.files.items()):
1811                 if entry["type"] == "deb":
1812                     line = " ".join([entry["package"], entry["version"],
1813                                      entry["architecture"], entry["source package"],
1814                                      entry["source version"]])
1815                     debinfo.write(line+"\n")
1816             debinfo.close()
1817             filename = "%s/%s" % (cnf["Dir::Queue::BTSVersionTrack"],
1818                                   self.pkg.changes_file[:-8]+".debinfo")
1819             os.rename(temp_filename, filename)
1820             os.chmod(filename, 0644)
1821
1822         # Its is Cnf["Dir::Queue::Accepted"] here, not targetdir!
1823         # <Ganneff> we do call queue_build too
1824         # <mhy> well yes, we'd have had to if we were inserting into accepted
1825         # <Ganneff> now. thats database only.
1826         # <mhy> urgh, that's going to get messy
1827         # <Ganneff> so i make the p-n call to it *also* using accepted/
1828         # <mhy> but then the packages will be in the queue_build table without the files being there
1829         # <Ganneff> as the buildd queue is only regenerated whenever unchecked runs
1830         # <mhy> ah, good point
1831         # <Ganneff> so it will work out, as unchecked move it over
1832         # <mhy> that's all completely sick
1833         # <Ganneff> yes
1834
1835         # This routine returns None on success or an error on failure
1836         res = get_or_set_queue('accepted').autobuild_upload(self.pkg, cnf["Dir::Queue::Accepted"])
1837         if res:
1838             utils.fubar(res)
1839
1840
1841     def check_override(self):
1842         """
1843         Checks override entries for validity. Mails "Override disparity" warnings,
1844         if that feature is enabled.
1845
1846         Abandons the check if
1847           - override disparity checks are disabled
1848           - mail sending is disabled
1849         """
1850
1851         cnf = Config()
1852
1853         # Abandon the check if:
1854         #  a) override disparity checks have been disabled
1855         #  b) we're not sending mail
1856         if not cnf.FindB("Dinstall::OverrideDisparityCheck") or \
1857            cnf["Dinstall::Options::No-Mail"]:
1858             return
1859
1860         summary = self.pkg.check_override()
1861
1862         if summary == "":
1863             return
1864
1865         overridetemplate = os.path.join(cnf["Dir::Templates"], 'process-unchecked.override-disparity')
1866
1867         self.update_subst()
1868         self.Subst["__SUMMARY__"] = summary
1869         mail_message = utils.TemplateSubst(self.Subst, overridetemplate)
1870         utils.send_mail(mail_message)
1871         del self.Subst["__SUMMARY__"]
1872
1873     ###########################################################################
1874
1875     def remove(self, dir=None):
1876         """
1877         Used (for instance) in p-u to remove the package from unchecked
1878         """
1879         if dir is None:
1880             os.chdir(self.pkg.directory)
1881         else:
1882             os.chdir(dir)
1883
1884         for f in self.pkg.files.keys():
1885             os.unlink(f)
1886         os.unlink(self.pkg.changes_file)
1887
1888     ###########################################################################
1889
1890     def move_to_dir (self, dest, perms=0660, changesperms=0664):
1891         """
1892         Move files to dest with certain perms/changesperms
1893         """
1894         utils.move(self.pkg.changes_file, dest, perms=changesperms)
1895         for f in self.pkg.files.keys():
1896             utils.move(f, dest, perms=perms)
1897
1898     ###########################################################################
1899
1900     def force_reject(self, reject_files):
1901         """
1902         Forcefully move files from the current directory to the
1903         reject directory.  If any file already exists in the reject
1904         directory it will be moved to the morgue to make way for
1905         the new file.
1906
1907         @type files: dict
1908         @param files: file dictionary
1909
1910         """
1911
1912         cnf = Config()
1913
1914         for file_entry in reject_files:
1915             # Skip any files which don't exist or which we don't have permission to copy.
1916             if os.access(file_entry, os.R_OK) == 0:
1917                 continue
1918
1919             dest_file = os.path.join(cnf["Dir::Queue::Reject"], file_entry)
1920
1921             try:
1922                 dest_fd = os.open(dest_file, os.O_RDWR | os.O_CREAT | os.O_EXCL, 0644)
1923             except OSError, e:
1924                 # File exists?  Let's try and move it to the morgue
1925                 if e.errno == errno.EEXIST:
1926                     morgue_file = os.path.join(cnf["Dir::Morgue"], cnf["Dir::MorgueReject"], file_entry)
1927                     try:
1928                         morgue_file = utils.find_next_free(morgue_file)
1929                     except NoFreeFilenameError:
1930                         # Something's either gone badly Pete Tong, or
1931                         # someone is trying to exploit us.
1932                         utils.warn("**WARNING** failed to move %s from the reject directory to the morgue." % (file_entry))
1933                         return
1934                     utils.move(dest_file, morgue_file, perms=0660)
1935                     try:
1936                         dest_fd = os.open(dest_file, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
1937                     except OSError, e:
1938                         # Likewise
1939                         utils.warn("**WARNING** failed to claim %s in the reject directory." % (file_entry))
1940                         return
1941                 else:
1942                     raise
1943             # If we got here, we own the destination file, so we can
1944             # safely overwrite it.
1945             utils.move(file_entry, dest_file, 1, perms=0660)
1946             os.close(dest_fd)
1947
1948     ###########################################################################
1949     def do_reject (self, manual=0, reject_message="", note=""):
1950         """
1951         Reject an upload. If called without a reject message or C{manual} is
1952         true, spawn an editor so the user can write one.
1953
1954         @type manual: bool
1955         @param manual: manual or automated rejection
1956
1957         @type reject_message: string
1958         @param reject_message: A reject message
1959
1960         @return: 0
1961
1962         """
1963         # If we weren't given a manual rejection message, spawn an
1964         # editor so the user can add one in...
1965         if manual and not reject_message:
1966             (fd, temp_filename) = utils.temp_filename()
1967             temp_file = os.fdopen(fd, 'w')
1968             if len(note) > 0:
1969                 for line in note:
1970                     temp_file.write(line)
1971             temp_file.close()
1972             editor = os.environ.get("EDITOR","vi")
1973             answer = 'E'
1974             while answer == 'E':
1975                 os.system("%s %s" % (editor, temp_filename))
1976                 temp_fh = utils.open_file(temp_filename)
1977                 reject_message = "".join(temp_fh.readlines())
1978                 temp_fh.close()
1979                 print "Reject message:"
1980                 print utils.prefix_multi_line_string(reject_message,"  ",include_blank_lines=1)
1981                 prompt = "[R]eject, Edit, Abandon, Quit ?"
1982                 answer = "XXX"
1983                 while prompt.find(answer) == -1:
1984                     answer = utils.our_raw_input(prompt)
1985                     m = re_default_answer.search(prompt)
1986                     if answer == "":
1987                         answer = m.group(1)
1988                     answer = answer[:1].upper()
1989             os.unlink(temp_filename)
1990             if answer == 'A':
1991                 return 1
1992             elif answer == 'Q':
1993                 sys.exit(0)
1994
1995         print "Rejecting.\n"
1996
1997         cnf = Config()
1998
1999         reason_filename = self.pkg.changes_file[:-8] + ".reason"
2000         reason_filename = os.path.join(cnf["Dir::Queue::Reject"], reason_filename)
2001
2002         # Move all the files into the reject directory
2003         reject_files = self.pkg.files.keys() + [self.pkg.changes_file]
2004         self.force_reject(reject_files)
2005
2006         # If we fail here someone is probably trying to exploit the race
2007         # so let's just raise an exception ...
2008         if os.path.exists(reason_filename):
2009             os.unlink(reason_filename)
2010         reason_fd = os.open(reason_filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
2011
2012         rej_template = os.path.join(cnf["Dir::Templates"], "queue.rejected")
2013
2014         self.update_subst()
2015         if not manual:
2016             self.Subst["__REJECTOR_ADDRESS__"] = cnf["Dinstall::MyEmailAddress"]
2017             self.Subst["__MANUAL_REJECT_MESSAGE__"] = ""
2018             self.Subst["__CC__"] = "X-DAK-Rejection: automatic (moo)"
2019             os.write(reason_fd, reject_message)
2020             reject_mail_message = utils.TemplateSubst(self.Subst, rej_template)
2021         else:
2022             # Build up the rejection email
2023             user_email_address = utils.whoami() + " <%s>" % (cnf["Dinstall::MyAdminAddress"])
2024             self.Subst["__REJECTOR_ADDRESS__"] = user_email_address
2025             self.Subst["__MANUAL_REJECT_MESSAGE__"] = reject_message
2026             self.Subst["__CC__"] = "Cc: " + cnf["Dinstall::MyEmailAddress"]
2027             reject_mail_message = utils.TemplateSubst(self.Subst, rej_template)
2028             # Write the rejection email out as the <foo>.reason file
2029             os.write(reason_fd, reject_mail_message)
2030
2031         del self.Subst["__REJECTOR_ADDRESS__"]
2032         del self.Subst["__MANUAL_REJECT_MESSAGE__"]
2033         del self.Subst["__CC__"]
2034
2035         os.close(reason_fd)
2036
2037         # Send the rejection mail if appropriate
2038         if not cnf["Dinstall::Options::No-Mail"]:
2039             utils.send_mail(reject_mail_message)
2040
2041         if self.logger:
2042             self.logger.log(["rejected", self.pkg.changes_file])
2043
2044         return 0
2045
2046     ################################################################################
2047     def in_override_p(self, package, component, suite, binary_type, file, session):
2048         """
2049         Check if a package already has override entries in the DB
2050
2051         @type package: string
2052         @param package: package name
2053
2054         @type component: string
2055         @param component: database id of the component
2056
2057         @type suite: int
2058         @param suite: database id of the suite
2059
2060         @type binary_type: string
2061         @param binary_type: type of the package
2062
2063         @type file: string
2064         @param file: filename we check
2065
2066         @return: the database result. But noone cares anyway.
2067
2068         """
2069
2070         cnf = Config()
2071
2072         if binary_type == "": # must be source
2073             file_type = "dsc"
2074         else:
2075             file_type = binary_type
2076
2077         # Override suite name; used for example with proposed-updates
2078         if cnf.Find("Suite::%s::OverrideSuite" % (suite)) != "":
2079             suite = cnf["Suite::%s::OverrideSuite" % (suite)]
2080
2081         result = get_override(package, suite, component, file_type, session)
2082
2083         # If checking for a source package fall back on the binary override type
2084         if file_type == "dsc" and len(result) < 1:
2085             result = get_override(package, suite, component, ['deb', 'udeb'], session)
2086
2087         # Remember the section and priority so we can check them later if appropriate
2088         if len(result) > 0:
2089             result = result[0]
2090             self.pkg.files[file]["override section"] = result.section.section
2091             self.pkg.files[file]["override priority"] = result.priority.priority
2092             return result
2093
2094         return None
2095
2096     ################################################################################
2097     def get_anyversion(self, sv_list, suite):
2098         """
2099         @type sv_list: list
2100         @param sv_list: list of (suite, version) tuples to check
2101
2102         @type suite: string
2103         @param suite: suite name
2104
2105         Description: TODO
2106         """
2107         Cnf = Config()
2108         anyversion = None
2109         anysuite = [suite] + Cnf.ValueList("Suite::%s::VersionChecks::Enhances" % (suite))
2110         for (s, v) in sv_list:
2111             if s in [ x.lower() for x in anysuite ]:
2112                 if not anyversion or apt_pkg.VersionCompare(anyversion, v) <= 0:
2113                     anyversion = v
2114
2115         return anyversion
2116
2117     ################################################################################
2118
2119     def cross_suite_version_check(self, sv_list, file, new_version, sourceful=False):
2120         """
2121         @type sv_list: list
2122         @param sv_list: list of (suite, version) tuples to check
2123
2124         @type file: string
2125         @param file: XXX
2126
2127         @type new_version: string
2128         @param new_version: XXX
2129
2130         Ensure versions are newer than existing packages in target
2131         suites and that cross-suite version checking rules as
2132         set out in the conf file are satisfied.
2133         """
2134
2135         cnf = Config()
2136
2137         # Check versions for each target suite
2138         for target_suite in self.pkg.changes["distribution"].keys():
2139             must_be_newer_than = [ i.lower() for i in cnf.ValueList("Suite::%s::VersionChecks::MustBeNewerThan" % (target_suite)) ]
2140             must_be_older_than = [ i.lower() for i in cnf.ValueList("Suite::%s::VersionChecks::MustBeOlderThan" % (target_suite)) ]
2141
2142             # Enforce "must be newer than target suite" even if conffile omits it
2143             if target_suite not in must_be_newer_than:
2144                 must_be_newer_than.append(target_suite)
2145
2146             for (suite, existent_version) in sv_list:
2147                 vercmp = apt_pkg.VersionCompare(new_version, existent_version)
2148
2149                 if suite in must_be_newer_than and sourceful and vercmp < 1:
2150                     self.rejects.append("%s: old version (%s) in %s >= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite))
2151
2152                 if suite in must_be_older_than and vercmp > -1:
2153                     cansave = 0
2154
2155                     if self.pkg.changes.get('distribution-version', {}).has_key(suite):
2156                         # we really use the other suite, ignoring the conflicting one ...
2157                         addsuite = self.pkg.changes["distribution-version"][suite]
2158
2159                         add_version = self.get_anyversion(sv_list, addsuite)
2160                         target_version = self.get_anyversion(sv_list, target_suite)
2161
2162                         if not add_version:
2163                             # not add_version can only happen if we map to a suite
2164                             # that doesn't enhance the suite we're propup'ing from.
2165                             # so "propup-ver x a b c; map a d" is a problem only if
2166                             # d doesn't enhance a.
2167                             #
2168                             # i think we could always propagate in this case, rather
2169                             # than complaining. either way, this isn't a REJECT issue
2170                             #
2171                             # And - we really should complain to the dorks who configured dak
2172                             self.warnings.append("%s is mapped to, but not enhanced by %s - adding anyways" % (suite, addsuite))
2173                             self.pkg.changes.setdefault("propdistribution", {})
2174                             self.pkg.changes["propdistribution"][addsuite] = 1
2175                             cansave = 1
2176                         elif not target_version:
2177                             # not targets_version is true when the package is NEW
2178                             # we could just stick with the "...old version..." REJECT
2179                             # for this, I think.
2180                             self.rejects.append("Won't propogate NEW packages.")
2181                         elif apt_pkg.VersionCompare(new_version, add_version) < 0:
2182                             # propogation would be redundant. no need to reject though.
2183                             self.warnings.append("ignoring versionconflict: %s: old version (%s) in %s <= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite))
2184                             cansave = 1
2185                         elif apt_pkg.VersionCompare(new_version, add_version) > 0 and \
2186                              apt_pkg.VersionCompare(add_version, target_version) >= 0:
2187                             # propogate!!
2188                             self.warnings.append("Propogating upload to %s" % (addsuite))
2189                             self.pkg.changes.setdefault("propdistribution", {})
2190                             self.pkg.changes["propdistribution"][addsuite] = 1
2191                             cansave = 1
2192
2193                     if not cansave:
2194                         self.reject.append("%s: old version (%s) in %s <= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite))
2195
2196     ################################################################################
2197     def check_binary_against_db(self, file, session):
2198         # Ensure version is sane
2199         q = session.query(BinAssociation)
2200         q = q.join(DBBinary).filter(DBBinary.package==self.pkg.files[file]["package"])
2201         q = q.join(Architecture).filter(Architecture.arch_string.in_([self.pkg.files[file]["architecture"], 'all']))
2202
2203         self.cross_suite_version_check([ (x.suite.suite_name, x.binary.version) for x in q.all() ],
2204                                        file, self.pkg.files[file]["version"], sourceful=False)
2205
2206         # Check for any existing copies of the file
2207         q = session.query(DBBinary).filter_by(package=self.pkg.files[file]["package"])
2208         q = q.filter_by(version=self.pkg.files[file]["version"])
2209         q = q.join(Architecture).filter_by(arch_string=self.pkg.files[file]["architecture"])
2210
2211         if q.count() > 0:
2212             self.rejects.append("%s: can not overwrite existing copy already in the archive." % (file))
2213
2214     ################################################################################
2215
2216     def check_source_against_db(self, file, session):
2217         """
2218         """
2219         source = self.pkg.dsc.get("source")
2220         version = self.pkg.dsc.get("version")
2221
2222         # Ensure version is sane
2223         q = session.query(SrcAssociation)
2224         q = q.join(DBSource).filter(DBSource.source==source)
2225
2226         self.cross_suite_version_check([ (x.suite.suite_name, x.source.version) for x in q.all() ],
2227                                        file, version, sourceful=True)
2228
2229     ################################################################################
2230     def check_dsc_against_db(self, file, session):
2231         """
2232
2233         @warning: NB: this function can remove entries from the 'files' index [if
2234          the orig tarball is a duplicate of the one in the archive]; if
2235          you're iterating over 'files' and call this function as part of
2236          the loop, be sure to add a check to the top of the loop to
2237          ensure you haven't just tried to dereference the deleted entry.
2238
2239         """
2240
2241         Cnf = Config()
2242         self.pkg.orig_files = {} # XXX: do we need to clear it?
2243         orig_files = self.pkg.orig_files
2244
2245         # Try and find all files mentioned in the .dsc.  This has
2246         # to work harder to cope with the multiple possible
2247         # locations of an .orig.tar.gz.
2248         # The ordering on the select is needed to pick the newest orig
2249         # when it exists in multiple places.
2250         for dsc_name, dsc_entry in self.pkg.dsc_files.items():
2251             found = None
2252             if self.pkg.files.has_key(dsc_name):
2253                 actual_md5 = self.pkg.files[dsc_name]["md5sum"]
2254                 actual_size = int(self.pkg.files[dsc_name]["size"])
2255                 found = "%s in incoming" % (dsc_name)
2256
2257                 # Check the file does not already exist in the archive
2258                 ql = get_poolfile_like_name(dsc_name, session)
2259
2260                 # Strip out anything that isn't '%s' or '/%s$'
2261                 for i in ql:
2262                     if not i.filename.endswith(dsc_name):
2263                         ql.remove(i)
2264
2265                 # "[dak] has not broken them.  [dak] has fixed a
2266                 # brokenness.  Your crappy hack exploited a bug in
2267                 # the old dinstall.
2268                 #
2269                 # "(Come on!  I thought it was always obvious that
2270                 # one just doesn't release different files with
2271                 # the same name and version.)"
2272                 #                        -- ajk@ on d-devel@l.d.o
2273
2274                 if len(ql) > 0:
2275                     # Ignore exact matches for .orig.tar.gz
2276                     match = 0
2277                     if re_is_orig_source.match(dsc_name):
2278                         for i in ql:
2279                             if self.pkg.files.has_key(dsc_name) and \
2280                                int(self.pkg.files[dsc_name]["size"]) == int(i.filesize) and \
2281                                self.pkg.files[dsc_name]["md5sum"] == i.md5sum:
2282                                 self.warnings.append("ignoring %s, since it's already in the archive." % (dsc_name))
2283                                 # TODO: Don't delete the entry, just mark it as not needed
2284                                 # This would fix the stupidity of changing something we often iterate over
2285                                 # whilst we're doing it
2286                                 del self.pkg.files[dsc_name]
2287                                 if not orig_files.has_key(dsc_name):
2288                                     orig_files[dsc_name] = {}
2289                                 orig_files[dsc_name]["path"] = os.path.join(i.location.path, i.filename)
2290                                 match = 1
2291
2292                     if not match:
2293                         self.rejects.append("can not overwrite existing copy of '%s' already in the archive." % (dsc_name))
2294
2295             elif re_is_orig_source.match(dsc_name):
2296                 # Check in the pool
2297                 ql = get_poolfile_like_name(dsc_name, session)
2298
2299                 # Strip out anything that isn't '%s' or '/%s$'
2300                 # TODO: Shouldn't we just search for things which end with our string explicitly in the SQL?
2301                 for i in ql:
2302                     if not i.filename.endswith(dsc_name):
2303                         ql.remove(i)
2304
2305                 if len(ql) > 0:
2306                     # Unfortunately, we may get more than one match here if,
2307                     # for example, the package was in potato but had an -sa
2308                     # upload in woody.  So we need to choose the right one.
2309
2310                     # default to something sane in case we don't match any or have only one
2311                     x = ql[0]
2312
2313                     if len(ql) > 1:
2314                         for i in ql:
2315                             old_file = os.path.join(i.location.path, i.filename)
2316                             old_file_fh = utils.open_file(old_file)
2317                             actual_md5 = apt_pkg.md5sum(old_file_fh)
2318                             old_file_fh.close()
2319                             actual_size = os.stat(old_file)[stat.ST_SIZE]
2320                             if actual_md5 == dsc_entry["md5sum"] and actual_size == int(dsc_entry["size"]):
2321                                 x = i
2322
2323                     old_file = os.path.join(i.location.path, i.filename)
2324                     old_file_fh = utils.open_file(old_file)
2325                     actual_md5 = apt_pkg.md5sum(old_file_fh)
2326                     old_file_fh.close()
2327                     actual_size = os.stat(old_file)[stat.ST_SIZE]
2328                     found = old_file
2329                     suite_type = x.location.archive_type
2330                     # need this for updating dsc_files in install()
2331                     dsc_entry["files id"] = x.file_id
2332                     # See install() in process-accepted...
2333                     if not orig_files.has_key(dsc_name):
2334                         orig_files[dsc_name] = {}
2335                     orig_files[dsc_name]["id"] = x.file_id
2336                     orig_files[dsc_name]["path"] = old_file
2337                     orig_files[dsc_name]["location"] = x.location.location_id
2338                 else:
2339                     # TODO: Record the queues and info in the DB so we don't hardcode all this crap
2340                     # Not there? Check the queue directories...
2341                     for directory in [ "Accepted", "New", "Byhand", "ProposedUpdates", "OldProposedUpdates", "Embargoed", "Unembargoed" ]:
2342                         if not Cnf.has_key("Dir::Queue::%s" % (directory)):
2343                             continue
2344                         in_otherdir = os.path.join(Cnf["Dir::Queue::%s" % (directory)], dsc_name)
2345                         if os.path.exists(in_otherdir):
2346                             in_otherdir_fh = utils.open_file(in_otherdir)
2347                             actual_md5 = apt_pkg.md5sum(in_otherdir_fh)
2348                             in_otherdir_fh.close()
2349                             actual_size = os.stat(in_otherdir)[stat.ST_SIZE]
2350                             found = in_otherdir
2351                             if not orig_files.has_key(dsc_name):
2352                                 orig_files[dsc_name] = {}
2353                             orig_files[dsc_name]["path"] = in_otherdir
2354
2355                     if not found:
2356                         self.rejects.append("%s refers to %s, but I can't find it in the queue or in the pool." % (file, dsc_name))
2357                         continue
2358             else:
2359                 self.rejects.append("%s refers to %s, but I can't find it in the queue." % (file, dsc_name))
2360                 continue
2361             if actual_md5 != dsc_entry["md5sum"]:
2362                 self.rejects.append("md5sum for %s doesn't match %s." % (found, file))
2363             if actual_size != int(dsc_entry["size"]):
2364                 self.rejects.append("size for %s doesn't match %s." % (found, file))
2365
2366     ################################################################################
2367     # This is used by process-new and process-holding to recheck a changes file
2368     # at the time we're running.  It mainly wraps various other internal functions
2369     # and is similar to accepted_checks - these should probably be tidied up
2370     # and combined
2371     def recheck(self, session):
2372         cnf = Config()
2373         for f in self.pkg.files.keys():
2374             # The .orig.tar.gz can disappear out from under us is it's a
2375             # duplicate of one in the archive.
2376             if not self.pkg.files.has_key(f):
2377                 continue
2378
2379             entry = self.pkg.files[f]
2380
2381             # Check that the source still exists
2382             if entry["type"] == "deb":
2383                 source_version = entry["source version"]
2384                 source_package = entry["source package"]
2385                 if not self.pkg.changes["architecture"].has_key("source") \
2386                    and not source_exists(source_package, source_version, self.pkg.changes["distribution"].keys(), session):
2387                     source_epochless_version = re_no_epoch.sub('', source_version)
2388                     dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version)
2389                     found = False
2390                     for q in ["Accepted", "Embargoed", "Unembargoed", "Newstage"]:
2391                         if cnf.has_key("Dir::Queue::%s" % (q)):
2392                             if os.path.exists(cnf["Dir::Queue::%s" % (q)] + '/' + dsc_filename):
2393                                 found = True
2394                     if not found:
2395                         self.rejects.append("no source found for %s %s (%s)." % (source_package, source_version, f))
2396
2397             # Version and file overwrite checks
2398             if entry["type"] == "deb":
2399                 self.check_binary_against_db(f, session)
2400             elif entry["type"] == "dsc":
2401                 self.check_source_against_db(f, session)
2402                 self.check_dsc_against_db(f, session)
2403
2404     ################################################################################
2405     def accepted_checks(self, overwrite_checks, session):
2406         # Recheck anything that relies on the database; since that's not
2407         # frozen between accept and our run time when called from p-a.
2408
2409         # overwrite_checks is set to False when installing to stable/oldstable
2410
2411         propogate={}
2412         nopropogate={}
2413
2414         # Find the .dsc (again)
2415         dsc_filename = None
2416         for f in self.pkg.files.keys():
2417             if self.pkg.files[f]["type"] == "dsc":
2418                 dsc_filename = f
2419
2420         for checkfile in self.pkg.files.keys():
2421             # The .orig.tar.gz can disappear out from under us is it's a
2422             # duplicate of one in the archive.
2423             if not self.pkg.files.has_key(checkfile):
2424                 continue
2425
2426             entry = self.pkg.files[checkfile]
2427
2428             # Check that the source still exists
2429             if entry["type"] == "deb":
2430                 source_version = entry["source version"]
2431                 source_package = entry["source package"]
2432                 if not self.pkg.changes["architecture"].has_key("source") \
2433                    and not source_exists(source_package, source_version,  self.pkg.changes["distribution"].keys()):
2434                     self.rejects.append("no source found for %s %s (%s)." % (source_package, source_version, checkfile))
2435
2436             # Version and file overwrite checks
2437             if overwrite_checks:
2438                 if entry["type"] == "deb":
2439                     self.check_binary_against_db(checkfile, session)
2440                 elif entry["type"] == "dsc":
2441                     self.check_source_against_db(checkfile, session)
2442                     self.check_dsc_against_db(dsc_filename, session)
2443
2444             # propogate in the case it is in the override tables:
2445             for suite in self.pkg.changes.get("propdistribution", {}).keys():
2446                 if self.in_override_p(entry["package"], entry["component"], suite, entry.get("dbtype",""), checkfile, session):
2447                     propogate[suite] = 1
2448                 else:
2449                     nopropogate[suite] = 1
2450
2451         for suite in propogate.keys():
2452             if suite in nopropogate:
2453                 continue
2454             self.pkg.changes["distribution"][suite] = 1
2455
2456         for checkfile in self.pkg.files.keys():
2457             # Check the package is still in the override tables
2458             for suite in self.pkg.changes["distribution"].keys():
2459                 if not self.in_override_p(entry["package"], entry["component"], suite, entry.get("dbtype",""), checkfile, session):
2460                     self.rejects.append("%s is NEW for %s." % (checkfile, suite))
2461
2462     ################################################################################
2463     # This is not really a reject, but an unaccept, but since a) the code for
2464     # that is non-trivial (reopen bugs, unannounce etc.), b) this should be
2465     # extremely rare, for now we'll go with whining at our admin folks...
2466
2467     def do_unaccept(self):
2468         cnf = Config()
2469
2470         self.update_subst()
2471         self.Subst["__REJECTOR_ADDRESS__"] = cnf["Dinstall::MyEmailAddress"]
2472         self.Subst["__REJECT_MESSAGE__"] = self.package_info()
2473         self.Subst["__CC__"] = "Cc: " + cnf["Dinstall::MyEmailAddress"]
2474         self.Subst["__BCC__"] = "X-DAK: dak process-accepted"
2475         if cnf.has_key("Dinstall::Bcc"):
2476             self.Subst["__BCC__"] += "\nBcc: %s" % (cnf["Dinstall::Bcc"])
2477
2478         template = os.path.join(cnf["Dir::Templates"], "process-accepted.unaccept")
2479
2480         reject_mail_message = utils.TemplateSubst(self.Subst, template)
2481
2482         # Write the rejection email out as the <foo>.reason file
2483         reason_filename = os.path.basename(self.pkg.changes_file[:-8]) + ".reason"
2484         reject_filename = os.path.join(cnf["Dir::Queue::Reject"], reason_filename)
2485
2486         # If we fail here someone is probably trying to exploit the race
2487         # so let's just raise an exception ...
2488         if os.path.exists(reject_filename):
2489             os.unlink(reject_filename)
2490
2491         fd = os.open(reject_filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
2492         os.write(fd, reject_mail_message)
2493         os.close(fd)
2494
2495         utils.send_mail(reject_mail_message)
2496
2497         del self.Subst["__REJECTOR_ADDRESS__"]
2498         del self.Subst["__REJECT_MESSAGE__"]
2499         del self.Subst["__CC__"]
2500
2501     ################################################################################
2502     # If any file of an upload has a recent mtime then chances are good
2503     # the file is still being uploaded.
2504
2505     def upload_too_new(self):
2506         cnf = Config()
2507         too_new = False
2508         # Move back to the original directory to get accurate time stamps
2509         cwd = os.getcwd()
2510         os.chdir(self.pkg.directory)
2511         file_list = self.pkg.files.keys()
2512         file_list.extend(self.pkg.dsc_files.keys())
2513         file_list.append(self.pkg.changes_file)
2514         for f in file_list:
2515             try:
2516                 last_modified = time.time()-os.path.getmtime(f)
2517                 if last_modified < int(cnf["Dinstall::SkipTime"]):
2518                     too_new = True
2519                     break
2520             except:
2521                 pass
2522
2523         os.chdir(cwd)
2524         return too_new