X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;f=dak%2Fprocess_accepted.py;h=cc3f7eabdfe170ef1f4f7b19085144ac6d8ae2ed;hb=fdf3c42445b4f11f4cd71634dd2b57cb7d7a4f36;hp=86396832e741e864fb8355ce976d06927235efd6;hpb=cae814a1ffbbb2944931693f35f73062a5ea99e7;p=dak.git diff --git a/dak/process_accepted.py b/dak/process_accepted.py index 86396832..cc3f7eab 100755 --- a/dak/process_accepted.py +++ b/dak/process_accepted.py @@ -1,6 +1,6 @@ #!/usr/bin/env python -# Installs Debian packages from queue/accepted into the pool +""" Installs Debian packages from queue/accepted into the pool """ # Copyright (C) 2000, 2001, 2002, 2003, 2004, 2006 James Troup # This program is free software; you can redistribute it and/or modify @@ -29,12 +29,19 @@ ############################################################################### -import errno, fcntl, os, sys, time, re -import apt_pkg -import daklib.database -import daklib.logging -import daklib.queue -import daklib.utils +import errno +import fcntl +import os +import sys +import time +import re +import apt_pkg, commands +from daklib import database +from daklib import logging +from daklib import queue +from daklib import utils +from daklib.dak_exceptions import * +from daklib.regexes import re_default_answer, re_issource, re_fdnic ############################################################################### @@ -71,12 +78,12 @@ class Urgency_Log: self.timestamp = time.strftime("%Y%m%d%H%M%S") # Create the log directory if it doesn't exist self.log_dir = Cnf["Dir::UrgencyLog"] - if not os.path.exists(self.log_dir): - umask = os.umask(00000) - os.makedirs(self.log_dir, 02775) + if not os.path.exists(self.log_dir) or not os.access(self.log_dir, os.W_OK): + utils.warn("UrgencyLog directory %s does not exist or is not writeable, using /srv/ftp.debian.org/tmp/ instead" % (self.log_dir)) + self.log_dir = '/srv/ftp.debian.org/tmp/' # Open the logfile self.log_filename = "%s/.install-urgencies-%s.new" % (self.log_dir, self.timestamp) - self.log_file = daklib.utils.open_file(self.log_filename, 'w') + self.log_file = utils.open_file(self.log_filename, 'w') self.writes = 0 def log (self, source, version, urgency): @@ -91,12 +98,14 @@ class Urgency_Log: self.log_file.close() if self.writes: new_filename = "%s/install-urgencies-%s" % (self.log_dir, self.timestamp) - daklib.utils.move(self.log_filename, new_filename) + utils.move(self.log_filename, new_filename) else: os.unlink(self.log_filename) + ############################################################################### + def reject (str, prefix="Rejected: "): global reject_message if str: @@ -108,53 +117,53 @@ def reject (str, prefix="Rejected: "): def check(): propogate={} nopropogate={} - for file in files.keys(): + for checkfile in files.keys(): # The .orig.tar.gz can disappear out from under us is it's a # duplicate of one in the archive. - if not files.has_key(file): + if not files.has_key(checkfile): continue # Check that the source still exists - if files[file]["type"] == "deb": - source_version = files[file]["source version"] - source_package = files[file]["source package"] + if files[checkfile]["type"] == "deb": + source_version = files[checkfile]["source version"] + source_package = files[checkfile]["source package"] if not changes["architecture"].has_key("source") \ and not Upload.source_exists(source_package, source_version, changes["distribution"].keys()): - reject("no source found for %s %s (%s)." % (source_package, source_version, file)) + reject("no source found for %s %s (%s)." % (source_package, source_version, checkfile)) # Version and file overwrite checks if not installing_to_stable: - if files[file]["type"] == "deb": - reject(Upload.check_binary_against_db(file), "") - elif files[file]["type"] == "dsc": - reject(Upload.check_source_against_db(file), "") - (reject_msg, is_in_incoming) = Upload.check_dsc_against_db(file) + if files[checkfile]["type"] == "deb": + reject(Upload.check_binary_against_db(checkfile), "") + elif files[checkfile]["type"] == "dsc": + reject(Upload.check_source_against_db(checkfile), "") + (reject_msg, is_in_incoming) = Upload.check_dsc_against_db(checkfile) reject(reject_msg, "") # propogate in the case it is in the override tables: if changes.has_key("propdistribution"): for suite in changes["propdistribution"].keys(): - if Upload.in_override_p(files[file]["package"], files[file]["component"], suite, files[file].get("dbtype",""), file): - propogate[suite] = 1 - else: - nopropogate[suite] = 1 + if Upload.in_override_p(files[checkfile]["package"], files[checkfile]["component"], suite, files[checkfile].get("dbtype",""), checkfile): + propogate[suite] = 1 + else: + nopropogate[suite] = 1 for suite in propogate.keys(): - if suite in nopropogate: - continue - changes["distribution"][suite] = 1 + if suite in nopropogate: + continue + changes["distribution"][suite] = 1 - for file in files.keys(): + for checkfile in files.keys(): # Check the package is still in the override tables for suite in changes["distribution"].keys(): - if not Upload.in_override_p(files[file]["package"], files[file]["component"], suite, files[file].get("dbtype",""), file): - reject("%s is NEW for %s." % (file, suite)) + if not Upload.in_override_p(files[checkfile]["package"], files[checkfile]["component"], suite, files[checkfile].get("dbtype",""), checkfile): + reject("%s is NEW for %s." % (checkfile, suite)) ############################################################################### def init(): global Cnf, Options, Upload, projectB, changes, dsc, dsc_files, files, pkg, Subst - Cnf = daklib.utils.get_conf() + Cnf = utils.get_conf() Arguments = [('a',"automatic","Dinstall::Options::Automatic"), ('h',"help","Dinstall::Options::Help"), @@ -163,8 +172,8 @@ def init(): ('s',"no-mail", "Dinstall::Options::No-Mail")] for i in ["automatic", "help", "no-action", "no-lock", "no-mail", "version"]: - if not Cnf.has_key("Dinstall::Options::%s" % (i)): - Cnf["Dinstall::Options::%s" % (i)] = "" + if not Cnf.has_key("Dinstall::Options::%s" % (i)): + Cnf["Dinstall::Options::%s" % (i)] = "" changes_files = apt_pkg.ParseCommandLine(Cnf,Arguments,sys.argv) Options = Cnf.SubTree("Dinstall::Options") @@ -172,7 +181,7 @@ def init(): if Options["Help"]: usage() - Upload = daklib.queue.Upload(Cnf) + Upload = queue.Upload(Cnf) projectB = Upload.projectB changes = Upload.pkg.changes @@ -211,15 +220,15 @@ def action (): if Options["Automatic"]: answer = 'R' else: - print "INSTALL to " + ", ".join(changes["distribution"].keys()) - print reject_message + summary, + print "INSTALL to " + ", ".join(changes["distribution"].keys()) + print reject_message + summary, prompt = "[I]nstall, Skip, Quit ?" if Options["Automatic"]: answer = 'I' while prompt.find(answer) == -1: - answer = daklib.utils.our_raw_input(prompt) - m = daklib.queue.re_default_answer.match(prompt) + answer = utils.our_raw_input(prompt) + m = re_default_answer.match(prompt) if answer == "": answer = m.group(1) answer = answer[:1].upper() @@ -245,7 +254,7 @@ def do_reject (): Subst["__REJECTOR_ADDRESS__"] = Cnf["Dinstall::MyEmailAddress"] Subst["__REJECT_MESSAGE__"] = reject_message Subst["__CC__"] = "Cc: " + Cnf["Dinstall::MyEmailAddress"] - reject_mail_message = daklib.utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-accepted.unaccept") + reject_mail_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-accepted.unaccept") # Write the rejection email out as the .reason file reason_filename = os.path.basename(pkg.changes_file[:-8]) + ".reason" @@ -258,7 +267,7 @@ def do_reject (): os.write(fd, reject_mail_message) os.close(fd) - daklib.utils.send_mail(reject_mail_message) + utils.send_mail(reject_mail_message) Logger.log(["unaccepted", pkg.changes_file]) ############################################################################### @@ -273,139 +282,132 @@ def install (): # Begin a transaction; if we bomb out anywhere between here and the COMMIT WORK below, the DB will not be changed. projectB.query("BEGIN WORK") + # Ensure that we have all the hashes we need below. + rejmsg = utils.ensure_hashes(changes, dsc, files, dsc_files) + if len(rejmsg) > 0: + # There were errors. Print them and SKIP the changes. + for msg in rejmsg: + utils.warn(msg) + return + # Add the .dsc file to the DB - for file in files.keys(): - if files[file]["type"] == "dsc": + for newfile in files.keys(): + if files[newfile]["type"] == "dsc": package = dsc["source"] version = dsc["version"] # NB: not files[file]["version"], that has no epoch maintainer = dsc["maintainer"] maintainer = maintainer.replace("'", "\\'") - maintainer_id = daklib.database.get_or_set_maintainer_id(maintainer) + maintainer_id = database.get_or_set_maintainer_id(maintainer) changedby = changes["changed-by"] changedby = changedby.replace("'", "\\'") - changedby_id = daklib.database.get_or_set_maintainer_id(changedby) - fingerprint_id = daklib.database.get_or_set_fingerprint_id(dsc["fingerprint"]) + changedby_id = database.get_or_set_maintainer_id(changedby) + fingerprint_id = database.get_or_set_fingerprint_id(dsc["fingerprint"]) install_date = time.strftime("%Y-%m-%d") - filename = files[file]["pool name"] + file - dsc_component = files[file]["component"] - dsc_location_id = files[file]["location id"] - if not files[file].has_key("files id") or not files[file]["files id"]: - files[file]["files id"] = daklib.database.set_files_id (filename, files[file]["size"], files[file]["md5sum"], dsc_location_id) - projectB.query("INSERT INTO source (source, version, maintainer, changedby, file, install_date, sig_fpr) VALUES ('%s', '%s', %d, %d, %d, '%s', %s)" - % (package, version, maintainer_id, changedby_id, files[file]["files id"], install_date, fingerprint_id)) + filename = files[newfile]["pool name"] + newfile + dsc_component = files[newfile]["component"] + dsc_location_id = files[newfile]["location id"] + if dsc.has_key("dm-upload-allowed") and dsc["dm-upload-allowed"] == "yes": + dm_upload_allowed = "true" + else: + dm_upload_allowed = "false" + if not files[newfile].has_key("files id") or not files[newfile]["files id"]: + files[newfile]["files id"] = database.set_files_id (filename, files[newfile]["size"], files[newfile]["md5sum"], files[newfile]["sha1sum"], files[newfile]["sha256sum"], dsc_location_id) + projectB.query("INSERT INTO source (source, version, maintainer, changedby, file, install_date, sig_fpr, dm_upload_allowed) VALUES ('%s', '%s', %d, %d, %d, '%s', %s, %s)" + % (package, version, maintainer_id, changedby_id, files[newfile]["files id"], install_date, fingerprint_id, dm_upload_allowed)) for suite in changes["distribution"].keys(): - suite_id = daklib.database.get_suite_id(suite) + suite_id = database.get_suite_id(suite) projectB.query("INSERT INTO src_associations (suite, source) VALUES (%d, currval('source_id_seq'))" % (suite_id)) # Add the source files to the DB (files and dsc_files) - projectB.query("INSERT INTO dsc_files (source, file) VALUES (currval('source_id_seq'), %d)" % (files[file]["files id"])) + projectB.query("INSERT INTO dsc_files (source, file) VALUES (currval('source_id_seq'), %d)" % (files[newfile]["files id"])) for dsc_file in dsc_files.keys(): - filename = files[file]["pool name"] + dsc_file + filename = files[newfile]["pool name"] + dsc_file # If the .orig.tar.gz is already in the pool, it's # files id is stored in dsc_files by check_dsc(). files_id = dsc_files[dsc_file].get("files id", None) if files_id == None: - files_id = daklib.database.get_files_id(filename, dsc_files[dsc_file]["size"], dsc_files[dsc_file]["md5sum"], dsc_location_id) + files_id = database.get_files_id(filename, dsc_files[dsc_file]["size"], dsc_files[dsc_file]["md5sum"], dsc_location_id) # FIXME: needs to check for -1/-2 and or handle exception if files_id == None: - files_id = daklib.database.set_files_id (filename, dsc_files[dsc_file]["size"], dsc_files[dsc_file]["md5sum"], dsc_location_id) + files_id = database.set_files_id (filename, dsc_files[dsc_file]["size"], dsc_files[dsc_file]["md5sum"], files[dsc_file]["sha1sum"], files[dsc_file]["sha256sum"], dsc_location_id) projectB.query("INSERT INTO dsc_files (source, file) VALUES (currval('source_id_seq'), %d)" % (files_id)) # Add the src_uploaders to the DB - if dsc.get("dm-upload-allowed", "no") == "yes": - uploader_ids = [maintainer_id] - if dsc.has_key("uploaders"): - for u in dsc["uploaders"].split(","): - u = u.replace("'", "\\'") - u = u.strip() - uploader_ids.append( - daklib.database.get_or_set_maintainer_id(u)) - added_ids = {} - for u in uploader_ids: - if added_ids.has_key(u): - daklib.utils.warn("Already saw uploader %s for source %s" % (u, package)) - continue - added_ids[u]=1 - projectB.query("INSERT INTO src_uploaders (source, maintainer) VALUES (currval('source_id_seq'), %d)" % (u)) + uploader_ids = [maintainer_id] + if dsc.has_key("uploaders"): + for u in dsc["uploaders"].split(","): + u = u.replace("'", "\\'") + u = u.strip() + uploader_ids.append( + database.get_or_set_maintainer_id(u)) + added_ids = {} + for u in uploader_ids: + if added_ids.has_key(u): + utils.warn("Already saw uploader %s for source %s" % (u, package)) + continue + added_ids[u]=1 + projectB.query("INSERT INTO src_uploaders (source, maintainer) VALUES (currval('source_id_seq'), %d)" % (u)) # Add the .deb files to the DB - for file in files.keys(): - if files[file]["type"] == "deb": - package = files[file]["package"] - version = files[file]["version"] - maintainer = files[file]["maintainer"] + for newfile in files.keys(): + if files[newfile]["type"] == "deb": + package = files[newfile]["package"] + version = files[newfile]["version"] + maintainer = files[newfile]["maintainer"] maintainer = maintainer.replace("'", "\\'") - maintainer_id = daklib.database.get_or_set_maintainer_id(maintainer) - fingerprint_id = daklib.database.get_or_set_fingerprint_id(changes["fingerprint"]) - architecture = files[file]["architecture"] - architecture_id = daklib.database.get_architecture_id (architecture) - type = files[file]["dbtype"] - source = files[file]["source package"] - source_version = files[file]["source version"] - filename = files[file]["pool name"] + file - if not files[file].has_key("location id") or not files[file]["location id"]: - files[file]["location id"] = daklib.database.get_location_id(Cnf["Dir::Pool"],files[file]["component"],daklib.utils.where_am_i()) - if not files[file].has_key("files id") or not files[file]["files id"]: - files[file]["files id"] = daklib.database.set_files_id (filename, files[file]["size"], files[file]["md5sum"], files[file]["location id"]) - source_id = daklib.database.get_source_id (source, source_version) + maintainer_id = database.get_or_set_maintainer_id(maintainer) + fingerprint_id = database.get_or_set_fingerprint_id(changes["fingerprint"]) + architecture = files[newfile]["architecture"] + architecture_id = database.get_architecture_id (architecture) + filetype = files[newfile]["dbtype"] + source = files[newfile]["source package"] + source_version = files[newfile]["source version"] + filename = files[newfile]["pool name"] + newfile + if not files[newfile].has_key("location id") or not files[newfile]["location id"]: + files[newfile]["location id"] = database.get_location_id(Cnf["Dir::Pool"],files[newfile]["component"],utils.where_am_i()) + if not files[newfile].has_key("files id") or not files[newfile]["files id"]: + files[newfile]["files id"] = database.set_files_id (filename, files[newfile]["size"], files[newfile]["md5sum"], files[newfile]["sha1sum"], files[newfile]["sha256sum"], files[newfile]["location id"]) + source_id = database.get_source_id (source, source_version) if source_id: projectB.query("INSERT INTO binaries (package, version, maintainer, source, architecture, file, type, sig_fpr) VALUES ('%s', '%s', %d, %d, %d, %d, '%s', %d)" - % (package, version, maintainer_id, source_id, architecture_id, files[file]["files id"], type, fingerprint_id)) + % (package, version, maintainer_id, source_id, architecture_id, files[newfile]["files id"], filetype, fingerprint_id)) else: - projectB.query("INSERT INTO binaries (package, version, maintainer, architecture, file, type, sig_fpr) VALUES ('%s', '%s', %d, %d, %d, '%s', %d)" - % (package, version, maintainer_id, architecture_id, files[file]["files id"], type, fingerprint_id)) + raise NoSourceFieldError, "Unable to find a source id for %s (%s), %s, file %s, type %s, signed by %s" % (package, version, architecture, newfile, filetype, changes["fingerprint"]) for suite in changes["distribution"].keys(): - suite_id = daklib.database.get_suite_id(suite) + suite_id = database.get_suite_id(suite) projectB.query("INSERT INTO bin_associations (suite, bin) VALUES (%d, currval('binaries_id_seq'))" % (suite_id)) - # If the .orig.tar.gz is in a legacy directory we need to poolify - # it, so that apt-get source (and anything else that goes by the - # "Directory:" field in the Sources.gz file) works. - orig_tar_id = Upload.pkg.orig_tar_id - orig_tar_location = Upload.pkg.orig_tar_location - legacy_source_untouchable = Upload.pkg.legacy_source_untouchable - if orig_tar_id and orig_tar_location == "legacy": - q = projectB.query("SELECT DISTINCT ON (f.id) l.path, f.filename, f.id as files_id, df.source, df.id as dsc_files_id, f.size, f.md5sum FROM files f, dsc_files df, location l WHERE df.source IN (SELECT source FROM dsc_files WHERE file = %s) AND f.id = df.file AND l.id = f.location AND (l.type = 'legacy' OR l.type = 'legacy-mixed')" % (orig_tar_id)) - qd = q.dictresult() - for qid in qd: - # Is this an old upload superseded by a newer -sa upload? (See check_dsc() for details) - if legacy_source_untouchable.has_key(qid["files_id"]): - continue - # First move the files to the new location - legacy_filename = qid["path"] + qid["filename"] - pool_location = daklib.utils.poolify (changes["source"], files[file]["component"]) - pool_filename = pool_location + os.path.basename(qid["filename"]) - destination = Cnf["Dir::Pool"] + pool_location - daklib.utils.move(legacy_filename, destination) - # Then Update the DB's files table - q = projectB.query("UPDATE files SET filename = '%s', location = '%s' WHERE id = '%s'" % (pool_filename, dsc_location_id, qid["files_id"])) - - # If this is a sourceful diff only upload that is moving non-legacy + if not database.copy_temporary_contents(package, version, files[newfile]): + reject("Missing contents for package") + + # If this is a sourceful diff only upload that is moving # cross-component we need to copy the .orig.tar.gz into the new # component too for the same reasons as above. # if changes["architecture"].has_key("source") and orig_tar_id and \ - orig_tar_location != "legacy" and orig_tar_location != dsc_location_id: - q = projectB.query("SELECT l.path, f.filename, f.size, f.md5sum FROM files f, location l WHERE f.id = %s AND f.location = l.id" % (orig_tar_id)) + orig_tar_location != dsc_location_id: + q = projectB.query("SELECT l.path, f.filename, f.size, f.md5sum, f.sha1sum, f.sha256sum FROM files f, location l WHERE f.id = %s AND f.location = l.id" % (orig_tar_id)) ql = q.getresult()[0] old_filename = ql[0] + ql[1] file_size = ql[2] file_md5sum = ql[3] - new_filename = daklib.utils.poolify(changes["source"], dsc_component) + os.path.basename(old_filename) - new_files_id = daklib.database.get_files_id(new_filename, file_size, file_md5sum, dsc_location_id) + file_sha1sum = ql[4] + file_sha256sum = ql[5] + new_filename = utils.poolify(changes["source"], dsc_component) + os.path.basename(old_filename) + new_files_id = database.get_files_id(new_filename, file_size, file_md5sum, dsc_location_id) if new_files_id == None: - daklib.utils.copy(old_filename, Cnf["Dir::Pool"] + new_filename) - new_files_id = daklib.database.set_files_id(new_filename, file_size, file_md5sum, dsc_location_id) - projectB.query("UPDATE dsc_files SET file = %s WHERE source = %s AND file = %s" % (new_files_id, source_id, orig_tar_id)) + utils.copy(old_filename, Cnf["Dir::Pool"] + new_filename) + new_files_id = database.set_files_id(new_filename, file_size, file_md5sum, file_sha1sum, file_sha256sum, dsc_location_id) + projectB.query("UPDATE dsc_files SET file = %s WHERE source = %s AND file = %s" % (new_files_id, database.get_source_id(changes["source"], changes["version"]), orig_tar_id)) # Install the files into the pool - for file in files.keys(): - destination = Cnf["Dir::Pool"] + files[file]["pool name"] + file - daklib.utils.move(file, destination) - Logger.log(["installed", file, files[file]["type"], files[file]["size"], files[file]["architecture"]]) - install_bytes += float(files[file]["size"]) + for newfile in files.keys(): + destination = Cnf["Dir::Pool"] + files[newfile]["pool name"] + newfile + utils.move(newfile, destination) + Logger.log(["installed", newfile, files[newfile]["type"], files[newfile]["size"], files[newfile]["architecture"]]) + install_bytes += float(files[newfile]["size"]) # Copy the .changes file across for suite which need it. copy_changes = {} @@ -417,14 +419,13 @@ def install (): if Cnf.has_key("Suite::%s::CopyDotDak" % (suite)): copy_dot_dak[Cnf["Suite::%s::CopyDotDak" % (suite)]] = "" for dest in copy_changes.keys(): - daklib.utils.copy(pkg.changes_file, Cnf["Dir::Root"] + dest) + utils.copy(pkg.changes_file, Cnf["Dir::Root"] + dest) for dest in copy_dot_dak.keys(): - daklib.utils.copy(Upload.pkg.changes_file[:-8]+".dak", dest) - + utils.copy(Upload.pkg.changes_file[:-8]+".dak", dest) projectB.query("COMMIT WORK") # Move the .changes into the 'done' directory - daklib.utils.move (pkg.changes_file, + utils.move (pkg.changes_file, os.path.join(Cnf["Dir::Queue::Done"], os.path.basename(pkg.changes_file))) # Remove the .dak file @@ -440,18 +441,18 @@ def install (): if suite not in Cnf.ValueList("Dinstall::QueueBuildSuites"): continue now_date = time.strftime("%Y-%m-%d %H:%M") - suite_id = daklib.database.get_suite_id(suite) + suite_id = database.get_suite_id(suite) dest_dir = Cnf["Dir::QueueBuild"] if Cnf.FindB("Dinstall::SecurityQueueBuild"): dest_dir = os.path.join(dest_dir, suite) - for file in files.keys(): - dest = os.path.join(dest_dir, file) + for newfile in files.keys(): + dest = os.path.join(dest_dir, newfile) # Remove it from the list of packages for later processing by apt-ftparchive projectB.query("UPDATE queue_build SET in_queue = 'f', last_used = '%s' WHERE filename = '%s' AND suite = %s" % (now_date, dest, suite_id)) if not Cnf.FindB("Dinstall::SecurityQueueBuild"): # Update the symlink to point to the new location in the pool - pool_location = daklib.utils.poolify (changes["source"], files[file]["component"]) - src = os.path.join(Cnf["Dir::Pool"], pool_location, os.path.basename(file)) + pool_location = utils.poolify (changes["source"], files[newfile]["component"]) + src = os.path.join(Cnf["Dir::Pool"], pool_location, os.path.basename(newfile)) if os.path.islink(dest): os.unlink(dest) os.symlink(src, dest) @@ -480,40 +481,40 @@ def stable_install (summary, short_summary): projectB.query("BEGIN WORK") # Add the source to stable (and remove it from proposed-updates) - for file in files.keys(): - if files[file]["type"] == "dsc": + for newfile in files.keys(): + if files[newfile]["type"] == "dsc": package = dsc["source"] version = dsc["version"]; # NB: not files[file]["version"], that has no epoch q = projectB.query("SELECT id FROM source WHERE source = '%s' AND version = '%s'" % (package, version)) ql = q.getresult() if not ql: - daklib.utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s) in source table." % (package, version)) + utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s) in source table." % (package, version)) source_id = ql[0][0] - suite_id = daklib.database.get_suite_id('proposed-updates') + suite_id = database.get_suite_id('proposed-updates') projectB.query("DELETE FROM src_associations WHERE suite = '%s' AND source = '%s'" % (suite_id, source_id)) - suite_id = daklib.database.get_suite_id('stable') + suite_id = database.get_suite_id('stable') projectB.query("INSERT INTO src_associations (suite, source) VALUES ('%s', '%s')" % (suite_id, source_id)) # Add the binaries to stable (and remove it/them from proposed-updates) - for file in files.keys(): - if files[file]["type"] == "deb": - package = files[file]["package"] - version = files[file]["version"] - architecture = files[file]["architecture"] + for newfile in files.keys(): + if files[newfile]["type"] == "deb": + package = files[newfile]["package"] + version = files[newfile]["version"] + architecture = files[newfile]["architecture"] q = projectB.query("SELECT b.id FROM binaries b, architecture a WHERE b.package = '%s' AND b.version = '%s' AND (a.arch_string = '%s' OR a.arch_string = 'all') AND b.architecture = a.id" % (package, version, architecture)) ql = q.getresult() if not ql: - daklib.utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s for %s architecture) in binaries table." % (package, version, architecture)) + utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s for %s architecture) in binaries table." % (package, version, architecture)) binary_id = ql[0][0] - suite_id = daklib.database.get_suite_id('proposed-updates') + suite_id = database.get_suite_id('proposed-updates') projectB.query("DELETE FROM bin_associations WHERE suite = '%s' AND bin = '%s'" % (suite_id, binary_id)) - suite_id = daklib.database.get_suite_id('stable') + suite_id = database.get_suite_id('stable') projectB.query("INSERT INTO bin_associations (suite, bin) VALUES ('%s', '%s')" % (suite_id, binary_id)) projectB.query("COMMIT WORK") - daklib.utils.move (pkg.changes_file, Cnf["Dir::Morgue"] + '/process-accepted/' + os.path.basename(pkg.changes_file)) + utils.move (pkg.changes_file, Cnf["Dir::Morgue"] + '/process-accepted/' + os.path.basename(pkg.changes_file)) ## Update the Stable ChangeLog file new_changelog_filename = Cnf["Dir::Root"] + Cnf["Suite::Stable::ChangeLogBase"] + ".ChangeLog" @@ -521,31 +522,31 @@ def stable_install (summary, short_summary): if os.path.exists(new_changelog_filename): os.unlink (new_changelog_filename) - new_changelog = daklib.utils.open_file(new_changelog_filename, 'w') - for file in files.keys(): - if files[file]["type"] == "deb": - new_changelog.write("stable/%s/binary-%s/%s\n" % (files[file]["component"], files[file]["architecture"], file)) - elif daklib.utils.re_issource.match(file): - new_changelog.write("stable/%s/source/%s\n" % (files[file]["component"], file)) + new_changelog = utils.open_file(new_changelog_filename, 'w') + for newfile in files.keys(): + if files[newfile]["type"] == "deb": + new_changelog.write("stable/%s/binary-%s/%s\n" % (files[newfile]["component"], files[newfile]["architecture"], newfile)) + elif re_issource.match(newfile): + new_changelog.write("stable/%s/source/%s\n" % (files[newfile]["component"], newfile)) else: - new_changelog.write("%s\n" % (file)) - chop_changes = daklib.queue.re_fdnic.sub("\n", changes["changes"]) + new_changelog.write("%s\n" % (newfile)) + chop_changes = re_fdnic.sub("\n", changes["changes"]) new_changelog.write(chop_changes + '\n\n') if os.access(changelog_filename, os.R_OK) != 0: - changelog = daklib.utils.open_file(changelog_filename) + changelog = utils.open_file(changelog_filename) new_changelog.write(changelog.read()) new_changelog.close() if os.access(changelog_filename, os.R_OK) != 0: os.unlink(changelog_filename) - daklib.utils.move(new_changelog_filename, changelog_filename) + utils.move(new_changelog_filename, changelog_filename) install_count += 1 if not Options["No-Mail"] and changes["architecture"].has_key("source"): Subst["__SUITE__"] = " into stable" Subst["__SUMMARY__"] = summary - mail_message = daklib.utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-accepted.install") - daklib.utils.send_mail(mail_message) + mail_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-accepted.install") + utils.send_mail(mail_message) Upload.announce(short_summary, 1) # Finally remove the .dak file @@ -599,7 +600,7 @@ def main(): # Check that we aren't going to clash with the daily cron job if not Options["No-Action"] and os.path.exists("%s/Archive_Maintenance_In_Progress" % (Cnf["Dir::Root"])) and not Options["No-Lock"]: - daklib.utils.fubar("Archive maintenance in progress. Try again later.") + utils.fubar("Archive maintenance in progress. Try again later.") # If running from within proposed-updates; assume an install to stable if os.getcwd().find('proposed-updates') != -1: @@ -612,10 +613,10 @@ def main(): fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) except IOError, e: if errno.errorcode[e.errno] == 'EACCES' or errno.errorcode[e.errno] == 'EAGAIN': - daklib.utils.fubar("Couldn't obtain lock; assuming another 'dak process-accepted' is already running.") + utils.fubar("Couldn't obtain lock; assuming another 'dak process-accepted' is already running.") else: raise - Logger = Upload.Logger = daklib.logging.Logger(Cnf, "process-accepted") + Logger = Upload.Logger = logging.Logger(Cnf, "process-accepted") if not installing_to_stable and Cnf.get("Dir::UrgencyLog"): Urgency_Logger = Urgency_Log(Cnf) @@ -627,7 +628,7 @@ def main(): Subst["__BCC__"] = bcc # Sort the .changes files so that we process sourceful ones first - changes_files.sort(daklib.utils.changes_compare) + changes_files.sort(utils.changes_compare) # Process the changes files for changes_file in changes_files: @@ -638,7 +639,7 @@ def main(): sets = "set" if install_count > 1: sets = "sets" - sys.stderr.write("Installed %d package %s, %s.\n" % (install_count, sets, daklib.utils.size_type(int(install_bytes)))) + sys.stderr.write("Installed %d package %s, %s.\n" % (install_count, sets, utils.size_type(int(install_bytes)))) Logger.log(["total",install_count,install_bytes]) if not Options["No-Action"]: