#!/usr/bin/env python
+# vim:set et ts=4 sw=4:
-# Handles NEW and BYHAND packages
-# Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 James Troup <james@nocrew.org>
+""" Handles NEW and BYHAND packages
+@contact: Debian FTP Master <ftpmaster@debian.org>
+@copyright: 2001, 2002, 2003, 2004, 2005, 2006 James Troup <james@nocrew.org>
+@copyright: 2009 Joerg Jaspert <joerg@debian.org>
+@license: GNU General Public License version 2 or later
+"""
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
################################################################################
-import copy, errno, os, readline, stat, sys, time
+from __future__ import with_statement
+
+import copy
+import errno
+import os
+import readline
+import stat
+import sys
+import time
+import contextlib
+import pwd
import apt_pkg, apt_inst
import examine_package
-import daklib.database
-import daklib.logging
-import daklib.queue
-import daklib.utils
+from daklib import database
+from daklib import logging
+from daklib import queue
+from daklib import utils
+from daklib.regexes import re_no_epoch, re_default_answer, re_isanum
+from daklib.dak_exceptions import CantOpenError, AlreadyLockedError, CantGetLockError
# Globals
-Cnf = None
+Cnf = None #: Configuration, apt_pkg.Configuration
Options = None
Upload = None
-projectB = None
+projectB = None #: database connection, pgobject
Logger = None
Priorities = None
files = Upload.pkg.files
reject_message = ""
- for file in files.keys():
+ for f 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(f):
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[f]["type"] == "deb":
+ source_version = files[f]["source version"]
+ source_package = files[f]["source package"]
if not Upload.pkg.changes["architecture"].has_key("source") \
and not Upload.source_exists(source_package, source_version, Upload.pkg.changes["distribution"].keys()):
- source_epochless_version = daklib.utils.re_no_epoch.sub('', source_version)
+ source_epochless_version = re_no_epoch.sub('', source_version)
dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version)
- if not os.path.exists(Cnf["Dir::Queue::Accepted"] + '/' + dsc_filename):
- reject("no source found for %s %s (%s)." % (source_package, source_version, file))
+ found = 0
+ for q in ["Accepted", "Embargoed", "Unembargoed"]:
+ if Cnf.has_key("Dir::Queue::%s" % (q)):
+ if os.path.exists(Cnf["Dir::Queue::%s" % (q)] + '/' + dsc_filename):
+ found = 1
+ if not found:
+ reject("no source found for %s %s (%s)." % (source_package, source_version, f))
# Version and file overwrite checks
- 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)
- reject(reject_msg)
+ if files[f]["type"] == "deb":
+ reject(Upload.check_binary_against_db(f), "")
+ elif files[f]["type"] == "dsc":
+ reject(Upload.check_source_against_db(f), "")
+ (reject_msg, is_in_incoming) = Upload.check_dsc_against_db(f)
+ reject(reject_msg, "")
if reject_message.find("Rejected") != -1:
answer = "XXX"
- if Options["No-Action"] or Options["Automatic"]:
+ if Options["No-Action"] or Options["Automatic"] or Options["Trainee"]:
answer = 'S'
print "REJECT\n" + reject_message,
prompt = "[R]eject, Skip, Quit ?"
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()
elif answer == 'S':
return 0
elif answer == 'Q':
+ end()
sys.exit(0)
return 1
def sg_compare (a, b):
a = a[1]
b = b[1]
- """Sort by have note, time of oldest upload."""
+ """Sort by have note, source already in database and time of oldest upload."""
# Sort by have note
a_note_state = a["note_state"]
b_note_state = b["note_state"]
return -1
elif a_note_state > b_note_state:
return 1
+ # Sort by source already in database (descending)
+ source_in_database = cmp(a["source_in_database"], b["source_in_database"])
+ if source_in_database:
+ return -source_in_database
# Sort by time of oldest upload
return cmp(a["oldest"], b["oldest"])
per_source[source]["list"].append(cache[filename])
# Determine oldest time and have note status for each source group
for source in per_source.keys():
+ q = projectB.query("SELECT 1 FROM source WHERE source = '%s'" % source)
+ ql = q.getresult()
+ per_source[source]["source_in_database"] = len(ql)>0
source_list = per_source[source]["list"]
first = source_list[0]
oldest = os.stat(first["filename"])[stat.ST_MTIME]
mtime = os.stat(d["filename"])[stat.ST_MTIME]
if mtime < oldest:
oldest = mtime
- have_note += (d.has_key("process-new note"))
+ have_note += (database.has_new_comment(d["source"], d["version"]))
per_source[source]["oldest"] = oldest
if not have_note:
per_source[source]["note_state"] = 0; # none
class Section_Completer:
def __init__ (self):
self.sections = []
+ self.matches = []
q = projectB.query("SELECT section FROM section")
for i in q.getresult():
self.sections.append(i[0])
class Priority_Completer:
def __init__ (self):
self.priorities = []
+ self.matches = []
q = projectB.query("SELECT priority FROM priority")
for i in q.getresult():
self.priorities.append(i[0])
################################################################################
def print_new (new, indexed, file=sys.stdout):
- daklib.utils.check_valid(new)
+ queue.check_valid(new)
broken = 0
index = 0
for pkg in new.keys():
line = "%-20s %-20s %-20s" % (pkg, priority, section)
line = line.strip()+'\n'
file.write(line)
- note = Upload.pkg.changes.get("process-new note")
- if note:
- print "*"*75
- print note
- print "*"*75
+ note = database.get_new_comments(Upload.pkg.changes.get("source"))
+ if len(note) > 0:
+ for line in note:
+ print line
return broken, note
################################################################################
def edit_new (new):
# Write the current data to a temporary file
- temp_filename = daklib.utils.temp_filename()
- temp_file = daklib.utils.open_file(temp_filename, 'w')
+ (fd, temp_filename) = utils.temp_filename()
+ temp_file = os.fdopen(fd, 'w')
print_new (new, 0, temp_file)
temp_file.close()
# Spawn an editor on that file
editor = os.environ.get("EDITOR","vi")
result = os.system("%s %s" % (editor, temp_filename))
if result != 0:
- daklib.utils.fubar ("%s invocation failed for %s." % (editor, temp_filename), result)
+ utils.fubar ("%s invocation failed for %s." % (editor, temp_filename), result)
# Read the edited data back in
- temp_file = daklib.utils.open_file(temp_filename)
+ temp_file = utils.open_file(temp_filename)
lines = temp_file.readlines()
temp_file.close()
os.unlink(temp_filename)
s[len(s):3] = [None] * (3-len(s))
(pkg, priority, section) = s[:3]
if not new.has_key(pkg):
- daklib.utils.warn("Ignoring unknown package '%s'" % (pkg))
+ utils.warn("Ignoring unknown package '%s'" % (pkg))
else:
# Strip off any invalid markers, print_new will readd them.
if section.endswith("[!]"):
section = section[:-3]
if priority.endswith("[!]"):
priority = priority[:-3]
- for file in new[pkg]["files"]:
- Upload.pkg.files[file]["section"] = section
- Upload.pkg.files[file]["priority"] = priority
+ for f in new[pkg]["files"]:
+ Upload.pkg.files[f]["section"] = section
+ Upload.pkg.files[f]["priority"] = priority
new[pkg]["section"] = section
new[pkg]["priority"] = priority
def edit_index (new, index):
priority = new[index]["priority"]
section = new[index]["section"]
- type = new[index]["type"]
+ ftype = new[index]["type"]
done = 0
while not done:
print "\t".join([index, priority, section])
answer = "XXX"
- if type != "dsc":
+ if ftype != "dsc":
prompt = "[B]oth, Priority, Section, Done ? "
else:
prompt = "[S]ection, Done ? "
edit_priority = edit_section = 0
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()
readline.set_completer(Priorities.complete)
got_priority = 0
while not got_priority:
- new_priority = daklib.utils.our_raw_input("New priority: ").strip()
+ new_priority = utils.our_raw_input("New priority: ").strip()
if new_priority not in Priorities.priorities:
print "E: '%s' is not a valid priority, try again." % (new_priority)
else:
readline.set_completer(Sections.complete)
got_section = 0
while not got_section:
- new_section = daklib.utils.our_raw_input("New section: ").strip()
+ new_section = utils.our_raw_input("New section: ").strip()
if new_section not in Sections.sections:
print "E: '%s' is not a valid section, try again." % (new_section)
else:
# Reset the readline completer
readline.set_completer(None)
- for file in new[index]["files"]:
- Upload.pkg.files[file]["section"] = section
- Upload.pkg.files[file]["priority"] = priority
+ for f in new[index]["files"]:
+ Upload.pkg.files[f]["section"] = section
+ Upload.pkg.files[f]["priority"] = priority
new[index]["priority"] = priority
new[index]["section"] = section
return new
got_answer = 0
while not got_answer:
- answer = daklib.utils.our_raw_input(prompt)
+ answer = utils.our_raw_input(prompt)
if not answer.isdigit():
answer = answer[:1].upper()
if answer == "E" or answer == "D":
got_answer = 1
- elif daklib.queue.re_isanum.match (answer):
+ elif re_isanum.match (answer):
answer = int(answer)
if (answer < 1) or (answer > index):
print "%s is not a valid index (%s). Please retry." % (answer, index_range(index))
def edit_note(note):
# Write the current data to a temporary file
- temp_filename = daklib.utils.temp_filename()
- temp_file = daklib.utils.open_file(temp_filename, 'w')
- temp_file.write(note)
- temp_file.close()
+ (fd, temp_filename) = utils.temp_filename()
editor = os.environ.get("EDITOR","vi")
answer = 'E'
while answer == 'E':
os.system("%s %s" % (editor, temp_filename))
- temp_file = daklib.utils.open_file(temp_filename)
- note = temp_file.read().rstrip()
+ temp_file = utils.open_file(temp_filename)
+ newnote = temp_file.read().rstrip()
temp_file.close()
- print "Note:"
- print daklib.utils.prefix_multi_line_string(note," ")
+ print "New Note:"
+ print utils.prefix_multi_line_string(newnote," ")
prompt = "[D]one, Edit, Abandon, Quit ?"
answer = "XXX"
while prompt.find(answer) == -1:
- answer = daklib.utils.our_raw_input(prompt)
- m = daklib.queue.re_default_answer.search(prompt)
+ answer = utils.our_raw_input(prompt)
+ m = re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
if answer == 'A':
return
elif answer == 'Q':
+ end()
sys.exit(0)
- Upload.pkg.changes["process-new note"] = note
- Upload.dump_vars(Cnf["Dir::Queue::New"])
+ database.add_new_comment(Upload.pkg.changes["source"], Upload.pkg.changes["version"], newnote, utils.whoami())
################################################################################
stdout_fd = sys.stdout
try:
sys.stdout = less_fd
- examine_package.display_changes(Upload.pkg.changes_file)
+ changes = utils.parse_changes (Upload.pkg.changes_file)
+ examine_package.display_changes(changes['distribution'], Upload.pkg.changes_file)
files = Upload.pkg.files
- for file in files.keys():
- if files[file].has_key("new"):
- type = files[file]["type"]
- if type == "deb":
- examine_package.check_deb(file)
- elif type == "dsc":
- examine_package.check_dsc(file)
+ for f in files.keys():
+ if files[f].has_key("new"):
+ ftype = files[f]["type"]
+ if ftype == "deb":
+ examine_package.check_deb(changes['distribution'], f)
+ elif ftype == "dsc":
+ examine_package.check_dsc(changes['distribution'], f)
finally:
+ examine_package.output_package_relations()
sys.stdout = stdout_fd
except IOError, e:
- if errno.errorcode[e.errno] == 'EPIPE':
- daklib.utils.warn("[examine_package] Caught EPIPE; skipping.")
+ if e.errno == errno.EPIPE:
+ utils.warn("[examine_package] Caught EPIPE; skipping.")
pass
else:
raise
except KeyboardInterrupt:
- daklib.utils.warn("[examine_package] Caught C-c; skipping.")
+ utils.warn("[examine_package] Caught C-c; skipping.")
pass
################################################################################
def do_bxa_notification():
files = Upload.pkg.files
summary = ""
- for file in files.keys():
- if files[file]["type"] == "deb":
- control = apt_pkg.ParseSection(apt_inst.debExtractControl(daklib.utils.open_file(file)))
+ for f in files.keys():
+ if files[f]["type"] == "deb":
+ control = apt_pkg.ParseSection(apt_inst.debExtractControl(utils.open_file(f)))
summary += "\n"
summary += "Package: %s\n" % (control.Find("Package"))
summary += "Description: %s\n" % (control.Find("Description"))
Upload.Subst["__BINARY_DESCRIPTIONS__"] = summary
- bxa_mail = daklib.utils.TemplateSubst(Upload.Subst,Cnf["Dir::Templates"]+"/process-new.bxa_notification")
- daklib.utils.send_mail(bxa_mail)
+ bxa_mail = utils.TemplateSubst(Upload.Subst,Cnf["Dir::Templates"]+"/process-new.bxa_notification")
+ utils.send_mail(bxa_mail)
################################################################################
projectB.query("BEGIN WORK")
for suite in changes["suite"].keys():
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
for pkg in new.keys():
- component_id = daklib.database.get_component_id(new[pkg]["component"])
- type_id = daklib.database.get_override_type_id(new[pkg]["type"])
+ component_id = database.get_component_id(new[pkg]["component"])
+ type_id = database.get_override_type_id(new[pkg]["type"])
priority_id = new[pkg]["priority id"]
section_id = new[pkg]["section id"]
projectB.query("INSERT INTO override (suite, component, type, package, priority, section, maintainer) VALUES (%s, %s, %s, '%s', %s, %s, '')" % (suite_id, component_id, type_id, pkg, priority_id, section_id))
- for file in new[pkg]["files"]:
- if files[file].has_key("new"):
- del files[file]["new"]
+ for f in new[pkg]["files"]:
+ if files[f].has_key("new"):
+ del files[f]["new"]
del new[pkg]
projectB.query("COMMIT WORK")
################################################################################
-def prod_maintainer ():
+def prod_maintainer (note):
# Here we prepare an editor and get them ready to prod...
- temp_filename = daklib.utils.temp_filename()
+ (fd, temp_filename) = utils.temp_filename()
+ temp_file = os.fdopen(fd, 'w')
+ if len(note) > 0:
+ for line in note:
+ temp_file.write(line)
+ temp_file.close()
editor = os.environ.get("EDITOR","vi")
answer = 'E'
while answer == 'E':
os.system("%s %s" % (editor, temp_filename))
- file = daklib.utils.open_file(temp_filename)
- prod_message = "".join(file.readlines())
- file.close()
+ temp_fh = utils.open_file(temp_filename)
+ prod_message = "".join(temp_fh.readlines())
+ temp_fh.close()
print "Prod message:"
- print daklib.utils.prefix_multi_line_string(prod_message," ",include_blank_lines=1)
+ print utils.prefix_multi_line_string(prod_message," ",include_blank_lines=1)
prompt = "[P]rod, Edit, Abandon, Quit ?"
answer = "XXX"
while prompt.find(answer) == -1:
- answer = daklib.utils.our_raw_input(prompt)
- m = daklib.queue.re_default_answer.search(prompt)
+ answer = utils.our_raw_input(prompt)
+ m = re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
- os.unlink(temp_filename)
- if answer == 'A':
- return
- elif answer == 'Q':
- sys.exit(0)
+ os.unlink(temp_filename)
+ if answer == 'A':
+ return
+ elif answer == 'Q':
+ end()
+ sys.exit(0)
# Otherwise, do the proding...
- user_email_address = daklib.utils.whoami() + " <%s>" % (
+ user_email_address = utils.whoami() + " <%s>" % (
Cnf["Dinstall::MyAdminAddress"])
Subst = Upload.Subst
Subst["__PROD_MESSAGE__"] = prod_message
Subst["__CC__"] = "Cc: " + Cnf["Dinstall::MyEmailAddress"]
- prod_mail_message = daklib.utils.TemplateSubst(
+ prod_mail_message = utils.TemplateSubst(
Subst,Cnf["Dir::Templates"]+"/process-new.prod")
# Send the prod mail if appropriate
if not Cnf["Dinstall::Options::No-Mail"]:
- daklib.utils.send_mail(prod_mail_message)
+ utils.send_mail(prod_mail_message)
print "Sent proding message"
for suite in changes["suite"].keys():
override = Cnf.Find("Suite::%s::OverrideSuite" % (suite))
if override:
- (olderr, newerr) = (daklib.database.get_suite_id(suite) == -1,
- daklib.database.get_suite_id(override) == -1)
- if olderr or newerr:
- (oinv, newinv) = ("", "")
- if olderr: oinv = "invalid "
- if newerr: ninv = "invalid "
- print "warning: overriding %ssuite %s to %ssuite %s" % (
- oinv, suite, ninv, override)
+ (olderr, newerr) = (database.get_suite_id(suite) == -1,
+ database.get_suite_id(override) == -1)
+ if olderr or newerr:
+ (oinv, newinv) = ("", "")
+ if olderr: oinv = "invalid "
+ if newerr: ninv = "invalid "
+ print "warning: overriding %ssuite %s to %ssuite %s" % (
+ oinv, suite, ninv, override)
del changes["suite"][suite]
changes["suite"][override] = 1
# Validate suites
for suite in changes["suite"].keys():
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
if suite_id == -1:
- daklib.utils.fubar("%s has invalid suite '%s' (possibly overriden). say wha?" % (changes, suite))
+ utils.fubar("%s has invalid suite '%s' (possibly overriden). say wha?" % (changes, suite))
# The main NEW processing loop
done = 0
while not done:
# Find out what's new
- new = daklib.utils.determine_new(changes, files, projectB)
+ new = queue.determine_new(changes, files, projectB)
if not new:
break
prompt += "Edit overrides, Check, Manual reject, Note edit, Prod, [S]kip, Quit ?"
while prompt.find(answer) == -1:
- answer = daklib.utils.our_raw_input(prompt)
- m = daklib.queue.re_default_answer.search(prompt)
+ answer = utils.our_raw_input(prompt)
+ m = re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
- if answer == 'A':
- done = add_overrides (new)
+ if answer == 'A' and not Options["Trainee"]:
+ try:
+ check_daily_lock()
+ done = add_overrides (new)
+ except CantGetLockError:
+ print "Hello? Operator! Give me the number for 911!"
+ print "Dinstall in the locked area, cant process packages, come back later"
elif answer == 'C':
check_pkg()
- elif answer == 'E':
+ elif answer == 'E' and not Options["Trainee"]:
new = edit_overrides (new)
- elif answer == 'M':
- aborted = Upload.do_reject(1, Options["Manual-Reject"])
+ elif answer == 'M' and not Options["Trainee"]:
+ aborted = Upload.do_reject(manual=1,
+ reject_message=Options["Manual-Reject"],
+ note=database.get_new_comments(changes.get("source", "")))
if not aborted:
os.unlink(Upload.pkg.changes_file[:-8]+".dak")
done = 1
elif answer == 'N':
- edit_note(changes.get("process-new note", ""))
- elif answer == 'P':
- prod_maintainer()
- elif answer == 'R':
- confirm = daklib.utils.our_raw_input("Really clear note (y/N)? ").lower()
+ edit_note(database.get_new_comments(changes.get("source", "")))
+ elif answer == 'P' and not Options["Trainee"]:
+ prod_maintainer(database.get_new_comments(changes.get("source", "")))
+ elif answer == 'R' and not Options["Trainee"]:
+ confirm = utils.our_raw_input("Really clear note (y/N)? ").lower()
if confirm == "y":
- del changes["process-new note"]
+ database.delete_new_comments(changes.get("source"), changes.get("version"))
elif answer == 'S':
done = 1
elif answer == 'Q':
+ end()
sys.exit(0)
################################################################################
print """Usage: dak process-new [OPTION]... [CHANGES]...
-a, --automatic automatic run
-h, --help show this help and exit.
+ -C, --comments-dir=DIR use DIR as comments-dir, for [o-]p-u-new
-m, --manual-reject=MSG manual reject with `msg'
-n, --no-action don't do anything
+ -t, --trainee FTP Trainee mode
-V, --version display the version number and exit"""
sys.exit(exit_code)
def init():
global Cnf, Options, Logger, Upload, projectB, Sections, Priorities
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('a',"automatic","Process-New::Options::Automatic"),
('h',"help","Process-New::Options::Help"),
- ('C',"comments-dir","Process-New::Options::Comments-Dir", "HasArg"),
+ ('C',"comments-dir","Process-New::Options::Comments-Dir", "HasArg"),
('m',"manual-reject","Process-New::Options::Manual-Reject", "HasArg"),
+ ('t',"trainee","Process-New::Options::Trainee"),
('n',"no-action","Process-New::Options::No-Action")]
- for i in ["automatic", "help", "manual-reject", "no-action", "version", "comments-dir"]:
+ for i in ["automatic", "help", "manual-reject", "no-action", "version", "comments-dir", "trainee"]:
if not Cnf.has_key("Process-New::Options::%s" % (i)):
Cnf["Process-New::Options::%s" % (i)] = ""
changes_files = apt_pkg.ParseCommandLine(Cnf,Arguments,sys.argv)
+ if len(changes_files) == 0 and not Cnf.get("Process-New::Options::Comments-Dir",""):
+ changes_files = utils.get_changes_files(Cnf["Dir::Queue::New"])
+
Options = Cnf.SubTree("Process-New::Options")
if Options["Help"]:
usage()
- Upload = daklib.queue.Upload(Cnf)
+ Upload = queue.Upload(Cnf)
if not Options["No-Action"]:
- Logger = Upload.Logger = daklib.logging.Logger(Cnf, "process-new")
+ try:
+ Logger = Upload.Logger = logging.Logger(Cnf, "process-new")
+ except CantOpenError, e:
+ Options["Trainee"] = "Oh yes"
projectB = Upload.projectB
will_install = 1
byhand = []
- for file in files.keys():
- if files[file]["type"] == "byhand":
- if os.path.exists(file):
- print "W: %s still present; please process byhand components and try again." % (file)
+ for f in files.keys():
+ if files[f]["type"] == "byhand":
+ if os.path.exists(f):
+ print "W: %s still present; please process byhand components and try again." % (f)
will_install = 0
else:
- byhand.append(file)
+ byhand.append(f)
answer = "XXXX"
if Options["No-Action"]:
prompt = "Manual reject, [S]kip, Quit ?"
while prompt.find(answer) == -1:
- answer = daklib.utils.our_raw_input(prompt)
- m = daklib.queue.re_default_answer.search(prompt)
+ answer = utils.our_raw_input(prompt)
+ m = re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
if answer == 'A':
done = 1
- for file in byhand:
- del files[file]
+ for f in byhand:
+ del files[f]
elif answer == 'M':
Upload.do_reject(1, Options["Manual-Reject"])
os.unlink(Upload.pkg.changes_file[:-8]+".dak")
elif answer == 'S':
done = 1
elif answer == 'Q':
+ end()
sys.exit(0)
################################################################################
+def check_daily_lock():
+ """
+ Raises CantGetLockError if the dinstall daily.lock exists.
+ """
+
+ try:
+ os.open(Cnf["Process-New::DinstallLockFile"], os.O_RDONLY | os.O_CREAT | os.O_EXCL)
+ except OSError, e:
+ if e.errno == errno.EEXIST or e.errno == errno.EACCES:
+ raise CantGetLockError
+
+ os.unlink(Cnf["Process-New::DinstallLockFile"])
+
+
+@contextlib.contextmanager
+def lock_package(package):
+ """
+ Lock C{package} so that noone else jumps in processing it.
+
+ @type package: string
+ @param package: source package name to lock
+ """
+
+ path = os.path.join(Cnf["Process-New::LockDir"], package)
+ try:
+ fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDONLY)
+ except OSError, e:
+ if e.errno == errno.EEXIST or e.errno == errno.EACCES:
+ user = pwd.getpwuid(os.stat(path)[stat.ST_UID])[4].split(',')[0].replace('.', '')
+ raise AlreadyLockedError, user
+
+ try:
+ yield fd
+ finally:
+ os.unlink(path)
+
+def move_to_dir (dest, perms=0660, changesperms=0664):
+ utils.move (Upload.pkg.changes_file, dest, perms=changesperms)
+ file_keys = Upload.pkg.files.keys()
+ for f in file_keys:
+ utils.move (f, dest, perms=perms)
+
+def is_source_in_queue_dir(qdir):
+ entries = [ x for x in os.listdir(qdir) if x.startswith(Upload.pkg.changes["source"])
+ and x.endswith(".changes") ]
+ for entry in entries:
+ # read the .dak
+ u = queue.Upload(Cnf)
+ u.pkg.changes_file = os.path.join(qdir, entry)
+ u.update_vars()
+ if not u.pkg.changes["architecture"].has_key("source"):
+ # another binary upload, ignore
+ continue
+ if Upload.pkg.changes["version"] != u.pkg.changes["version"]:
+ # another version, ignore
+ continue
+ # found it!
+ return True
+ return False
+
+def move_to_holding(suite, queue_dir):
+ print "Moving to %s holding area." % (suite.upper(),)
+ if Options["No-Action"]:
+ return
+ Logger.log(["Moving to %s" % (suite,), Upload.pkg.changes_file])
+ Upload.dump_vars(queue_dir)
+ move_to_dir(queue_dir, perms=0664)
+ os.unlink(Upload.pkg.changes_file[:-8]+".dak")
+
+def _accept():
+ if Options["No-Action"]:
+ return
+ (summary, short_summary) = Upload.build_summaries()
+ Upload.accept(summary, short_summary, targetdir=Cnf["Dir::Queue::Newstage"])
+ os.unlink(Upload.pkg.changes_file[:-8]+".dak")
+
+def do_accept_stableupdate(suite, q):
+ queue_dir = Cnf["Dir::Queue::%s" % (q,)]
+ if not Upload.pkg.changes["architecture"].has_key("source"):
+ # It is not a sourceful upload. So its source may be either in p-u
+ # holding, in new, in accepted or already installed.
+ if is_source_in_queue_dir(queue_dir):
+ # It's in p-u holding, so move it there.
+ print "Binary-only upload, source in %s." % (q,)
+ move_to_holding(suite, queue_dir)
+ elif Upload.source_exists(Upload.pkg.changes["source"],
+ Upload.pkg.changes["version"]):
+ # dak tells us that there is source available. At time of
+ # writing this means that it is installed, so put it into
+ # accepted.
+ print "Binary-only upload, source installed."
+ _accept()
+ elif is_source_in_queue_dir(Cnf["Dir::Queue::Accepted"]):
+ # The source is in accepted, the binary cleared NEW: accept it.
+ print "Binary-only upload, source in accepted."
+ _accept()
+ elif is_source_in_queue_dir(Cnf["Dir::Queue::New"]):
+ # It's in NEW. We expect the source to land in p-u holding
+ # pretty soon.
+ print "Binary-only upload, source in new."
+ move_to_holding(suite, queue_dir)
+ else:
+ # No case applicable. Bail out. Return will cause the upload
+ # to be skipped.
+ print "ERROR"
+ print "Stable update failed. Source not found."
+ return
+ else:
+ # We are handling a sourceful upload. Move to accepted if currently
+ # in p-u holding and to p-u holding otherwise.
+ if is_source_in_queue_dir(queue_dir):
+ print "Sourceful upload in %s, accepting." % (q,)
+ _accept()
+ else:
+ move_to_holding(suite, queue_dir)
+
def do_accept():
print "ACCEPT"
if not Options["No-Action"]:
- retry = 0
- while retry < 10:
- try:
- lock_fd = os.open(Cnf["Process-New::AcceptedLockFile"], os.O_RDONLY | os.O_CREAT | os.O_EXCL)
- retry = 10
- except OSError, e:
- if errno.errorcode[e.errno] == 'EACCES' or errno.errorcode[e.errno] == 'EEXIST':
- retry += 1
- if (retry >= 10):
- daklib.utils.fubar("Couldn't obtain lock; assuming 'dak process-unchecked' is already running.")
- else:
- print("Unable to get accepted lock (try %d of 10)" % retry)
- time.sleep(60)
- else:
- raise
(summary, short_summary) = Upload.build_summaries()
- Upload.accept(summary, short_summary)
- os.unlink(Upload.pkg.changes_file[:-8]+".dak")
- os.unlink(Cnf["Process-New::AcceptedLockFile"])
+ if Cnf.FindB("Dinstall::SecurityQueueHandling"):
+ Upload.dump_vars(Cnf["Dir::Queue::Embargoed"])
+ move_to_dir(Cnf["Dir::Queue::Embargoed"])
+ Upload.queue_build("embargoed", Cnf["Dir::Queue::Embargoed"])
+ # Check for override disparities
+ Upload.Subst["__SUMMARY__"] = summary
+ else:
+ # Stable updates need to be copied to proposed-updates holding
+ # area instead of accepted. Sourceful uploads need to go
+ # to it directly, binaries only if the source has not yet been
+ # accepted into p-u.
+ for suite, q in [("proposed-updates", "ProposedUpdates"),
+ ("oldstable-proposed-updates", "OldProposedUpdates")]:
+ if not Upload.pkg.changes["distribution"].has_key(suite):
+ continue
+ return do_accept_stableupdate(suite, q)
+ # Just a normal upload, accept it...
+ _accept()
def check_status(files):
new = byhand = 0
- for file in files.keys():
- if files[file]["type"] == "byhand":
+ for f in files.keys():
+ if files[f]["type"] == "byhand":
byhand = 1
- elif files[file].has_key("new"):
+ elif files[f].has_key("new"):
new = 1
return (new, byhand)
Upload.update_subst()
files = Upload.pkg.files
- if not recheck():
- return
-
- (new, byhand) = check_status(files)
- if new or byhand:
- if new:
- do_new()
- if byhand:
- do_byhand()
- (new, byhand) = check_status(files)
+ try:
+ check_daily_lock()
+ except CantGetLockError:
+ print "Hello? Operator! Give me the number for 911!"
+ print "Dinstall in the locked area, cant process packages, come back later"
+ sys.exit(1)
- if not new and not byhand:
- do_accept()
+ try:
+ with lock_package(Upload.pkg.changes["source"]):
+ if not recheck():
+ return
+
+ (new, byhand) = check_status(files)
+ if new or byhand:
+ if new:
+ do_new()
+ if byhand:
+ do_byhand()
+ (new, byhand) = check_status(files)
+
+ if not new and not byhand:
+ do_accept()
+ except AlreadyLockedError, e:
+ print "Seems to be locked by %s already, skipping..." % (e)
################################################################################
sets = "set"
if accept_count > 1:
sets = "sets"
- sys.stderr.write("Accepted %d package %s, %s.\n" % (accept_count, sets, daklib.utils.size_type(int(accept_bytes))))
+ sys.stderr.write("Accepted %d package %s, %s.\n" % (accept_count, sets, utils.size_type(int(accept_bytes))))
Logger.log(["total",accept_count,accept_bytes])
- if not Options["No-Action"]:
+ if not Options["No-Action"] and not Options["Trainee"]:
Logger.close()
################################################################################
if len(lines) == 0 or lines[0] != line + "\n": continue
changes_files = [ x for x in os.listdir(".") if x.startswith(comm[7:]+"_")
and x.endswith(".changes") ]
- changes_files = sort_changes(changes_files)
+ changes_files = sort_changes(changes_files)
for f in changes_files:
- f = daklib.utils.validate_changes_file_arg(f, 0)
- if not f: continue
- print "\n" + f
- fn(f, "".join(lines[1:]))
+ f = utils.validate_changes_file_arg(f, 0)
+ if not f: continue
+ print "\n" + f
+ fn(f, "".join(lines[1:]))
if opref != npref and not Options["No-Action"]:
- newcomm = npref + comm[len(opref):]
- os.rename("%s/%s" % (dir, comm), "%s/%s" % (dir, newcomm))
+ newcomm = npref + comm[len(opref):]
+ os.rename("%s/%s" % (dir, comm), "%s/%s" % (dir, newcomm))
################################################################################
Upload.init_vars()
Upload.update_vars()
Upload.update_subst()
- files = Upload.pkg.files
if not recheck():
pass # dak has its own reasons to reject as well, which is fine
commentsdir = Cnf.get("Process-New::Options::Comments-Dir","")
if commentsdir:
- if changes_files != []:
- sys.stderr.write("Can't specify any changes files if working with comments-dir")
- sys.exit(1)
- do_comments(commentsdir, "ACCEPT.", "ACCEPTED.", "OK", comment_accept)
- do_comments(commentsdir, "REJECT.", "REJECTED.", "NOTOK", comment_reject)
+ if changes_files != []:
+ sys.stderr.write("Can't specify any changes files if working with comments-dir")
+ sys.exit(1)
+ do_comments(commentsdir, "ACCEPT.", "ACCEPTED.", "OK", comment_accept)
+ do_comments(commentsdir, "REJECT.", "REJECTED.", "NOTOK", comment_reject)
else:
for changes_file in changes_files:
- changes_file = daklib.utils.validate_changes_file_arg(changes_file, 0)
+ changes_file = utils.validate_changes_file_arg(changes_file, 0)
if not changes_file:
continue
print "\n" + changes_file
+
do_pkg (changes_file)
end()
projects / dak.git / blobdiff