+2008-05-04 Joerg Jaspert <joerg@debian.org>
+
+ * dak/import_keyring.py: Remove unused daklib.logging and Logger
+ and add the actually used daklib/utils
+
+ * dak/examine_package.py: remove daklib.queue import, never used
+
+ * dak/check_proposed_updates.py: Import stuff from daklib as
+ "import daklib.foo as foo"
+ * dak/clean_proposed_updates.py: likewise
+ * dak/clean_queues.py: likewise
+ * dak/clean_suites.py: likewise
+ * dak/compare_suites.py: likewise
+ * dak/cruft_report.py: likewise
+ * dak/examine_package.py: likewise
+ * dak/find_null_maintainers.py: likewise
+ * dak/generate_index_diffs.py: likewise
+ * dak/generate_releases.py: likewise
+ * dak/import_archive.py: likewise
+ * dak/import_ldap_fingerprints.py: likewise
+ * dak/import_users_from_passwd.py: likewise
+ * dak/init_db.py: likewise
+ * dak/init_dirs.py: likewise
+ * dak/ls.py: likewise
+ * dak/make_maintainers.py: likewise
+ * dak/make_overrides.py: likewise
+ * dak/make_suite_file_list.py: likewise
+ * dak/new_security_install.py: likewise
+ * dak/override.py: likewise
+ * dak/process_accepted.py: likewise
+ * dak/process_new.py: likewise
+ * dak/process_unchecked.py: likewise
+ * dak/rm.py: likewise
+ * dak/show_new.py: likewise
+ * dak/split_done.py: likewise
+ * dak/stats.py: likewise
+ * dak/transitions.py: likewise
+
+ * dak/check_archive.py (check_files_not_symlinks): Remove
+ long-time unused and commented code. Import stuff from daklib as
+ "import daklib.foo as foo"
+
2008-05-04 Thomas Viehmann <tv@beamnet.de>
* dak/process_unchecked.py (check_signed_by_key): cater for uid_email
None in sponsor notification
+2008-05-03 Joerg Jaspert <joerg@debian.org>
+
+ * dak/examine_package.py: clean up pychecker warnings (merged with
+ Thomas changes to the NEW display)
+
+2008-05-03 Mark Hymers <mhy@debian.org>
+
+ * dak/check_archive.py: clean up pychecker warnings
+ * dak/check_overrides.py: likewise
+ * dak/check_proposed_updates.py: likewise
+ * dak/clean_proposed_updates.py: likewise
+ * dak/clean_queues.py: likewise
+ * dak/control_overrides.py: likewise
+ * dak/control_suite.py: likewise
+ * dak/decode_dot_dak.py: likewise
+ * dak/examine_package.py: likewise
+ * dak/process_new.py: likewise
+ * dak/process_unchecked.py: likewise
+ * dak/queue_report.py: likewise
+ * dak/reject_proposed_updates.py: likewise
+ * dak/security_install.py: likewise
+ * dak/show_new.py: likewise
+ * dak/stats.py: likewise
+ * dak/symlink_dists.py: likewise
+ * dak/transitions.py: likewise
+
2008-05-03 Joerg Jaspert <joerg@debian.org>
* config/debian/cron.daily: Rename to
daily for some time now. And while dinstall is an OLD name, its
recognized pretty well within Debian
Also add some more timing information
+ Do not allow automated [o-]p-u-new processing to break dinstall
2008-05-03 Thomas Viehmann <tv@beamnet.de>
echo "Doing automated p-u-new processing"
cd $queuedir/p-u-new
date -u -R >> REPORT
-dak process-new -a -C COMMENTS >> REPORT
+dak process-new -a -C COMMENTS >> REPORT || true
echo >> REPORT
TS=$(($TS+1)); echo Archive maintenance timestamp $TS: $(date +%X)
echo "Doing automated o-p-u-new processing"
cd $queuedir/o-p-u-new
date -u -R >> REPORT
-dak process-new -a -C COMMENTS >> REPORT
+dak process-new -a -C COMMENTS >> REPORT || true
echo >> REPORT
################################################################################
import commands, os, pg, stat, sys, time
import apt_pkg, apt_inst
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
filename = Cnf["Dir::Override"]+'override.unreferenced'
if os.path.exists(filename):
- file = daklib.utils.open_file(filename)
- for filename in file.readlines():
+ f = utils.open_file(filename)
+ for filename in f.readlines():
filename = filename[:-1]
excluded[filename] = ""
os.path.walk(Cnf["Dir::Root"]+'pool/', process_dir, None)
print
- print "%s wasted..." % (daklib.utils.size_type(waste))
+ print "%s wasted..." % (utils.size_type(waste))
################################################################################
continue
component = component.lower()
list_filename = '%s%s_%s_source.list' % (Cnf["Dir::Lists"], suite, component)
- list_file = daklib.utils.open_file(list_filename)
+ list_file = utils.open_file(list_filename)
for line in list_file.readlines():
- file = line[:-1]
+ f = line[:-1]
try:
- daklib.utils.parse_changes(file, signing_rules=1)
- except daklib.utils.invalid_dsc_format_exc, line:
- daklib.utils.warn("syntax error in .dsc file '%s', line %s." % (file, line))
+ utils.parse_changes(f, signing_rules=1)
+ except utils.invalid_dsc_format_exc, line:
+ utils.warn("syntax error in .dsc file '%s', line %s." % (f, line))
count += 1
if count:
- daklib.utils.warn("Found %s invalid .dsc files." % (count))
+ utils.warn("Found %s invalid .dsc files." % (count))
################################################################################
print suite
print "-"*len(suite)
print
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
q = projectB.query("""
SELECT DISTINCT b.package FROM binaries b, bin_associations ba
WHERE b.id = ba.bin AND ba.suite = %s AND NOT EXISTS
db_md5sum = i[2]
db_size = int(i[3])
try:
- file = daklib.utils.open_file(filename)
+ f = utils.open_file(filename)
except:
- daklib.utils.warn("can't open '%s'." % (filename))
+ utils.warn("can't open '%s'." % (filename))
continue
- md5sum = apt_pkg.md5sum(file)
+ md5sum = apt_pkg.md5sum(f)
size = os.stat(filename)[stat.ST_SIZE]
if md5sum != db_md5sum:
- daklib.utils.warn("**WARNING** md5sum mismatch for '%s' ('%s' [current] vs. '%s' [db])." % (filename, md5sum, db_md5sum))
+ utils.warn("**WARNING** md5sum mismatch for '%s' ('%s' [current] vs. '%s' [db])." % (filename, md5sum, db_md5sum))
if size != db_size:
- daklib.utils.warn("**WARNING** size mismatch for '%s' ('%s' [current] vs. '%s' [db])." % (filename, size, db_size))
+ utils.warn("**WARNING** size mismatch for '%s' ('%s' [current] vs. '%s' [db])." % (filename, size, db_size))
print "Done."
for i in ql:
filename = os.path.abspath(i[0] + i[1])
if os.access(filename, os.R_OK):
- file = daklib.utils.open_file(filename)
+ f = utils.open_file(filename)
current_file = filename
sys.stderr.write("Processing %s.\n" % (filename))
- apt_inst.debExtract(file,Ent,"control.tar.gz")
- file.seek(0)
- apt_inst.debExtract(file,Ent,"data.tar.gz")
+ apt_inst.debExtract(f, Ent, "control.tar.gz")
+ f.seek(0)
+ apt_inst.debExtract(f, Ent, "data.tar.gz")
count += 1
print "Checked %d files (out of %d)." % (count, len(db_files.keys()))
filename = os.path.abspath(i[0] + i[1])
try:
# NB: don't enforce .dsc syntax
- dsc = daklib.utils.parse_changes(filename)
+ dsc = utils.parse_changes(filename)
except:
- daklib.utils.fubar("error parsing .dsc file '%s'." % (filename))
- dsc_files = daklib.utils.build_file_list(dsc, is_a_dsc=1)
+ utils.fubar("error parsing .dsc file '%s'." % (filename))
+ dsc_files = utils.build_file_list(dsc, is_a_dsc=1)
has_tar = 0
- for file in dsc_files.keys():
- m = daklib.utils.re_issource.match(file)
+ for f in dsc_files.keys():
+ m = utils.re_issource.match(f)
if not m:
- daklib.utils.fubar("%s not recognised as source." % (file))
- type = m.group(3)
- if type == "orig.tar.gz" or type == "tar.gz":
+ utils.fubar("%s not recognised as source." % (f))
+ ftype = m.group(3)
+ if ftype == "orig.tar.gz" or ftype == "tar.gz":
has_tar = 1
if not has_tar:
- daklib.utils.warn("%s has no .tar.gz in the .dsc file." % (file))
+ utils.warn("%s has no .tar.gz in the .dsc file." % (f))
count += 1
if count:
- daklib.utils.warn("Found %s invalid .dsc files." % (count))
+ utils.warn("Found %s invalid .dsc files." % (count))
################################################################################
filename = "%s/dists/%s/%s/source/Sources.gz" % (Cnf["Dir::Root"], suite, component)
print "Processing %s..." % (filename)
# apt_pkg.ParseTagFile needs a real file handle and can't handle a GzipFile instance...
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
(result, output) = commands.getstatusoutput("gunzip -c %s > %s" % (filename, temp_filename))
if (result != 0):
sys.stderr.write("Gunzip invocation failed!\n%s\n" % (output))
sys.exit(result)
- sources = daklib.utils.open_file(temp_filename)
+ sources = utils.open_file(temp_filename)
Sources = apt_pkg.ParseTagFile(sources)
while Sources.Step():
source = Sources.Section.Find('Package')
if directory.find("potato") == -1:
print "W: %s missing." % (filename)
else:
- pool_location = daklib.utils.poolify (source, component)
+ pool_location = utils.poolify (source, component)
pool_filename = "%s/%s/%s" % (Cnf["Dir::Pool"], pool_location, name)
if not os.path.exists(pool_filename):
print "E: %s missing (%s)." % (filename, pool_filename)
# Create symlink
pool_filename = os.path.normpath(pool_filename)
filename = os.path.normpath(filename)
- src = daklib.utils.clean_symlink(pool_filename, filename, Cnf["Dir::Root"])
+ src = utils.clean_symlink(pool_filename, filename, Cnf["Dir::Root"])
print "Symlinking: %s -> %s" % (filename, src)
#os.symlink(src, filename)
sources.close()
% (Cnf["Dir::Root"], suite, component, architecture)
print "Processing %s..." % (filename)
# apt_pkg.ParseTagFile needs a real file handle and can't handle a GzipFile instance...
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
(result, output) = commands.getstatusoutput("gunzip -c %s > %s" % (filename, temp_filename))
if (result != 0):
sys.stderr.write("Gunzip invocation failed!\n%s\n" % (output))
sys.exit(result)
- packages = daklib.utils.open_file(temp_filename)
+ packages = utils.open_file(temp_filename)
Packages = apt_pkg.ParseTagFile(packages)
while Packages.Step():
filename = "%s/%s" % (Cnf["Dir::Root"], Packages.Section.Find('Filename'))
print "done. (%d seconds)" % (int(time.time()-before))
q_files = q.getresult()
-# locations = {}
-# q = projectB.query("SELECT l.path, c.name, l.id FROM location l, component c WHERE l.component = c.id")
-# for i in q.getresult():
-# path = os.path.normpath(i[0] + i[1])
-# locations[path] = (i[0], i[2])
-
-# q = projectB.query("BEGIN WORK")
for i in q_files:
filename = os.path.normpath(i[0] + i[1])
-# file_id = i[2]
if os.access(filename, os.R_OK) == 0:
- daklib.utils.warn("%s: doesn't exist." % (filename))
+ utils.warn("%s: doesn't exist." % (filename))
else:
if os.path.islink(filename):
- daklib.utils.warn("%s: is a symlink." % (filename))
- # You probably don't want to use the rest of this...
-# print "%s: is a symlink." % (filename)
-# dest = os.readlink(filename)
-# if not os.path.isabs(dest):
-# dest = os.path.normpath(os.path.join(os.path.dirname(filename), dest))
-# print "--> %s" % (dest)
-# # Determine suitable location ID
-# # [in what must be the suckiest way possible?]
-# location_id = None
-# for path in locations.keys():
-# if dest.find(path) == 0:
-# (location, location_id) = locations[path]
-# break
-# if not location_id:
-# daklib.utils.fubar("Can't find location for %s (%s)." % (dest, filename))
-# new_filename = dest.replace(location, "")
-# q = projectB.query("UPDATE files SET filename = '%s', location = %s WHERE id = %s" % (new_filename, location_id, file_id))
-# q = projectB.query("COMMIT WORK")
+ utils.warn("%s: is a symlink." % (filename))
################################################################################
if not name.endswith(".dsc"):
continue
filename = os.path.abspath(dirname+'/'+name)
- dsc = daklib.utils.parse_changes(filename)
+ dsc = utils.parse_changes(filename)
for field_name in [ "build-depends", "build-depends-indep" ]:
field = dsc.get(field_name)
if field:
def main ():
global Cnf, projectB, db_files, waste, excluded
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Check-Archive::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Check-Archive::Options::%s" % (i)):
usage()
if len(args) < 1:
- daklib.utils.warn("dak check-archive requires at least one argument")
+ utils.warn("dak check-archive requires at least one argument")
usage(1)
elif len(args) > 1:
- daklib.utils.warn("dak check-archive accepts only one argument")
+ utils.warn("dak check-archive accepts only one argument")
usage(1)
mode = args[0].lower()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
if mode == "md5sums":
check_md5sums()
elif mode == "validate-builddeps":
check_build_depends()
else:
- daklib.utils.warn("unknown mode '%s'" % (mode))
+ utils.warn("unknown mode '%s'" % (mode))
usage(1)
################################################################################
import pg, sys, os
import apt_pkg
-import daklib.database
-import daklib.logging
-import daklib.utils
+import daklib.database as database
+import daklib.logging as logging
+import daklib.utils as utils
################################################################################
def process(osuite, affected_suites, originosuite, component, type):
global Logger, Options, projectB, sections, priorities
- osuite_id = daklib.database.get_suite_id(osuite)
+ osuite_id = database.get_suite_id(osuite)
if osuite_id == -1:
- daklib.utils.fubar("Suite '%s' not recognised." % (osuite))
+ utils.fubar("Suite '%s' not recognised." % (osuite))
originosuite_id = None
if originosuite:
- originosuite_id = daklib.database.get_suite_id(originosuite)
+ originosuite_id = database.get_suite_id(originosuite)
if originosuite_id == -1:
- daklib.utils.fubar("Suite '%s' not recognised." % (originosuite))
+ utils.fubar("Suite '%s' not recognised." % (originosuite))
- component_id = daklib.database.get_component_id(component)
+ component_id = database.get_component_id(component)
if component_id == -1:
- daklib.utils.fubar("Component '%s' not recognised." % (component))
+ utils.fubar("Component '%s' not recognised." % (component))
- type_id = daklib.database.get_override_type_id(type)
+ type_id = database.get_override_type_id(type)
if type_id == -1:
- daklib.utils.fubar("Type '%s' not recognised. (Valid types are deb, udeb and dsc)" % (type))
- dsc_type_id = daklib.database.get_override_type_id("dsc")
- deb_type_id = daklib.database.get_override_type_id("deb")
+ utils.fubar("Type '%s' not recognised. (Valid types are deb, udeb and dsc)" % (type))
+ dsc_type_id = database.get_override_type_id("dsc")
- source_priority_id = daklib.database.get_priority_id("source")
+ source_priority_id = database.get_priority_id("source")
if type == "deb" or type == "udeb":
packages = {}
src_packages[package] = 1
else:
if blacklist.has_key(package):
- daklib.utils.warn("%s in incoming, not touching" % package)
+ utils.warn("%s in incoming, not touching" % package)
continue
Logger.log(["removing unused override", osuite, component,
type, package, priorities[i[1]], sections[i[2]], i[3]])
for package, hasoverride in src_packages.items():
if not hasoverride:
- daklib.utils.warn("%s has no override!" % package)
+ utils.warn("%s has no override!" % package)
else: # binary override
for i in q.getresult():
packages[package] = 1
else:
if blacklist.has_key(package):
- daklib.utils.warn("%s in incoming, not touching" % package)
+ utils.warn("%s in incoming, not touching" % package)
continue
Logger.log(["removing unused override", osuite, component,
type, package, priorities[i[1]], sections[i[2]], i[3]])
for package, hasoverride in packages.items():
if not hasoverride:
- daklib.utils.warn("%s has no override!" % package)
+ utils.warn("%s has no override!" % package)
projectB.query("COMMIT WORK")
sys.stdout.flush()
def main ():
global Logger, Options, projectB, sections, priorities
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Check-Overrides::Options::Help"),
('n',"no-action", "Check-Overrides::Options::No-Action")]
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
# init sections, priorities:
q = projectB.query("SELECT id, section FROM section")
priorities[i[0]] = i[1]
if not Options["No-Action"]:
- Logger = daklib.logging.Logger(Cnf, "check-overrides")
+ Logger = logging.Logger(Cnf, "check-overrides")
else:
- Logger = daklib.logging.Logger(Cnf, "check-overrides", 1)
+ Logger = logging.Logger(Cnf, "check-overrides", 1)
gen_blacklist(Cnf["Dir::Queue::Accepted"])
suiteids.append(i[0])
if len(suiteids) != len(suites) or len(suiteids) < 1:
- daklib.utils.fubar("Couldn't find id's of all suites: %s" % suites)
+ utils.fubar("Couldn't find id's of all suites: %s" % suites)
for component in Cnf.SubTree("Component").List():
if component == "mixed":
import pg, sys, os
import apt_pkg, apt_inst
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
if stable[dep].has_key(arch):
if apt_pkg.CheckDep(stable[dep][arch], constraint, version):
if Options["debug"]:
- print "Found %s as a real package." % (daklib.utils.pp_deps(parsed_dep))
+ print "Found %s as a real package." % (utils.pp_deps(parsed_dep))
unsat = 0
break
# As a virtual?
if stable_virtual[dep].has_key(arch):
if not constraint and not version:
if Options["debug"]:
- print "Found %s as a virtual package." % (daklib.utils.pp_deps(parsed_dep))
+ print "Found %s as a virtual package." % (utils.pp_deps(parsed_dep))
unsat = 0
break
# As part of the same .changes?
- epochless_version = daklib.utils.re_no_epoch.sub('', version)
+ epochless_version = utils.re_no_epoch.sub('', version)
dep_filename = "%s_%s_%s.deb" % (dep, epochless_version, arch)
if files.has_key(dep_filename):
if Options["debug"]:
- print "Found %s in the same upload." % (daklib.utils.pp_deps(parsed_dep))
+ print "Found %s in the same upload." % (utils.pp_deps(parsed_dep))
unsat = 0
break
# Not found...
# [FIXME: must be a better way ... ]
- error = "%s not found. [Real: " % (daklib.utils.pp_deps(parsed_dep))
+ error = "%s not found. [Real: " % (utils.pp_deps(parsed_dep))
if stable.has_key(dep):
if stable[dep].has_key(arch):
error += "%s:%s:%s" % (dep, arch, stable[dep][arch])
unsat.append(error)
if unsat:
- sys.stderr.write("MWAAP! %s: '%s' %s can not be satisifed:\n" % (filename, daklib.utils.pp_deps(parsed_dep), dep_type))
+ sys.stderr.write("MWAAP! %s: '%s' %s can not be satisifed:\n" % (filename, utils.pp_deps(parsed_dep), dep_type))
for error in unsat:
sys.stderr.write(" %s\n" % (error))
pkg_unsat = 1
def check_package(filename, files):
try:
- control = apt_pkg.ParseSection(apt_inst.debExtractControl(daklib.utils.open_file(filename)))
+ control = apt_pkg.ParseSection(apt_inst.debExtractControl(utils.open_file(filename)))
except:
- daklib.utils.warn("%s: debExtractControl() raised %s." % (filename, sys.exc_type))
+ utils.warn("%s: debExtractControl() raised %s." % (filename, sys.exc_type))
return 1
Depends = control.Find("Depends")
Pre_Depends = control.Find("Pre-Depends")
def check_changes (filename):
try:
- changes = daklib.utils.parse_changes(filename)
- files = daklib.utils.build_file_list(changes)
+ changes = utils.parse_changes(filename)
+ files = utils.build_file_list(changes)
except:
- daklib.utils.warn("Error parsing changes file '%s'" % (filename))
+ utils.warn("Error parsing changes file '%s'" % (filename))
return
result = 0
# Move to the pool directory
cwd = os.getcwd()
- file = files.keys()[0]
- pool_dir = Cnf["Dir::Pool"] + '/' + daklib.utils.poolify(changes["source"], files[file]["component"])
+ f = files.keys()[0]
+ pool_dir = Cnf["Dir::Pool"] + '/' + utils.poolify(changes["source"], files[f]["component"])
os.chdir(pool_dir)
changes_result = 0
- for file in files.keys():
- if file.endswith(".deb"):
- result = check_package(file, files)
+ for f in files.keys():
+ if f.endswith(".deb"):
+ result = check_package(f, files)
if Options["verbose"]:
- pass_fail(file, result)
+ pass_fail(f, result)
changes_result += result
pass_fail (filename, changes_result)
################################################################################
def check_joey (filename):
- file = daklib.utils.open_file(filename)
+ f = utils.open_file(filename)
cwd = os.getcwd()
os.chdir("%s/dists/proposed-updates" % (Cnf["Dir::Root"]))
- for line in file.readlines():
+ for line in f.readlines():
line = line.rstrip()
if line.find('install') != -1:
split_line = line.split()
if len(split_line) != 2:
- daklib.utils.fubar("Parse error (not exactly 2 elements): %s" % (line))
+ utils.fubar("Parse error (not exactly 2 elements): %s" % (line))
install_type = split_line[0]
if install_type not in [ "install", "install-u", "sync-install" ]:
- daklib.utils.fubar("Unknown install type ('%s') from: %s" % (install_type, line))
+ utils.fubar("Unknown install type ('%s') from: %s" % (install_type, line))
changes_filename = split_line[1]
if Options["debug"]:
print "Processing %s..." % (changes_filename)
check_changes(changes_filename)
- file.close()
+ f.close()
os.chdir(cwd)
suite = "stable"
stable = {}
components = Cnf.ValueList("Suite::%s::Components" % (suite))
- architectures = filter(daklib.utils.real_arch, Cnf.ValueList("Suite::%s::Architectures" % (suite)))
+ architectures = filter(utils.real_arch, Cnf.ValueList("Suite::%s::Architectures" % (suite)))
for component in components:
for architecture in architectures:
filename = "%s/dists/%s/%s/binary-%s/Packages" % (Cnf["Dir::Root"], suite, component, architecture)
- packages = daklib.utils.open_file(filename, 'r')
+ packages = utils.open_file(filename, 'r')
Packages = apt_pkg.ParseTagFile(packages)
while Packages.Step():
package = Packages.Section.Find('Package')
def main ():
global Cnf, projectB, Options
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('d', "debug", "Check-Proposed-Updates::Options::Debug"),
('q',"quiet","Check-Proposed-Updates::Options::Quiet"),
if Options["Help"]:
usage(0)
if not arguments:
- daklib.utils.fubar("need at least one package name as an argument.")
+ utils.fubar("need at least one package name as an argument.")
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
print "Parsing packages files...",
parse_packages()
print "done."
- for file in arguments:
- if file.endswith(".changes"):
- check_changes(file)
- elif file.endswith(".deb"):
- check_deb(file)
- elif file.endswith(".joey"):
- check_joey(file)
+ for f in arguments:
+ if f.endswith(".changes"):
+ check_changes(f)
+ elif f.endswith(".deb"):
+ check_deb(f)
+ elif f.endswith(".joey"):
+ check_joey(f)
else:
- daklib.utils.fubar("Unrecognised file type: '%s'." % (file))
+ utils.fubar("Unrecognised file type: '%s'." % (f))
#######################################################################################
import os, pg, re, sys
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
def check_changes (filename):
try:
- changes = daklib.utils.parse_changes(filename)
- files = daklib.utils.build_file_list(changes)
+ changes = utils.parse_changes(filename)
+ files = utils.build_file_list(changes)
except:
- daklib.utils.warn("Couldn't read changes file '%s'." % (filename))
+ utils.warn("Couldn't read changes file '%s'." % (filename))
return
num_files = len(files.keys())
- for file in files.keys():
- if daklib.utils.re_isadeb.match(file):
- m = re_isdeb.match(file)
+ for f in files.keys():
+ if utils.re_isadeb.match(f):
+ m = re_isdeb.match(f)
pkg = m.group(1)
version = m.group(2)
arch = m.group(3)
if Options["debug"]:
- print "BINARY: %s ==> %s_%s_%s" % (file, pkg, version, arch)
+ print "BINARY: %s ==> %s_%s_%s" % (f, pkg, version, arch)
else:
- m = daklib.utils.re_issource.match(file)
+ m = utils.re_issource.match(f)
if m:
pkg = m.group(1)
version = m.group(2)
- type = m.group(3)
- if type != "dsc":
- del files[file]
+ ftype = m.group(3)
+ if ftype != "dsc":
+ del files[f]
num_files -= 1
continue
arch = "source"
if Options["debug"]:
- print "SOURCE: %s ==> %s_%s_%s" % (file, pkg, version, arch)
+ print "SOURCE: %s ==> %s_%s_%s" % (f, pkg, version, arch)
else:
- daklib.utils.fubar("unknown type, fix me")
+ utils.fubar("unknown type, fix me")
if not pu.has_key(pkg):
# FIXME
- daklib.utils.warn("%s doesn't seem to exist in %s?? (from %s [%s])" % (pkg, Options["suite"], file, filename))
+ utils.warn("%s doesn't seem to exist in %s?? (from %s [%s])" % (pkg, Options["suite"], f, filename))
continue
if not pu[pkg].has_key(arch):
# FIXME
- daklib.utils.warn("%s doesn't seem to exist for %s in %s?? (from %s [%s])" % (pkg, arch, Options["suite"], file, filename))
+ utils.warn("%s doesn't seem to exist for %s in %s?? (from %s [%s])" % (pkg, arch, Options["suite"], f, filename))
continue
- pu_version = daklib.utils.re_no_epoch.sub('', pu[pkg][arch])
+ pu_version = utils.re_no_epoch.sub('', pu[pkg][arch])
if pu_version == version:
if Options["verbose"]:
- print "%s: ok" % (file)
+ print "%s: ok" % (f)
else:
if Options["verbose"]:
- print "%s: superseded, removing. [%s]" % (file, pu_version)
- del files[file]
+ print "%s: superseded, removing. [%s]" % (f, pu_version)
+ del files[f]
new_num_files = len(files.keys())
if new_num_files == 0:
print "%s: no files left, superseded by %s" % (filename, pu_version)
dest = Cnf["Dir::Morgue"] + "/misc/"
if not Options["no-action"]:
- daklib.utils.move(filename, dest)
+ utils.move(filename, dest)
elif new_num_files < num_files:
print "%s: lost files, MWAAP." % (filename)
else:
################################################################################
def check_joey (filename):
- file = daklib.utils.open_file(filename)
+ f = utils.open_file(filename)
cwd = os.getcwd()
os.chdir("%s/dists/%s" % (Cnf["Dir::Root"]), Options["suite"])
- for line in file.readlines():
+ for line in f.readlines():
line = line.rstrip()
if line.find('install') != -1:
split_line = line.split()
if len(split_line) != 2:
- daklib.utils.fubar("Parse error (not exactly 2 elements): %s" % (line))
+ utils.fubar("Parse error (not exactly 2 elements): %s" % (line))
install_type = split_line[0]
if install_type not in [ "install", "install-u", "sync-install" ]:
- daklib.utils.fubar("Unknown install type ('%s') from: %s" % (install_type, line))
+ utils.fubar("Unknown install type ('%s') from: %s" % (install_type, line))
changes_filename = split_line[1]
if Options["debug"]:
print "Processing %s..." % (changes_filename)
def main ():
global Cnf, projectB, Options
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('d', "debug", "Clean-Proposed-Updates::Options::Debug"),
('v', "verbose", "Clean-Proposed-Updates::Options::Verbose"),
if Options["Help"]:
usage(0)
if not arguments:
- daklib.utils.fubar("need at least one package name as an argument.")
+ utils.fubar("need at least one package name as an argument.")
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
init_pu()
- for file in arguments:
- if file.endswith(".changes"):
- check_changes(file)
- elif file.endswith(".joey"):
- check_joey(file)
+ for f in arguments:
+ if f.endswith(".changes"):
+ check_changes(f)
+ elif f.endswith(".joey"):
+ check_joey(f)
else:
- daklib.utils.fubar("Unrecognised file type: '%s'." % (file))
+ utils.fubar("Unrecognised file type: '%s'." % (f))
#######################################################################################
import os, stat, sys, time
import apt_pkg
-import daklib.utils
+import daklib.utils as utils
################################################################################
if not os.path.exists(del_dir):
os.makedirs(del_dir, 02775)
if not os.path.isdir(del_dir):
- daklib.utils.fubar("%s must be a directory." % (del_dir))
+ utils.fubar("%s must be a directory." % (del_dir))
# Move to the directory to clean
incoming = Options["Incoming"]
os.chdir(incoming)
# Remove a file to the morgue
-def remove (file):
- if os.access(file, os.R_OK):
- dest_filename = del_dir + '/' + os.path.basename(file)
+def remove (f):
+ if os.access(f, os.R_OK):
+ dest_filename = del_dir + '/' + os.path.basename(f)
# If the destination file exists; try to find another filename to use
if os.path.exists(dest_filename):
- dest_filename = daklib.utils.find_next_free(dest_filename, 10)
- daklib.utils.move(file, dest_filename, 0660)
+ dest_filename = utils.find_next_free(dest_filename, 10)
+ utils.move(f, dest_filename, 0660)
else:
- daklib.utils.warn("skipping '%s', permission denied." % (os.path.basename(file)))
+ utils.warn("skipping '%s', permission denied." % (os.path.basename(f)))
# Removes any old files.
# [Used for Incoming/REJECT]
#
def flush_old ():
- for file in os.listdir('.'):
- if os.path.isfile(file):
- if os.stat(file)[stat.ST_MTIME] < delete_date:
+ for f in os.listdir('.'):
+ if os.path.isfile(f):
+ if os.stat(f)[stat.ST_MTIME] < delete_date:
if Options["No-Action"]:
- print "I: Would delete '%s'." % (os.path.basename(file))
+ print "I: Would delete '%s'." % (os.path.basename(f))
else:
if Options["Verbose"]:
- print "Removing '%s' (to '%s')." % (os.path.basename(file), del_dir)
- remove(file)
+ print "Removing '%s' (to '%s')." % (os.path.basename(f), del_dir)
+ remove(f)
else:
if Options["Verbose"]:
- print "Skipping, too new, '%s'." % (os.path.basename(file))
+ print "Skipping, too new, '%s'." % (os.path.basename(f))
# Removes any files which are old orphans (not associated with a valid .changes file).
# [Used for Incoming]
# Proces all .changes and .dsc files.
for changes_filename in changes_files:
try:
- changes = daklib.utils.parse_changes(changes_filename)
- files = daklib.utils.build_file_list(changes)
+ changes = utils.parse_changes(changes_filename)
+ files = utils.build_file_list(changes)
except:
- daklib.utils.warn("error processing '%s'; skipping it. [Got %s]" % (changes_filename, sys.exc_type))
+ utils.warn("error processing '%s'; skipping it. [Got %s]" % (changes_filename, sys.exc_type))
continue
dsc_files = {}
- for file in files.keys():
- if file.endswith(".dsc"):
+ for f in files.keys():
+ if f.endswith(".dsc"):
try:
- dsc = daklib.utils.parse_changes(file)
- dsc_files = daklib.utils.build_file_list(dsc, is_a_dsc=1)
+ dsc = utils.parse_changes(f)
+ dsc_files = utils.build_file_list(dsc, is_a_dsc=1)
except:
- daklib.utils.warn("error processing '%s'; skipping it. [Got %s]" % (file, sys.exc_type))
+ utils.warn("error processing '%s'; skipping it. [Got %s]" % (f, sys.exc_type))
continue
# Ensure all the files we've seen aren't deleted
# Anthing left at this stage is not referenced by a .changes (or
# a .dsc) and should be deleted if old enough.
- for file in all_files.keys():
- if os.stat(file)[stat.ST_MTIME] < delete_date:
+ for f in all_files.keys():
+ if os.stat(f)[stat.ST_MTIME] < delete_date:
if Options["No-Action"]:
- print "I: Would delete '%s'." % (os.path.basename(file))
+ print "I: Would delete '%s'." % (os.path.basename(f))
else:
if Options["Verbose"]:
- print "Removing '%s' (to '%s')." % (os.path.basename(file), del_dir)
- remove(file)
+ print "Removing '%s' (to '%s')." % (os.path.basename(f), del_dir)
+ remove(f)
else:
if Options["Verbose"]:
- print "Skipping, too new, '%s'." % (os.path.basename(file))
+ print "Skipping, too new, '%s'." % (os.path.basename(f))
################################################################################
def main ():
global Cnf, Options
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
for i in ["Help", "Incoming", "No-Action", "Verbose" ]:
if not Cnf.has_key("Clean-Queues::Options::%s" % (i)):
import os, pg, stat, sys, time
import apt_pkg
-import daklib.utils
+import daklib.utils as utils
################################################################################
for i in q.getresult():
filename = i[0] + i[1]
if not os.path.exists(filename):
- daklib.utils.warn("can not find '%s'." % (filename))
+ utils.warn("can not find '%s'." % (filename))
continue
if os.path.isfile(filename):
if os.path.islink(filename):
dest_filename = dest + '/' + os.path.basename(filename)
# If the destination file exists; try to find another filename to use
if os.path.exists(dest_filename):
- dest_filename = daklib.utils.find_next_free(dest_filename)
+ dest_filename = utils.find_next_free(dest_filename)
if Options["No-Action"]:
print "Cleaning %s -> %s ..." % (filename, dest_filename)
else:
- daklib.utils.move(filename, dest_filename)
+ utils.move(filename, dest_filename)
else:
- daklib.utils.fubar("%s is neither symlink nor file?!" % (filename))
+ utils.fubar("%s is neither symlink nor file?!" % (filename))
# Delete from the 'files' table
if not Options["No-Action"]:
projectB.query("DELETE FROM files WHERE last_used <= '%s'" % (delete_date))
sys.stdout.write("done. (%d seconds)]\n" % (int(time.time()-before)))
if count > 0:
- sys.stderr.write("Cleaned %d files, %s.\n" % (count, daklib.utils.size_type(size)))
+ sys.stderr.write("Cleaned %d files, %s.\n" % (count, utils.size_type(size)))
################################################################################
for i in q.getresult():
filename = i[0]
if not os.path.exists(filename):
- daklib.utils.warn("%s (from queue_build) doesn't exist." % (filename))
+ utils.warn("%s (from queue_build) doesn't exist." % (filename))
continue
if not Cnf.FindB("Dinstall::SecurityQueueBuild") and not os.path.islink(filename):
- daklib.utils.fubar("%s (from queue_build) should be a symlink but isn't." % (filename))
+ utils.fubar("%s (from queue_build) should be a symlink but isn't." % (filename))
os.unlink(filename)
count += 1
projectB.query("DELETE FROM queue_build WHERE last_used <= '%s'" % (our_delete_date))
def main():
global Cnf, Options, projectB, delete_date, now_date
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
for i in ["Help", "No-Action" ]:
if not Cnf.has_key("Clean-Suites::Options::%s" % (i)):
Cnf["Clean-Suites::Options::%s" % (i)] = ""
import pg, sys
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
def main ():
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Compare-Suites::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Compare-Suites::Options::%s" % (i)):
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
src_suite = "stable"
dst_suite = "unstable"
- src_suite_id = daklib.database.get_suite_id(src_suite)
- dst_suite_id = daklib.database.get_suite_id(dst_suite)
- arch_all_id = daklib.database.get_architecture_id("all")
- dsc_type_id = daklib.database.get_override_type_id("dsc")
+ src_suite_id = database.get_suite_id(src_suite)
+ dst_suite_id = database.get_suite_id(dst_suite)
+ arch_all_id = database.get_architecture_id("all")
+ dsc_type_id = database.get_override_type_id("dsc")
for arch in Cnf.ValueList("Suite::%s::Architectures" % (src_suite)):
if arch == "source":
if arch == "all":
continue
- arch_id = daklib.database.get_architecture_id(arch)
+ arch_id = database.get_architecture_id(arch)
q = projectB.query("""
SELECT b_src.package, b_src.version, a.arch_string
FROM binaries b_src, bin_associations ba, override o, architecture a
import pg, sys, time
import apt_pkg
-import daklib.utils, daklib.database, daklib.logging
+import daklib.utils as utils
+import daklib.database as database
+import daklib.logging as logging
################################################################################
################################################################################
def process_file (file, suite, component, type, action):
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
if suite_id == -1:
- daklib.utils.fubar("Suite '%s' not recognised." % (suite))
+ utils.fubar("Suite '%s' not recognised." % (suite))
- component_id = daklib.database.get_component_id(component)
+ component_id = database.get_component_id(component)
if component_id == -1:
- daklib.utils.fubar("Component '%s' not recognised." % (component))
+ utils.fubar("Component '%s' not recognised." % (component))
- type_id = daklib.database.get_override_type_id(type)
+ type_id = database.get_override_type_id(type)
if type_id == -1:
- daklib.utils.fubar("Type '%s' not recognised. (Valid types are deb, udeb and dsc.)" % (type))
+ utils.fubar("Type '%s' not recognised. (Valid types are deb, udeb and dsc.)" % (type))
# --set is done mostly internal for performance reasons; most
# invocations of --set will be updates and making people wait 2-3
start_time = time.time()
projectB.query("BEGIN WORK")
for line in file.readlines():
- line = daklib.utils.re_comments.sub('', line).strip()
+ line = utils.re_comments.sub('', line).strip()
if line == "":
continue
elif len(split_line) == 3:
(package, section, maintainer_override) = split_line
else:
- daklib.utils.warn("'%s' does not break into 'package section [maintainer-override]'." % (line))
+ utils.warn("'%s' does not break into 'package section [maintainer-override]'." % (line))
c_error += 1
continue
priority = "source"
elif len(split_line) == 4:
(package, priority, section, maintainer_override) = split_line
else:
- daklib.utils.warn("'%s' does not break into 'package priority section [maintainer-override]'." % (line))
+ utils.warn("'%s' does not break into 'package priority section [maintainer-override]'." % (line))
c_error += 1
continue
- section_id = daklib.database.get_section_id(section)
+ section_id = database.get_section_id(section)
if section_id == -1:
- daklib.utils.warn("'%s' is not a valid section. ['%s' in suite %s, component %s]." % (section, package, suite, component))
+ utils.warn("'%s' is not a valid section. ['%s' in suite %s, component %s]." % (section, package, suite, component))
c_error += 1
continue
- priority_id = daklib.database.get_priority_id(priority)
+ priority_id = database.get_priority_id(priority)
if priority_id == -1:
- daklib.utils.warn("'%s' is not a valid priority. ['%s' in suite %s, component %s]." % (priority, package, suite, component))
+ utils.warn("'%s' is not a valid priority. ['%s' in suite %s, component %s]." % (priority, package, suite, component))
c_error += 1
continue
if new.has_key(package):
- daklib.utils.warn("Can't insert duplicate entry for '%s'; ignoring all but the first. [suite %s, component %s]" % (package, suite, component))
+ utils.warn("Can't insert duplicate entry for '%s'; ignoring all but the first. [suite %s, component %s]" % (package, suite, component))
c_error += 1
continue
new[package] = ""
################################################################################
-def list(suite, component, type):
- suite_id = daklib.database.get_suite_id(suite)
+def list_overrides(suite, component, type):
+ suite_id = database.get_suite_id(suite)
if suite_id == -1:
- daklib.utils.fubar("Suite '%s' not recognised." % (suite))
+ utils.fubar("Suite '%s' not recognised." % (suite))
- component_id = daklib.database.get_component_id(component)
+ component_id = database.get_component_id(component)
if component_id == -1:
- daklib.utils.fubar("Component '%s' not recognised." % (component))
+ utils.fubar("Component '%s' not recognised." % (component))
- type_id = daklib.database.get_override_type_id(type)
+ type_id = database.get_override_type_id(type)
if type_id == -1:
- daklib.utils.fubar("Type '%s' not recognised. (Valid types are deb, udeb and dsc)" % (type))
+ utils.fubar("Type '%s' not recognised. (Valid types are deb, udeb and dsc)" % (type))
if type == "dsc":
q = projectB.query("SELECT o.package, s.section, o.maintainer FROM override o, section s WHERE o.suite = %s AND o.component = %s AND o.type = %s AND o.section = s.id ORDER BY s.section, o.package" % (suite_id, component_id, type_id))
for i in q.getresult():
- print daklib.utils.result_join(i)
+ print utils.result_join(i)
else:
q = projectB.query("SELECT o.package, p.priority, s.section, o.maintainer, p.level FROM override o, priority p, section s WHERE o.suite = %s AND o.component = %s AND o.type = %s AND o.priority = p.id AND o.section = s.id ORDER BY s.section, p.level, o.package" % (suite_id, component_id, type_id))
for i in q.getresult():
- print daklib.utils.result_join(i[:-1])
+ print utils.result_join(i[:-1])
################################################################################
def main ():
global Cnf, projectB, Logger
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('a', "add", "Control-Overrides::Options::Add"),
('c', "component", "Control-Overrides::Options::Component", "HasArg"),
('h', "help", "Control-Overrides::Options::Help"),
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
action = None
for i in [ "add", "list", "set" ]:
if Cnf["Control-Overrides::Options::%s" % (i)]:
if action:
- daklib.utils.fubar("Can not perform more than one action at once.")
+ utils.fubar("Can not perform more than one action at once.")
action = i
- (suite, component, type) = (Cnf["Control-Overrides::Options::Suite"],
- Cnf["Control-Overrides::Options::Component"],
- Cnf["Control-Overrides::Options::Type"])
+ (suite, component, otype) = (Cnf["Control-Overrides::Options::Suite"],
+ Cnf["Control-Overrides::Options::Component"],
+ Cnf["Control-Overrides::Options::Type"])
if action == "list":
- list(suite, component, type)
+ list_overrides(suite, component, otype)
else:
if Cnf.has_key("Suite::%s::Untouchable" % suite) and Cnf["Suite::%s::Untouchable" % suite] != 0:
- daklib.utils.fubar("%s: suite is untouchable" % suite)
+ utils.fubar("%s: suite is untouchable" % suite)
- Logger = daklib.logging.Logger(Cnf, "control-overrides")
+ Logger = logging.Logger(Cnf, "control-overrides")
if file_list:
- for file in file_list:
- process_file(daklib.utils.open_file(file), suite, component, type, action)
+ for f in file_list:
+ process_file(utils.open_file(f), suite, component, otype, action)
else:
- process_file(sys.stdin, suite, component, type, action)
+ process_file(sys.stdin, suite, component, otype, action)
Logger.close()
#######################################################################################
import pg, sys
import apt_pkg
-import daklib.database
-import daklib.logging
-import daklib.utils
+import daklib.database as database
+import daklib.logging as logging
+import daklib.utils as utils
#######################################################################################
ql = q.getresult()
if not ql:
- daklib.utils.warn("Couldn't find '%s_%s_%s'." % (package, version, architecture))
+ utils.warn("Couldn't find '%s_%s_%s'." % (package, version, architecture))
return None
if len(ql) > 1:
- daklib.utils.warn("Found more than one match for '%s_%s_%s'." % (package, version, architecture))
+ utils.warn("Found more than one match for '%s_%s_%s'." % (package, version, architecture))
return None
- id = ql[0][0]
- return id
+ return ql[0][0]
#######################################################################################
for line in lines:
split_line = line.strip().split()
if len(split_line) != 3:
- daklib.utils.warn("'%s' does not break into 'package version architecture'." % (line[:-1]))
+ utils.warn("'%s' does not break into 'package version architecture'." % (line[:-1]))
continue
key = " ".join(split_line)
desired[key] = ""
for key in current.keys():
if not desired.has_key(key):
(package, version, architecture) = key.split()
- id = current[key]
+ pkid = current[key]
if architecture == "source":
- q = projectB.query("DELETE FROM src_associations WHERE id = %s" % (id))
+ q = projectB.query("DELETE FROM src_associations WHERE id = %s" % (pkid))
else:
- q = projectB.query("DELETE FROM bin_associations WHERE id = %s" % (id))
- Logger.log(["removed",key,id])
+ q = projectB.query("DELETE FROM bin_associations WHERE id = %s" % (pkid))
+ Logger.log(["removed", key, pkid])
# Check to see which packages need added and add them
for key in desired.keys():
if not current.has_key(key):
(package, version, architecture) = key.split()
- id = get_id (package, version, architecture)
- if not id:
+ pkid = get_id (package, version, architecture)
+ if not pkid:
continue
if architecture == "source":
- q = projectB.query("INSERT INTO src_associations (suite, source) VALUES (%s, %s)" % (suite_id, id))
+ q = projectB.query("INSERT INTO src_associations (suite, source) VALUES (%s, %s)" % (suite_id, pkid))
else:
- q = projectB.query("INSERT INTO bin_associations (suite, bin) VALUES (%s, %s)" % (suite_id, id))
- Logger.log(["added",key,id])
+ q = projectB.query("INSERT INTO bin_associations (suite, bin) VALUES (%s, %s)" % (suite_id, pkid))
+ Logger.log(["added", key, pkid])
projectB.query("COMMIT WORK")
def process_file (file, suite, action):
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
if action == "set":
set_suite (file, suite_id)
for line in lines:
split_line = line.strip().split()
if len(split_line) != 3:
- daklib.utils.warn("'%s' does not break into 'package version architecture'." % (line[:-1]))
+ utils.warn("'%s' does not break into 'package version architecture'." % (line[:-1]))
continue
(package, version, architecture) = split_line
- id = get_id(package, version, architecture)
- if not id:
+ pkid = get_id(package, version, architecture)
+ if not pkid:
continue
if architecture == "source":
# Find the existing assoications ID, if any
- q = projectB.query("SELECT id FROM src_associations WHERE suite = %s and source = %s" % (suite_id, id))
+ q = projectB.query("SELECT id FROM src_associations WHERE suite = %s and source = %s" % (suite_id, pkid))
ql = q.getresult()
if not ql:
assoication_id = None
# Take action
if action == "add":
if assoication_id:
- daklib.utils.warn("'%s_%s_%s' already exists in suite %s." % (package, version, architecture, suite))
+ utils.warn("'%s_%s_%s' already exists in suite %s." % (package, version, architecture, suite))
continue
else:
- q = projectB.query("INSERT INTO src_associations (suite, source) VALUES (%s, %s)" % (suite_id, id))
+ q = projectB.query("INSERT INTO src_associations (suite, source) VALUES (%s, %s)" % (suite_id, pkid))
elif action == "remove":
if assoication_id == None:
- daklib.utils.warn("'%s_%s_%s' doesn't exist in suite %s." % (package, version, architecture, suite))
+ utils.warn("'%s_%s_%s' doesn't exist in suite %s." % (package, version, architecture, suite))
continue
else:
q = projectB.query("DELETE FROM src_associations WHERE id = %s" % (assoication_id))
else:
# Find the existing assoications ID, if any
- q = projectB.query("SELECT id FROM bin_associations WHERE suite = %s and bin = %s" % (suite_id, id))
+ q = projectB.query("SELECT id FROM bin_associations WHERE suite = %s and bin = %s" % (suite_id, pkid))
ql = q.getresult()
if not ql:
assoication_id = None
# Take action
if action == "add":
if assoication_id:
- daklib.utils.warn("'%s_%s_%s' already exists in suite %s." % (package, version, architecture, suite))
+ utils.warn("'%s_%s_%s' already exists in suite %s." % (package, version, architecture, suite))
continue
else:
- q = projectB.query("INSERT INTO bin_associations (suite, bin) VALUES (%s, %s)" % (suite_id, id))
+ q = projectB.query("INSERT INTO bin_associations (suite, bin) VALUES (%s, %s)" % (suite_id, pkid))
elif action == "remove":
if assoication_id == None:
- daklib.utils.warn("'%s_%s_%s' doesn't exist in suite %s." % (package, version, architecture, suite))
+ utils.warn("'%s_%s_%s' doesn't exist in suite %s." % (package, version, architecture, suite))
continue
else:
q = projectB.query("DELETE FROM bin_associations WHERE id = %s" % (assoication_id))
#######################################################################################
def get_list (suite):
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
# List binaries
q = projectB.query("SELECT b.package, b.version, a.arch_string FROM binaries b, bin_associations ba, architecture a WHERE ba.suite = %s AND ba.bin = b.id AND b.architecture = a.id" % (suite_id))
ql = q.getresult()
def main ():
global Cnf, projectB, Logger
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('a',"add","Control-Suite::Options::Add", "HasArg"),
('h',"help","Control-Suite::Options::Help"),
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"],int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
action = None
for i in ("add", "list", "remove", "set"):
if Cnf["Control-Suite::Options::%s" % (i)] != "":
suite = Cnf["Control-Suite::Options::%s" % (i)]
- if daklib.database.get_suite_id(suite) == -1:
- daklib.utils.fubar("Unknown suite '%s'." %(suite))
+ if database.get_suite_id(suite) == -1:
+ utils.fubar("Unknown suite '%s'." %(suite))
else:
if action:
- daklib.utils.fubar("Can only perform one action at a time.")
+ utils.fubar("Can only perform one action at a time.")
action = i
# Need an action...
if action == None:
- daklib.utils.fubar("No action specified.")
+ utils.fubar("No action specified.")
# Safety/Sanity check
if action == "set" and suite not in ["testing", "etch-m68k"]:
- daklib.utils.fubar("Will not reset a suite other than testing.")
+ utils.fubar("Will not reset a suite other than testing.")
if action == "list":
get_list(suite)
else:
- Logger = daklib.logging.Logger(Cnf, "control-suite")
+ Logger = logging.Logger(Cnf, "control-suite")
if file_list:
- for file in file_list:
- process_file(daklib.utils.open_file(file), suite, action)
+ for f in file_list:
+ process_file(utils.open_file(f), suite, action)
else:
process_file(sys.stdin, suite, action)
Logger.close()
import commands, pg, os, sys, time
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
################################################################################
def do_nviu():
- experimental_id = daklib.database.get_suite_id("experimental")
+ experimental_id = database.get_suite_id("experimental")
if experimental_id == -1:
return
# Check for packages in experimental obsoleted by versions in unstable
WHERE sa.suite = %s AND sa2.suite = %d AND sa.source = s.id
AND sa2.source = s2.id AND s.source = s2.source
AND versioncmp(s.version, s2.version) < 0""" % (experimental_id,
- daklib.database.get_suite_id("unstable")))
+ database.get_suite_id("unstable")))
ql = q.getresult()
if ql:
nviu_to_remove = []
def main ():
global Cnf, projectB, suite, suite_id, source_binaries, source_versions
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Cruft-Report::Options::Help"),
('m',"mode","Cruft-Report::Options::Mode", "HasArg"),
elif Options["Mode"] == "full":
checks = [ "nbs", "nviu", "obsolete source", "dubious nbs", "bnb", "bms", "anais" ]
else:
- daklib.utils.warn("%s is not a recognised mode - only 'full' or 'daily' are understood." % (Options["Mode"]))
+ utils.warn("%s is not a recognised mode - only 'full' or 'daily' are understood." % (Options["Mode"]))
usage(1)
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
bin_pkgs = {}
src_pkgs = {}
duplicate_bins = {}
suite = Options["Suite"]
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
bin_not_built = {}
for component in components:
filename = "%s/dists/%s/%s/source/Sources.gz" % (Cnf["Dir::Root"], suite, component)
# apt_pkg.ParseTagFile needs a real file handle and can't handle a GzipFile instance...
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
(result, output) = commands.getstatusoutput("gunzip -c %s > %s" % (filename, temp_filename))
if (result != 0):
sys.stderr.write("Gunzip invocation failed!\n%s\n" % (output))
sys.exit(result)
- sources = daklib.utils.open_file(temp_filename)
+ sources = utils.open_file(temp_filename)
Sources = apt_pkg.ParseTagFile(sources)
while Sources.Step():
source = Sources.Section.Find('Package')
if suite != "experimental":
check_components.append('main/debian-installer');
for component in check_components:
- architectures = filter(daklib.utils.real_arch, Cnf.ValueList("Suite::%s::Architectures" % (suite)))
+ architectures = filter(utils.real_arch, Cnf.ValueList("Suite::%s::Architectures" % (suite)))
for architecture in architectures:
filename = "%s/dists/%s/%s/binary-%s/Packages.gz" % (Cnf["Dir::Root"], suite, component, architecture)
# apt_pkg.ParseTagFile needs a real file handle
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
(result, output) = commands.getstatusoutput("gunzip -c %s > %s" % (filename, temp_filename))
if (result != 0):
sys.stderr.write("Gunzip invocation failed!\n%s\n" % (output))
sys.exit(result)
- packages = daklib.utils.open_file(temp_filename)
+ packages = utils.open_file(temp_filename)
Packages = apt_pkg.ParseTagFile(packages)
while Packages.Step():
package = Packages.Section.Find('Package')
bin2source[package]["version"] = version
bin2source[package]["source"] = source
if source.find("(") != -1:
- m = daklib.utils.re_extract_src_version.match(source)
+ m = utils.re_extract_src_version.match(source)
source = m.group(1)
version = m.group(2)
if not bin_pkgs.has_key(package):
import sys
import apt_pkg
-import daklib.queue
-import daklib.utils
+import daklib.queue as queue
+import daklib.utils as utils
################################################################################
################################################################################
def main():
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Decode-Dot-Dak::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Decode-Dot-Dak::Options::%s" % (i)):
if Options["Help"]:
usage()
- k = daklib.queue.Upload(Cnf)
+ k = queue.Upload(Cnf)
for arg in sys.argv[1:]:
- arg = daklib.utils.validate_changes_file_arg(arg,require_changes=-1)
+ arg = utils.validate_changes_file_arg(arg,require_changes=-1)
k.pkg.changes_file = arg
print "%s:" % (arg)
k.init_vars()
del changes[i]
print
if changes:
- daklib.utils.warn("changes still has following unrecognised keys: %s" % (changes.keys()))
+ utils.warn("changes still has following unrecognised keys: %s" % (changes.keys()))
dsc = k.pkg.dsc
print " Dsc:"
del dsc[i]
print
if dsc:
- daklib.utils.warn("dsc still has following unrecognised keys: %s" % (dsc.keys()))
+ utils.warn("dsc still has following unrecognised keys: %s" % (dsc.keys()))
files = k.pkg.files
print " Files:"
- for file in files.keys():
- print " %s:" % (file)
+ for f in files.keys():
+ print " %s:" % (f)
for i in [ "package", "version", "architecture", "type", "size",
"md5sum", "component", "location id", "source package",
"source version", "maintainer", "dbtype", "files id",
"new", "section", "priority", "pool name" ]:
- if files[file].has_key(i):
- print " %s: %s" % (i.capitalize(), files[file][i])
- del files[file][i]
- if files[file]:
- daklib.utils.warn("files[%s] still has following unrecognised keys: %s" % (file, files[file].keys()))
+ if files[f].has_key(i):
+ print " %s: %s" % (i.capitalize(), files[f][i])
+ del files[f][i]
+ if files[f]:
+ utils.warn("files[%s] still has following unrecognised keys: %s" % (f, files[f].keys()))
print
dsc_files = k.pkg.dsc_files
print " Dsc Files:"
- for file in dsc_files.keys():
- print " %s:" % (file)
+ for f in dsc_files.keys():
+ print " %s:" % (f)
# Mandatory fields
for i in [ "size", "md5sum" ]:
- print " %s: %s" % (i.capitalize(), dsc_files[file][i])
- del dsc_files[file][i]
+ print " %s: %s" % (i.capitalize(), dsc_files[f][i])
+ del dsc_files[f][i]
# Optional fields
for i in [ "files id" ]:
- if dsc_files[file].has_key(i):
- print " %s: %s" % (i.capitalize(), dsc_files[file][i])
- del dsc_files[file][i]
- if dsc_files[file]:
- daklib.utils.warn("dsc_files[%s] still has following unrecognised keys: %s" % (file, dsc_files[file].keys()))
+ if dsc_files[f].has_key(i):
+ print " %s: %s" % (i.capitalize(), dsc_files[f][i])
+ del dsc_files[f][i]
+ if dsc_files[f]:
+ utils.warn("dsc_files[%s] still has following unrecognised keys: %s" % (f, dsc_files[f].keys()))
################################################################################
import errno, os, pg, re, sys, md5
import apt_pkg, apt_inst
-import daklib.database, daklib.utils, daklib.queue
+import daklib.database as database
+import daklib.utils as utils
################################################################################
Cnf = None
projectB = None
-Cnf = daklib.utils.get_conf()
+Cnf = utils.get_conf()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
-daklib.database.init(Cnf, projectB)
+database.init(Cnf, projectB)
printed_copyrights = {}
maintainer = ''
arch = ''
- deb_file = daklib.utils.open_file(filename)
+ deb_file = utils.open_file(filename)
try:
extracts = apt_inst.debExtractControl(deb_file)
control = apt_pkg.ParseSection(extracts)
def read_changes_or_dsc (filename):
dsc = {}
- dsc_file = daklib.utils.open_file(filename)
+ dsc_file = utils.open_file(filename)
try:
- dsc = daklib.utils.parse_changes(filename)
+ dsc = utils.parse_changes(filename)
except:
return formatted_text("can't parse .dsc control info")
dsc_file.close()
def get_copyright (deb_filename):
package = re_package.sub(r'\1', deb_filename)
o = os.popen("dpkg-deb -c %s | egrep 'usr(/share)?/doc/[^/]*/copyright' | awk '{print $6}' | head -n 1" % (deb_filename))
- copyright = o.read()[:-1]
+ cright = o.read()[:-1]
- if copyright == "":
+ if cright == "":
return formatted_text("WARNING: No copyright found, please check package manually.")
- doc_directory = re_doc_directory.sub(r'\1', copyright)
+ doc_directory = re_doc_directory.sub(r'\1', cright)
if package != doc_directory:
return formatted_text("WARNING: wrong doc directory (expected %s, got %s)." % (package, doc_directory))
- o = os.popen("dpkg-deb --fsys-tarfile %s | tar xvOf - %s 2>/dev/null" % (deb_filename, copyright))
- copyright = o.read()
- copyrightmd5 = md5.md5(copyright).hexdigest()
+ o = os.popen("dpkg-deb --fsys-tarfile %s | tar xvOf - %s 2>/dev/null" % (deb_filename, cright))
+ cright = o.read()
+ copyrightmd5 = md5.md5(cright).hexdigest()
res = ""
if printed_copyrights.has_key(copyrightmd5) and printed_copyrights[copyrightmd5] != "%s (%s)" % (package, deb_filename):
(printed_copyrights[copyrightmd5]))
else:
printed_copyrights[copyrightmd5] = "%s (%s)" % (package, deb_filename)
- return res+formatted_text(copyright)
+ return res+formatted_text(cright)
def check_dsc (dsc_filename):
(dsc) = read_changes_or_dsc(dsc_filename)
# Read a file, strip the signature and return the modified contents as
# a string.
def strip_pgp_signature (filename):
- file = daklib.utils.open_file (filename)
+ file = utils.open_file (filename)
contents = ""
inside_signature = 0
skip_next = 0
def check_changes (changes_filename):
display_changes(changes_filename)
- changes = daklib.utils.parse_changes (changes_filename)
- files = daklib.utils.build_file_list(changes)
- for file in files.keys():
- if file.endswith(".deb") or file.endswith(".udeb"):
- check_deb(file)
- if file.endswith(".dsc"):
- check_dsc(file)
+ changes = utils.parse_changes (changes_filename)
+ files = utils.build_file_list(changes)
+ for f in files.keys():
+ if f.endswith(".deb") or f.endswith(".udeb"):
+ check_deb(f)
+ if f.endswith(".dsc"):
+ check_dsc(f)
# else: => byhand
def main ():
global Cnf, projectB, db_files, waste, excluded
-# Cnf = daklib.utils.get_conf()
+# Cnf = utils.get_conf()
Arguments = [('h',"help","Examine-Package::Options::Help"),
('H',"html-output","Examine-Package::Options::Html-Output"),
stdout_fd = sys.stdout
- for file in args:
+ for f in args:
try:
if not Options["Html-Output"]:
# Pipe output for each argument through less
# -R added to display raw control chars for colour
sys.stdout = less_fd
try:
- if file.endswith(".changes"):
- check_changes(file)
- elif file.endswith(".deb") or file.endswith(".udeb"):
+ if f.endswith(".changes"):
+ check_changes(f)
+ elif f.endswith(".deb") or f.endswith(".udeb"):
check_deb(file)
- elif file.endswith(".dsc"):
- check_dsc(file)
+ elif f.endswith(".dsc"):
+ check_dsc(f)
else:
- daklib.utils.fubar("Unrecognised file type: '%s'." % (file))
+ utils.fubar("Unrecognised file type: '%s'." % (f))
finally:
if not Options["Html-Output"]:
# Reset stdout here so future less invocations aren't FUBAR
sys.stdout = stdout_fd
except IOError, e:
if errno.errorcode[e.errno] == 'EPIPE':
- daklib.utils.warn("[examine-package] Caught EPIPE; skipping.")
+ 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
#######################################################################################
import ldap, pg, sys, time
import apt_pkg
-import daklib.utils
+import daklib.utils as utils
################################################################################
def main():
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Find-Null-Maintainers::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Find-Null-Maintainers::Options::%s" % (i)):
import sys, os, tempfile
import apt_pkg
-import daklib.utils
+import daklib.utils as utils
################################################################################
os.umask(0002)
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [ ('h', "help", "Generate-Index-Diffs::Options::Help"),
('c', None, "Generate-Index-Diffs::Options::CanonicalPath", "hasArg"),
('p', "patchname", "Generate-Index-Diffs::Options::PatchName", "hasArg"),
o.close()
AptCnf = apt_pkg.newConfiguration()
- apt_pkg.ReadConfigFileISC(AptCnf,daklib.utils.which_apt_conf_file())
+ apt_pkg.ReadConfigFileISC(AptCnf,utils.which_apt_conf_file())
if Options.has_key("RootDir"): Cnf["Dir::Root"] = Options["RootDir"]
elif AptCnf.has_key("bindirectory::%s" % (tree)):
sections = AptCnf["bindirectory::%s::Sections" % (tree)].split()
else:
- aptcnf_filename = os.path.basename(daklib.utils.which_apt_conf_file())
+ aptcnf_filename = os.path.basename(utils.which_apt_conf_file())
print "ALERT: suite %s not in %s, nor untouchable!" % (suite, aptcnf_filename)
continue
import sys, os, popen2, tempfile, stat, time, pg
import apt_pkg
-import daklib.utils
+import daklib.utils as utils
################################################################################
(cat, path, name, ext))
else:
size = os.stat(path + name)[stat.ST_SIZE]
- file_handle = daklib.utils.open_file(path + name)
- except daklib.utils.cant_open_exc:
+ file_handle = utils.open_file(path + name)
+ except utils.cant_open_exc:
print "ALERT: Couldn't open " + path + name
else:
hash = hashop(file_handle)
global Cnf, AptCnf, projectB, out
out = sys.stdout
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Generate-Releases::Options::Help"),
('a',"apt-conf","Generate-Releases::Options::Apt-Conf", "HasArg"),
usage()
if not Options["Apt-Conf"]:
- Options["Apt-Conf"] = daklib.utils.which_apt_conf_file()
+ Options["Apt-Conf"] = utils.which_apt_conf_file()
AptCnf = apt_pkg.newConfiguration()
apt_pkg.ReadConfigFileISC(AptCnf, Options["Apt-Conf"])
elif AptCnf.has_key("bindirectory::%s" % (tree)):
pass
else:
- aptcnf_filename = os.path.basename(daklib.utils.which_apt_conf_file())
+ aptcnf_filename = os.path.basename(utils.which_apt_conf_file())
print "ALERT: suite %s not in %s, nor untouchable!" % (suite, aptcnf_filename)
continue
out.write("Date: %s\n" % (time.strftime("%a, %d %b %Y %H:%M:%S UTC", time.gmtime(time.time()))))
if notautomatic != "":
out.write("NotAutomatic: %s\n" % (notautomatic))
- out.write("Architectures: %s\n" % (" ".join(filter(daklib.utils.real_arch, SuiteBlock.ValueList("Architectures")))))
+ out.write("Architectures: %s\n" % (" ".join(filter(utils.real_arch, SuiteBlock.ValueList("Architectures")))))
if components:
out.write("Components: %s\n" % (" ".join(components)))
release = open(relpath, "w")
#release = open(longsuite.replace("/","_") + "_" + arch + "_" + sec + "_Release", "w")
except IOError:
- daklib.utils.fubar("Couldn't write to " + relpath)
+ utils.fubar("Couldn't write to " + relpath)
release.write("Archive: %s\n" % (suite))
if version != "":
import commands, os, pg, re, sys, time
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
###############################################################################
###############################################################################
def check_signature (filename):
- if not daklib.utils.re_taint_free.match(os.path.basename(filename)):
+ if not utils.re_taint_free.match(os.path.basename(filename)):
reject("!!WARNING!! tainted filename: '%s'." % (filename))
return None
status_read, status_write = os.pipe()
cmd = "gpgv --status-fd %s %s %s" \
- % (status_write, daklib.utils.gpg_keyring_args(), filename)
- (output, status, exit_status) = daklib.utils.gpgv_get_status_output(cmd, status_read, status_write)
+ % (status_write, utils.gpg_keyring_args(), filename)
+ (output, status, exit_status) = utils.gpgv_get_status_output(cmd, status_read, status_write)
# Process the status-fd output
keywords = {}
# Now check for obviously bad things in the processed output
if keywords.has_key("SIGEXPIRED"):
- daklib.utils.warn("%s: signing key has expired." % (filename))
+ utils.warn("%s: signing key has expired." % (filename))
if keywords.has_key("KEYREVOKED"):
reject("key used to sign %s has been revoked." % (filename))
bad = 1
reject("ascii armour of signature was corrupt in %s." % (filename))
bad = 1
if keywords.has_key("NODATA"):
- daklib.utils.warn("no signature found for %s." % (filename))
+ utils.warn("no signature found for %s." % (filename))
return "NOSIG"
#reject("no signature found in %s." % (filename))
#bad = 1
if exit_status and not keywords.has_key("NO_PUBKEY"):
reject("gpgv failed while checking %s." % (filename))
if status.strip():
- reject(daklib.utils.prefix_multi_line_string(status, " [GPG status-fd output:] "), "")
+ reject(utils.prefix_multi_line_string(status, " [GPG status-fd output:] "), "")
else:
- reject(daklib.utils.prefix_multi_line_string(output, " [GPG output:] "), "")
+ reject(utils.prefix_multi_line_string(output, " [GPG output:] "), "")
return None
# Sanity check the good stuff we expect
bad = 1
# Finally ensure there's not something we don't recognise
- known_keywords = daklib.utils.Dict(VALIDSIG="",SIG_ID="",GOODSIG="",BADSIG="",ERRSIG="",
+ known_keywords = utils.Dict(VALIDSIG="",SIG_ID="",GOODSIG="",BADSIG="",ERRSIG="",
SIGEXPIRED="",KEYREVOKED="",NO_PUBKEY="",BADARMOR="",
NODATA="")
projectB.query("DELETE FROM location")
for location in Cnf.SubTree("Location").List():
SubSec = Cnf.SubTree("Location::%s" % (location))
- archive_id = daklib.database.get_archive_id(SubSec["archive"])
+ archive_id = database.get_archive_id(SubSec["archive"])
type = SubSec.Find("type")
if type == "legacy-mixed":
projectB.query("INSERT INTO location (path, archive, type) VALUES ('%s', %d, '%s')" % (location, archive_id, SubSec["type"]))
else:
for component in Cnf.SubTree("Component").List():
- component_id = daklib.database.get_component_id(component)
+ component_id = database.get_component_id(component)
projectB.query("INSERT INTO location (path, component, archive, type) VALUES ('%s', %d, %d, '%s')" %
(location, component_id, archive_id, SubSec["type"]))
if SubSec.has_key(i):
projectB.query("UPDATE suite SET %s = '%s' WHERE suite_name = '%s'" % (i.lower(), SubSec[i], suite.lower()))
for architecture in Cnf.ValueList("Suite::%s::Architectures" % (suite)):
- architecture_id = daklib.database.get_architecture_id (architecture)
+ architecture_id = database.get_architecture_id (architecture)
projectB.query("INSERT INTO suite_architectures (suite, architecture) VALUES (currval('suite_id_seq'), %d)" % (architecture_id))
def update_override_type():
try:
path = q.getresult()[0][0]
except:
- daklib.utils.fubar("[import-archive] get_location_path(): Couldn't get path for %s" % (directory))
+ utils.fubar("[import-archive] get_location_path(): Couldn't get path for %s" % (directory))
location_path_cache[directory] = path
return path
global source_cache, source_query_cache, src_associations_query_cache, dsc_files_query_cache, source_id_serial, src_associations_id_serial, dsc_files_id_serial, source_cache_for_binaries, orig_tar_gz_cache, reject_message
suite = suite.lower()
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
try:
- file = daklib.utils.open_file (filename)
- except daklib.utils.cant_open_exc:
- daklib.utils.warn("can't open '%s'" % (filename))
+ file = utils.open_file (filename)
+ except utils.cant_open_exc:
+ utils.warn("can't open '%s'" % (filename))
return
Scanner = apt_pkg.ParseTagFile(file)
while Scanner.Step() != 0:
package = Scanner.Section["package"]
version = Scanner.Section["version"]
directory = Scanner.Section["directory"]
- dsc_file = os.path.join(Cnf["Dir::Root"], directory, "%s_%s.dsc" % (package, daklib.utils.re_no_epoch.sub('', version)))
+ dsc_file = os.path.join(Cnf["Dir::Root"], directory, "%s_%s.dsc" % (package, utils.re_no_epoch.sub('', version)))
# Sometimes the Directory path is a lie; check in the pool
if not os.path.exists(dsc_file):
if directory.split('/')[0] == "dists":
- directory = Cnf["Dir::PoolRoot"] + daklib.utils.poolify(package, component)
- dsc_file = os.path.join(Cnf["Dir::Root"], directory, "%s_%s.dsc" % (package, daklib.utils.re_no_epoch.sub('', version)))
+ directory = Cnf["Dir::PoolRoot"] + utils.poolify(package, component)
+ dsc_file = os.path.join(Cnf["Dir::Root"], directory, "%s_%s.dsc" % (package, utils.re_no_epoch.sub('', version)))
if not os.path.exists(dsc_file):
- daklib.utils.fubar("%s not found." % (dsc_file))
+ utils.fubar("%s not found." % (dsc_file))
install_date = time.strftime("%Y-%m-%d", time.localtime(os.path.getmtime(dsc_file)))
fingerprint = check_signature(dsc_file)
- fingerprint_id = daklib.database.get_or_set_fingerprint_id(fingerprint)
+ fingerprint_id = database.get_or_set_fingerprint_id(fingerprint)
if reject_message:
- daklib.utils.fubar("%s: %s" % (dsc_file, reject_message))
+ utils.fubar("%s: %s" % (dsc_file, reject_message))
maintainer = Scanner.Section["maintainer"]
maintainer = maintainer.replace("'", "\\'")
- maintainer_id = daklib.database.get_or_set_maintainer_id(maintainer)
+ maintainer_id = database.get_or_set_maintainer_id(maintainer)
location = get_location_path(directory.split('/')[0])
- location_id = daklib.database.get_location_id (location, component, archive)
+ location_id = database.get_location_id (location, component, archive)
if not directory.endswith("/"):
directory += '/'
directory = poolify (directory, location)
if directory != "" and not directory.endswith("/"):
directory += '/'
- no_epoch_version = daklib.utils.re_no_epoch.sub('', version)
+ no_epoch_version = utils.re_no_epoch.sub('', version)
# Add all files referenced by the .dsc to the files table
ids = []
for line in Scanner.Section["files"].split('\n'):
count_total = 0
count_bad = 0
suite = suite.lower()
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
try:
- file = daklib.utils.open_file (filename)
- except daklib.utils.cant_open_exc:
- daklib.utils.warn("can't open '%s'" % (filename))
+ file = utils.open_file (filename)
+ except utils.cant_open_exc:
+ utils.warn("can't open '%s'" % (filename))
return
Scanner = apt_pkg.ParseTagFile(file)
while Scanner.Step() != 0:
version = Scanner.Section["version"]
maintainer = Scanner.Section["maintainer"]
maintainer = maintainer.replace("'", "\\'")
- maintainer_id = daklib.database.get_or_set_maintainer_id(maintainer)
+ maintainer_id = database.get_or_set_maintainer_id(maintainer)
architecture = Scanner.Section["architecture"]
- architecture_id = daklib.database.get_architecture_id (architecture)
+ architecture_id = database.get_architecture_id (architecture)
fingerprint = "NOSIG"
- fingerprint_id = daklib.database.get_or_set_fingerprint_id(fingerprint)
+ fingerprint_id = database.get_or_set_fingerprint_id(fingerprint)
if not Scanner.Section.has_key("source"):
source = package
else:
source = Scanner.Section["source"]
source_version = ""
if source.find("(") != -1:
- m = daklib.utils.re_extract_src_version.match(source)
+ m = utils.re_extract_src_version.match(source)
source = m.group(1)
source_version = m.group(2)
if not source_version:
source_version = version
filename = Scanner.Section["filename"]
location = get_location_path(filename.split('/')[0])
- location_id = daklib.database.get_location_id (location, component, archive)
+ location_id = database.get_location_id (location, component, archive)
filename = poolify (filename, location)
if architecture == "all":
filename = re_arch_from_filename.sub("binary-all", filename)
###############################################################################
def do_sources(sources, suite, component, server):
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
(result, output) = commands.getstatusoutput("gunzip -c %s > %s" % (sources, temp_filename))
if (result != 0):
- daklib.utils.fubar("Gunzip invocation failed!\n%s" % (output), result)
+ utils.fubar("Gunzip invocation failed!\n%s" % (output), result)
print 'Processing '+sources+'...'
process_sources (temp_filename, suite, component, server)
os.unlink(temp_filename)
def do_da_do_da ():
global Cnf, projectB, query_cache, files_query_cache, source_query_cache, src_associations_query_cache, dsc_files_query_cache, bin_associations_query_cache, binaries_query_cache
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('a', "action", "Import-Archive::Options::Action"),
('h', "help", "Import-Archive::Options::Help")]
for i in [ "action", "help" ]:
usage()
if not Options["Action"]:
- daklib.utils.warn("""no -a/--action given; not doing anything.
+ utils.warn("""no -a/--action given; not doing anything.
Please read the documentation before running this script.
""")
usage(1)
print "Re-Creating DB..."
(result, output) = commands.getstatusoutput("psql -f init_pool.sql template1")
if (result != 0):
- daklib.utils.fubar("psql invocation failed!\n", result)
+ utils.fubar("psql invocation failed!\n", result)
print output
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init (Cnf, projectB)
+ database.init (Cnf, projectB)
print "Adding static tables from conf file..."
projectB.query("BEGIN WORK")
update_section()
projectB.query("COMMIT WORK")
- files_query_cache = daklib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"files","w")
- source_query_cache = daklib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"source","w")
- src_associations_query_cache = daklib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"src_associations","w")
- dsc_files_query_cache = daklib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"dsc_files","w")
- binaries_query_cache = daklib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"binaries","w")
- bin_associations_query_cache = daklib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"bin_associations","w")
+ files_query_cache = utils.open_file(Cnf["Import-Archive::ExportDir"]+"files","w")
+ source_query_cache = utils.open_file(Cnf["Import-Archive::ExportDir"]+"source","w")
+ src_associations_query_cache = utils.open_file(Cnf["Import-Archive::ExportDir"]+"src_associations","w")
+ dsc_files_query_cache = utils.open_file(Cnf["Import-Archive::ExportDir"]+"dsc_files","w")
+ binaries_query_cache = utils.open_file(Cnf["Import-Archive::ExportDir"]+"binaries","w")
+ bin_associations_query_cache = utils.open_file(Cnf["Import-Archive::ExportDir"]+"bin_associations","w")
projectB.query("BEGIN WORK")
# Process Sources files to popoulate `source' and friends
sources = Cnf["Dir::Root"] + "dists/" + Cnf["Suite::%s::CodeName" % (suite)] + '/' + component + '/source/' + 'Sources.gz'
do_sources(sources, suite, component, server)
else:
- daklib.utils.fubar("Unknown location type ('%s')." % (type))
+ utils.fubar("Unknown location type ('%s')." % (type))
# Process Packages files to populate `binaries' and friends
elif type == "legacy" or type == "pool":
for suite in Cnf.ValueList("Location::%s::Suites" % (location)):
for component in Cnf.SubTree("Component").List():
- architectures = filter(daklib.utils.real_arch,
+ architectures = filter(utils.real_arch,
Cnf.ValueList("Suite::%s::Architectures" % (suite)))
for architecture in architectures:
packages = Cnf["Dir::Root"] + "dists/" + Cnf["Suite::%s::CodeName" % (suite)] + '/' + component + '/binary-' + architecture + '/Packages'
(result, output) = commands.getstatusoutput("psql %s < add_constraints.sql" % (Cnf["DB::Name"]))
print output
if (result != 0):
- daklib.utils.fubar("psql invocation failed!\n%s" % (output), result)
+ utils.fubar("psql invocation failed!\n%s" % (output), result)
return
################################################################################
def main():
- daklib.utils.try_with_debug(do_da_do_da)
+ utils.try_with_debug(do_da_do_da)
################################################################################
################################################################################
-import daklib.database, daklib.logging
+import daklib.database as database
+import daklib.utils as utils
import sys, os, re
import apt_pkg, pg, ldap, email.Utils
Cnf = None
Options = None
projectB = None
-Logger = None
################################################################################
keys[key]["uid"] = uid
if id != None: continue
- id = daklib.database.get_or_set_uid_id(uid)
+ id = database.get_or_set_uid_id(uid)
byuid[id] = (uid, name)
byname[uid] = (id, name)
keys[x]["uid"] = format % "invalid-uid"
else:
uid = format % keys[x]["email"]
- id = daklib.database.get_or_set_uid_id(uid)
+ id = database.get_or_set_uid_id(uid)
byuid[id] = (uid, keys[x]["name"])
byname[uid] = (id, keys[x]["name"])
keys[x]["uid"] = uid
if any_invalid:
uid = format % "invalid-uid"
- id = daklib.database.get_or_set_uid_id(uid)
+ id = database.get_or_set_uid_id(uid)
byuid[id] = (uid, "ungeneratable user id")
byname[uid] = (id, "ungeneratable user id")
return (byname, byuid)
def main():
global Cnf, projectB, Options
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Import-Keyring::Options::Help"),
('L',"import-ldap-users","Import-Keyring::Options::Import-Ldap-Users"),
('U',"generate-users","Import-Keyring::Options::Generate-Users", "HasArg"),
### Initialise
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
projectB.query("BEGIN WORK")
keyringname = keyring_names[0]
keyring = Keyring(keyringname)
- keyring_id = daklib.database.get_or_set_keyring_id(
+ keyring_id = database.get_or_set_keyring_id(
keyringname.split("/")[-1])
### Generate new uid entries if they're needed (from LDAP or the keyring)
import commands, ldap, pg, re, sys
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
def main():
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Import-LDAP-Fingerprints::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Import-LDAP-Fingerprints::Options::%s" % (i)):
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
LDAPDn = Cnf["Import-LDAP-Fingerprints::LDAPDn"]
LDAPServer = Cnf["Import-LDAP-Fingerprints::LDAPServer"]
fingerprints = entry["keyFingerPrint"]
uid = entry["uid"][0]
name = get_ldap_name(entry)
- uid_id = daklib.database.get_or_set_uid_id(uid)
+ uid_id = database.get_or_set_uid_id(uid)
if not db_uid_name.has_key(uid_id) or db_uid_name[uid_id] != name:
q = projectB.query("UPDATE uid SET name = '%s' WHERE id = %d" % (escape_string(name), uid_id))
q = projectB.query("UPDATE fingerprint SET uid = %s WHERE id = %s" % (uid_id, fingerprint_id))
print "Promoting DM %s to DD %s with keyid 0x%s." % (existing_uid, uid, fingerprint)
else:
- daklib.utils.warn("%s has %s in LDAP, but projectB says it should be %s." % (uid, fingerprint, existing_uid))
+ utils.warn("%s has %s in LDAP, but projectB says it should be %s." % (uid, fingerprint, existing_uid))
# Try to update people who sign with non-primary key
q = projectB.query("SELECT fingerprint, id FROM fingerprint WHERE uid is null")
for i in q.getresult():
(fingerprint, fingerprint_id) = i
cmd = "gpg --no-default-keyring %s --fingerprint %s" \
- % (daklib.utils.gpg_keyring_args(), fingerprint)
+ % (utils.gpg_keyring_args(), fingerprint)
(result, output) = commands.getstatusoutput(cmd)
if result == 0:
m = re_gpg_fingerprint.search(output)
if not m:
print output
- daklib.utils.fubar("0x%s: No fingerprint found in gpg output but it returned 0?\n%s" % (fingerprint, daklib.utils.prefix_multi_line_string(output, " [GPG output:] ")))
+ utils.fubar("0x%s: No fingerprint found in gpg output but it returned 0?\n%s" % (fingerprint, utils.prefix_multi_line_string(output, " [GPG output:] ")))
primary_key = m.group(1)
primary_key = primary_key.replace(" ","")
if not ldap_fin_uid_id.has_key(primary_key):
- daklib.utils.warn("0x%s (from 0x%s): no UID found in LDAP" % (primary_key, fingerprint))
+ utils.warn("0x%s (from 0x%s): no UID found in LDAP" % (primary_key, fingerprint))
else:
(uid, uid_id) = ldap_fin_uid_id[primary_key]
q = projectB.query("UPDATE fingerprint SET uid = %s WHERE id = %s" % (uid_id, fingerprint_id))
for keyring in Cnf.ValueList("Import-LDAP-Fingerprints::ExtraKeyrings"):
extra_keyrings += " --keyring=%s" % (keyring)
cmd = "gpg %s %s --list-key %s" \
- % (daklib.utils.gpg_keyring_args(), extra_keyrings, fingerprint)
+ % (utils.gpg_keyring_args(), extra_keyrings, fingerprint)
(result, output) = commands.getstatusoutput(cmd)
if result != 0:
cmd = "gpg --keyserver=%s --allow-non-selfsigned-uid --recv-key %s" % (Cnf["Import-LDAP-Fingerprints::KeyServer"], fingerprint)
# FIXME: default to the guessed ID
uid = None
while not uid:
- uid = daklib.utils.our_raw_input("Map to which UID ? ")
+ uid = utils.our_raw_input("Map to which UID ? ")
Attrs = l.search_s(LDAPDn,ldap.SCOPE_ONELEVEL,"(uid=%s)" % (uid), ["cn","mn","sn"])
if not Attrs:
print "That UID doesn't exist in LDAP!"
entry = Attrs[0][1]
name = get_ldap_name(entry)
prompt = "Map to %s - %s (y/N) ? " % (uid, name.replace(" "," "))
- yn = daklib.utils.our_raw_input(prompt).lower()
+ yn = utils.our_raw_input(prompt).lower()
if yn == "y":
- uid_id = daklib.database.get_or_set_uid_id(uid)
+ uid_id = database.get_or_set_uid_id(uid)
projectB.query("UPDATE fingerprint SET uid = %s WHERE id = %s" % (uid_id, fingerprint_id))
print "Assigning %s to 0x%s." % (uid, fingerprint)
else:
import pg, pwd, sys
import apt_pkg
-import daklib.utils
+import daklib.utils as utils
################################################################################
def main ():
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('n', "no-action", "Import-Users-From-Passwd::Options::No-Action"),
('q', "quiet", "Import-Users-From-Passwd::Options::Quiet"),
if Options["Help"]:
usage()
elif arguments:
- daklib.utils.warn("dak import-users-from-passwd takes no non-option arguments.")
+ utils.warn("dak import-users-from-passwd takes no non-option arguments.")
usage(1)
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
import pg, sys
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
projectB.query("DELETE FROM location")
for location in Cnf.SubTree("Location").List():
location_config = Cnf.SubTree("Location::%s" % (location))
- archive_id = daklib.database.get_archive_id(location_config["Archive"])
+ archive_id = database.get_archive_id(location_config["Archive"])
if archive_id == -1:
- daklib.utils.fubar("Archive '%s' for location '%s' not found."
+ utils.fubar("Archive '%s' for location '%s' not found."
% (location_config["Archive"], location))
location_type = location_config.get("type")
if location_type == "legacy-mixed":
% (location, archive_id, location_config["type"]))
elif location_type == "legacy" or location_type == "pool":
for component in Cnf.SubTree("Component").List():
- component_id = daklib.database.get_component_id(component)
+ component_id = database.get_component_id(component)
projectB.query("INSERT INTO location (path, component, "
"archive, type) VALUES ('%s', %d, %d, '%s')"
% (location, component_id, archive_id,
location_type))
else:
- daklib.utils.fubar("E: type '%s' not recognised in location %s."
+ utils.fubar("E: type '%s' not recognised in location %s."
% (location_type, location))
projectB.query("COMMIT WORK")
"description) VALUES ('%s', %s, %s, %s)"
% (suite.lower(), version, origin, description))
for architecture in Cnf.ValueList("Suite::%s::Architectures" % (suite)):
- architecture_id = daklib.database.get_architecture_id (architecture)
+ architecture_id = database.get_architecture_id (architecture)
if architecture_id < 0:
- daklib.utils.fubar("architecture '%s' not found in architecture"
+ utils.fubar("architecture '%s' not found in architecture"
" table for suite %s."
% (architecture, suite))
projectB.query("INSERT INTO suite_architectures (suite, "
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
arguments = [('h', "help", "Init-DB::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Init-DB::Options::%s" % (i)):
if options["Help"]:
usage()
elif arguments:
- daklib.utils.warn("dak init-db takes no arguments.")
+ utils.warn("dak init-db takes no arguments.")
usage(exit_code=1)
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"],
int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
do_archive()
do_architecture()
import os, sys
import apt_pkg
-import daklib.utils
+import daklib.utils as utils
################################################################################
if os.path.exists(target):
if not os.path.isdir(target):
- daklib.utils.fubar("%s (%s) is not a directory."
+ utils.fubar("%s (%s) is not a directory."
% (target, config_name))
else:
print "Creating %s ..." % (target)
global AptCnf, Cnf
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
arguments = [('h', "help", "Init-Dirs::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Init-Dirs::Options::%s" % (i)):
if options["Help"]:
usage()
elif arguments:
- daklib.utils.warn("dak init-dirs takes no arguments.")
+ utils.warn("dak init-dirs takes no arguments.")
usage(exit_code=1)
AptCnf = apt_pkg.newConfiguration()
- apt_pkg.ReadConfigFileISC(AptCnf, daklib.utils.which_apt_conf_file())
+ apt_pkg.ReadConfigFileISC(AptCnf, utils.which_apt_conf_file())
create_directories()
import os, pg, sys
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
def main ():
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('a', "architecture", "Ls::Options::Architecture", "HasArg"),
('b', "binarytype", "Ls::Options::BinaryType", "HasArg"),
if Options["Help"]:
usage()
if not packages:
- daklib.utils.fubar("need at least one package name as an argument.")
+ utils.fubar("need at least one package name as an argument.")
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
# If cron.daily is running; warn the user that our output might seem strange
if os.path.exists(os.path.join(Cnf["Dir::Root"], "Archive_Maintenance_In_Progress")):
- daklib.utils.warn("Archive maintenance is in progress; database inconsistencies are possible.")
+ utils.warn("Archive maintenance is in progress; database inconsistencies are possible.")
# Handle buildd maintenance helper options
if Options["GreaterOrEqual"] or Options["GreaterThan"]:
if Options["GreaterOrEqual"] and Options["GreaterThan"]:
- daklib.utils.fubar("-g/--greaterorequal and -G/--greaterthan are mutually exclusive.")
+ utils.fubar("-g/--greaterorequal and -G/--greaterthan are mutually exclusive.")
if not Options["Suite"]:
Options["Suite"] = "unstable"
# Parse -a/--architecture, -c/--component and -s/--suite
(con_suites, con_architectures, con_components, check_source) = \
- daklib.utils.parse_args(Options)
+ utils.parse_args(Options)
if Options["BinaryType"]:
if Options["BinaryType"] != "udeb" and Options["BinaryType"] != "deb":
- daklib.utils.fubar("Invalid binary type. 'udeb' and 'deb' recognised.")
+ utils.fubar("Invalid binary type. 'udeb' and 'deb' recognised.")
con_bintype = "AND b.type = '%s'" % (Options["BinaryType"])
# REMOVE ME TRAMP
if Options["BinaryType"] == "udeb":
suites.sort()
for suite in suites:
arches = d[pkg][version][suite]
- arches.sort(daklib.utils.arch_compare_sw)
+ arches.sort(utils.arch_compare_sw)
if Options["Format"] == "": #normal
sys.stdout.write("%10s | %10s | %13s | " % (pkg, version, suite))
sys.stdout.write(", ".join(arches))
import pg, sys
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
global fixed_maintainer_cache
if not fixed_maintainer_cache.has_key(maintainer):
- fixed_maintainer_cache[maintainer] = daklib.utils.fix_maintainer(maintainer)[0]
+ fixed_maintainer_cache[maintainer] = utils.fix_maintainer(maintainer)[0]
return fixed_maintainer_cache[maintainer]
def get_maintainer (maintainer):
- return fix_maintainer(daklib.database.get_maintainer(maintainer))
+ return fix_maintainer(database.get_maintainer(maintainer))
def get_maintainer_from_source (source_id):
global maintainer_from_source_cache
def main():
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Make-Maintainers::Options::Help")]
if not Cnf.has_key("Make-Maintainers::Options::Help"):
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
for suite in Cnf.SubTree("Suite").List():
suite = suite.lower()
# Process any additional Maintainer files (e.g. from pseudo packages)
for filename in extra_files:
- file = daklib.utils.open_file(filename)
+ file = utils.open_file(filename)
for line in file.readlines():
- line = daklib.utils.re_comments.sub('', line).strip()
+ line = utils.re_comments.sub('', line).strip()
if line == "":
continue
split = line.split()
import pg, sys
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
def do_list(output_file, suite, component, otype):
global override
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
if suite_id == -1:
- daklib.utils.fubar("Suite '%s' not recognised." % (suite))
+ utils.fubar("Suite '%s' not recognised." % (suite))
- component_id = daklib.database.get_component_id(component)
+ component_id = database.get_component_id(component)
if component_id == -1:
- daklib.utils.fubar("Component '%s' not recognised." % (component))
+ utils.fubar("Component '%s' not recognised." % (component))
- otype_id = daklib.database.get_override_type_id(otype)
+ otype_id = database.get_override_type_id(otype)
if otype_id == -1:
- daklib.utils.fubar("Type '%s' not recognised. (Valid types are deb, udeb and dsc)" % (otype))
+ utils.fubar("Type '%s' not recognised. (Valid types are deb, udeb and dsc)" % (otype))
override.setdefault(suite, {})
override[suite].setdefault(component, {})
q = projectB.query("SELECT o.package, s.section, o.maintainer FROM override o, section s WHERE o.suite = %s AND o.component = %s AND o.type = %s AND o.section = s.id ORDER BY s.section, o.package" % (suite_id, component_id, otype_id))
for i in q.getresult():
override[suite][component][otype][i[0]] = i
- output_file.write(daklib.utils.result_join(i)+'\n')
+ output_file.write(utils.result_join(i)+'\n')
else:
q = projectB.query("SELECT o.package, p.priority, s.section, o.maintainer, p.level FROM override o, priority p, section s WHERE o.suite = %s AND o.component = %s AND o.type = %s AND o.priority = p.id AND o.section = s.id ORDER BY s.section, p.level, o.package" % (suite_id, component_id, otype_id))
for i in q.getresult():
i = i[:-1]; # Strip the priority level
override[suite][component][otype][i[0]] = i
- output_file.write(daklib.utils.result_join(i)+'\n')
+ output_file.write(utils.result_join(i)+'\n')
################################################################################
def main ():
global Cnf, projectB, override
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Make-Overrides::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Make-Overrides::Options::%s" % (i)):
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
for suite in Cnf.SubTree("Check-Overrides::OverrideSuites").List():
if Cnf.has_key("Suite::%s::Untouchable" % suite) and Cnf["Suite::%s::Untouchable" % suite] != 0:
elif otype == "dsc":
suffix = ".src"
filename = "%s/override.%s.%s%s" % (Cnf["Dir::Override"], override_suite, component, suffix)
- output_file = daklib.utils.open_file(filename, 'w')
+ output_file = utils.open_file(filename, 'w')
do_list(output_file, suite, component, otype)
output_file.close()
import copy, os, pg, sys
import apt_pkg
import symlink_dists
-import daklib.database
-import daklib.logging
-import daklib.utils
+import daklib.database as database
+import daklib.logging as logging
+import daklib.utils as utils
################################################################################
def delete_packages(delete_versions, pkg, dominant_arch, suite,
dominant_version, delete_table, delete_col, packages):
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
for version in delete_versions:
delete_unique_id = version[1]
if not packages.has_key(delete_unique_id):
def write_legacy_mixed_filelist(suite, list, packages, dislocated_files):
# Work out the filename
filename = os.path.join(Cnf["Dir::Lists"], "%s_-_all.list" % (suite))
- output = daklib.utils.open_file(filename, "w")
+ output = utils.open_file(filename, "w")
# Generate the final list of files
files = {}
for id in list:
else:
filename = path + filename
if files.has_key(filename):
- daklib.utils.warn("%s (in %s) is duplicated." % (filename, suite))
+ utils.warn("%s (in %s) is duplicated." % (filename, suite))
else:
files[filename] = ""
# Sort the files since apt-ftparchive doesn't
elif type == "deb":
arch = "binary-%s" % (arch)
filename = os.path.join(Cnf["Dir::Lists"], "%s_%s_%s.list" % (suite, component, arch))
- output = daklib.utils.open_file(filename, "w")
+ output = utils.open_file(filename, "w")
# Generate the final list of files
files = {}
for id in list:
else:
filename = path + filename
if files.has_key(pkg):
- daklib.utils.warn("%s (in %s/%s, %s) is duplicated." % (pkg, suite, component, filename))
+ utils.warn("%s (in %s/%s, %s) is duplicated." % (pkg, suite, component, filename))
else:
files[pkg] = filename
# Sort the files since apt-ftparchive doesn't
if not Options["Suite"]:
suites = Cnf.SubTree("Suite").List()
else:
- suites = daklib.utils.split_args(Options["Suite"])
+ suites = utils.split_args(Options["Suite"])
for suite in [ i.lower() for i in suites ]:
d.setdefault(suite, {})
if not Options["Component"]:
components = Cnf.ValueList("Suite::%s::Components" % (suite))
else:
- components = daklib.utils.split_args(Options["Component"])
+ components = utils.split_args(Options["Component"])
udeb_components = Cnf.ValueList("Suite::%s::UdebComponents" % (suite))
udeb_components = udeb_components
for component in components:
if not Options["Architecture"]:
architectures = Cnf.ValueList("Suite::%s::Architectures" % (suite))
else:
- architectures = daklib.utils.split_args(Options["Architectures"])
+ architectures = utils.split_args(Options["Architectures"])
for arch in [ i.lower() for i in architectures ]:
d[suite][component].setdefault(arch, {})
if arch == "source":
if not Options["Suite"]:
return 1
# Otherwise, look in what suites the user specified
- suites = daklib.utils.split_args(Options["Suite"])
+ suites = utils.split_args(Options["Suite"])
if "stable" in suites:
return 1
# If we're only doing a subset of suites, ensure we do enough to
# be able to do arch: all mapping.
if Options["Suite"]:
- suites = daklib.utils.split_args(Options["Suite"])
+ suites = utils.split_args(Options["Suite"])
for suite in suites:
archall_suite = Cnf.get("Make-Suite-File-List::ArchAllMap::%s" % (suite))
if archall_suite and archall_suite not in suites:
- daklib.utils.warn("Adding %s as %s maps Arch: all from it." % (archall_suite, suite))
+ utils.warn("Adding %s as %s maps Arch: all from it." % (archall_suite, suite))
suites.append(archall_suite)
Options["Suite"] = ",".join(suites)
(con_suites, con_architectures, con_components, check_source) = \
- daklib.utils.parse_args(Options)
+ utils.parse_args(Options)
if stable_dislocation_p():
dislocated_files = symlink_dists.find_dislocated_stable(Cnf, projectB)
def main():
global Cnf, projectB, Options, Logger
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('a', "architecture", "Make-Suite-File-List::Options::Architecture", "HasArg"),
('c', "component", "Make-Suite-File-List::Options::Component", "HasArg"),
('h', "help", "Make-Suite-File-List::Options::Help"),
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
- Logger = daklib.logging.Logger(Cnf, "make-suite-file-list")
+ database.init(Cnf, projectB)
+ Logger = logging.Logger(Cnf, "make-suite-file-list")
do_da_do_da()
Logger.close()
################################################################################
-import daklib.queue, daklib.logging, daklib.utils, daklib.database
+import daklib.queue as queue
+import daklib.logging as logging
+import daklib.utils as utils
+import daklib.database as database
import apt_pkg, os, sys, pwd, time, re, commands
re_taint_free = re.compile(r"^['/;\-\+\.~\s\w]+$");
def init():
global Cnf, Upload, Options, Logger
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Cnf["Dinstall::Options::No-Mail"] = "y"
Arguments = [('h', "help", "Security-Install::Options::Help"),
('a', "automatic", "Security-Install::Options::Automatic"),
sys.exit(0)
if len(arguments) == 0:
- daklib.utils.fubar("Process what?")
+ utils.fubar("Process what?")
- Upload = daklib.queue.Upload(Cnf)
+ Upload = queue.Upload(Cnf)
if Options["No-Action"]:
Options["Sudo"] = ""
if not Options["Sudo"] and not Options["No-Action"]:
- Logger = Upload.Logger = daklib.logging.Logger(Cnf, "new-security-install")
+ Logger = Upload.Logger = logging.Logger(Cnf, "new-security-install")
return arguments
changesfiles = {}
for a in arguments:
if "/" in a:
- daklib.utils.fubar("can only deal with files in the current directory")
+ utils.fubar("can only deal with files in the current directory")
if not a.endswith(".changes"):
- daklib.utils.fubar("not a .changes file: %s" % (a))
+ utils.fubar("not a .changes file: %s" % (a))
Upload.init_vars()
Upload.pkg.changes_file = a
Upload.update_vars()
adv_ids = adv_ids.keys()
if len(adv_ids) > 1:
- daklib.utils.fubar("multiple advisories selected: %s" % (", ".join(adv_ids)))
+ utils.fubar("multiple advisories selected: %s" % (", ".join(adv_ids)))
if adv_ids == []:
advisory = None
else:
a = default
while a not in v:
- a = daklib.utils.our_raw_input(p) + default
+ a = utils.our_raw_input(p) + default
a = a[:1].upper()
return v[a]
def yes_no(prompt):
if Options["Automatic"]: return True
while 1:
- answer = daklib.utils.our_raw_input(prompt + " ").lower()
+ answer = utils.our_raw_input(prompt + " ").lower()
if answer in "yn":
return answer == "y"
print "Invalid answer; please try again."
uploads = {}; # uploads[uri] = file_list
changesfiles = {}; # changesfiles[uri] = file_list
package_list = {} # package_list[source_name][version]
- changes_files.sort(daklib.utils.changes_compare)
+ changes_files.sort(utils.changes_compare)
for changes_file in changes_files:
- changes_file = daklib.utils.validate_changes_file_arg(changes_file)
+ changes_file = utils.validate_changes_file_arg(changes_file)
# Reset variables
components = {}
upload_uris = {}
# Build the file list for this .changes file
for file in files.keys():
poolname = os.path.join(Cnf["Dir::Root"], Cnf["Dir::PoolRoot"],
- daklib.utils.poolify(changes["source"], files[file]["component"]),
+ utils.poolify(changes["source"], files[file]["component"]),
file)
file_list.append(poolname)
orig_component = files[file].get("original component", files[file]["component"])
upload_uris[upload_uri] = ""
num_upload_uris = len(upload_uris.keys())
if num_upload_uris == 0:
- daklib.utils.fubar("%s: No valid upload URI found from components (%s)."
+ utils.fubar("%s: No valid upload URI found from components (%s)."
% (changes_file, ", ".join(components.keys())))
elif num_upload_uris > 1:
- daklib.utils.fubar("%s: more than one upload URI (%s) from components (%s)."
+ utils.fubar("%s: more than one upload URI (%s) from components (%s)."
% (changes_file, ", ".join(upload_uris.keys()),
", ".join(components.keys())))
upload_uri = upload_uris.keys()[0]
if not Options["No-Action"]:
filename = "%s/testing-processed" % (Cnf["Dir::Log"])
- file = daklib.utils.open_file(filename, 'a')
+ file = utils.open_file(filename, 'a')
for source in package_list.keys():
for version in package_list[source].keys():
file.write(" ".join([source, version])+'\n')
updated_pkgs = {}; # updated_pkgs[distro][arch][file] = {path,md5,size}
for arg in changes:
- arg = daklib.utils.validate_changes_file_arg(arg)
+ arg = utils.validate_changes_file_arg(arg)
Upload.pkg.changes_file = arg
Upload.init_vars()
Upload.update_vars()
md5 = files[file]["md5sum"]
size = files[file]["size"]
poolname = Cnf["Dir::PoolRoot"] + \
- daklib.utils.poolify(src, files[file]["component"])
+ utils.poolify(src, files[file]["component"])
if arch == "source" and file.endswith(".dsc"):
dscpoolname = poolname
for suite in suites:
Subst["__BCC__"] = "Bcc: %s" % (Cnf["Dinstall::Bcc"])
adv = ""
- archive = Cnf["Archive::%s::PrimaryMirror" % (daklib.utils.where_am_i())]
+ archive = Cnf["Archive::%s::PrimaryMirror" % (utils.where_am_i())]
for suite in updated_pkgs.keys():
ver = Cnf["Suite::%s::Version" % suite]
if ver != "": ver += " "
arches.sort()
adv += "%s updates are available for %s.\n\n" % (
- suite.capitalize(), daklib.utils.join_with_commas_and(arches))
+ suite.capitalize(), utils.join_with_commas_and(arches))
for a in ["source", "all"] + arches:
if not updated_pkgs[suite].has_key(a):
Subst["__ADVISORY_TEXT__"] = adv
- adv = daklib.utils.TemplateSubst(Subst, template)
+ adv = utils.TemplateSubst(Subst, template)
return adv
def spawn(command):
if not re_taint_free.match(command):
- daklib.utils.fubar("Invalid character in \"%s\"." % (command))
+ utils.fubar("Invalid character in \"%s\"." % (command))
if Options["No-Action"]:
print "[%s]" % (command)
else:
(result, output) = commands.getstatusoutput(command)
if (result != 0):
- daklib.utils.fubar("Invocation of '%s' failed:\n%s\n" % (command, output), result)
+ utils.fubar("Invocation of '%s' failed:\n%s\n" % (command, output), result)
##################### ! ! ! N O T E ! ! ! #####################
def sudo(arg, fn, exit):
if Options["Sudo"]:
if advisory == None:
- daklib.utils.fubar("Must set advisory name")
+ utils.fubar("Must set advisory name")
os.spawnl(os.P_WAIT, "/usr/bin/sudo", "/usr/bin/sudo", "-u", "dak", "-H",
"/usr/local/bin/dak", "new-security-install", "-"+arg, "--", advisory)
else:
print "Updating file lists for apt-ftparchive..."
spawn("dak make-suite-file-list")
print "Updating Packages and Sources files..."
- spawn("apt-ftparchive generate %s" % (daklib.utils.which_apt_conf_file()))
+ spawn("apt-ftparchive generate %s" % (utils.which_apt_conf_file()))
print "Updating Release files..."
spawn("dak generate-releases")
print "Triggering security mirrors..."
def do_Disembargo(): sudo("D", _do_Disembargo, True)
def _do_Disembargo():
if os.getcwd() != Cnf["Dir::Queue::Embargoed"].rstrip("/"):
- daklib.utils.fubar("Can only disembargo from %s" % Cnf["Dir::Queue::Embargoed"])
+ utils.fubar("Can only disembargo from %s" % Cnf["Dir::Queue::Embargoed"])
dest = Cnf["Dir::Queue::Unembargoed"]
- emb_q = daklib.database.get_or_set_queue_id("embargoed")
- une_q = daklib.database.get_or_set_queue_id("unembargoed")
+ emb_q = database.get_or_set_queue_id("embargoed")
+ une_q = database.get_or_set_queue_id("unembargoed")
for c in changes:
print "Disembargoing %s" % (c)
Upload.projectB.query("COMMIT WORK")
for file in Upload.pkg.files.keys():
- daklib.utils.copy(file, os.path.join(dest, file))
+ utils.copy(file, os.path.join(dest, file))
os.unlink(file)
for c in changes:
- daklib.utils.copy(c, os.path.join(dest, c))
+ utils.copy(c, os.path.join(dest, c))
os.unlink(c)
k = c[:-8] + ".dak"
- daklib.utils.copy(k, os.path.join(dest, k))
+ utils.copy(k, os.path.join(dest, k))
os.unlink(k)
def do_Reject(): sudo("R", _do_Reject, True)
def do_Edit():
adv_file = "./advisory.%s" % (advisory)
if not os.path.exists(adv_file):
- daklib.utils.copy(Cnf["Dir::Templates"]+"/security-install.advisory", adv_file)
+ utils.copy(Cnf["Dir::Templates"]+"/security-install.advisory", adv_file)
editor = os.environ.get("EDITOR", "vi")
result = os.system("%s %s" % (editor, adv_file))
if result != 0:
- daklib.utils.fubar("%s invocation failed for %s." % (editor, adv_file))
+ utils.fubar("%s invocation failed for %s." % (editor, adv_file))
def do_Show():
adv_file = "./advisory.%s" % (advisory)
add_changes(extras)
if not advisory:
- daklib.utils.fubar("Must specify an advisory id")
+ utils.fubar("Must specify an advisory id")
if not changes:
- daklib.utils.fubar("No changes specified")
+ utils.fubar("No changes specified")
if Options["Approve"]:
advisory_info()
elif what == "Reject":
do_Reject()
else:
- daklib.utils.fubar("Impossible answer '%s', wtf?" % (what))
+ utils.fubar("Impossible answer '%s', wtf?" % (what))
################################################################################
import pg, sys
import apt_pkg
-import daklib.logging
-import daklib.database
-import daklib.utils
+import daklib.logging as logging
+import daklib.database as database
+import daklib.utils as utils
################################################################################
################################################################################
-# Shamelessly stolen from 'dak rm'. Should probably end up in daklib.utils.py
+# Shamelessly stolen from 'dak rm'. Should probably end up in utils.py
def game_over():
- answer = daklib.utils.our_raw_input("Continue (y/N)? ").lower()
+ answer = utils.our_raw_input("Continue (y/N)? ").lower()
if answer != "y":
print "Aborted."
sys.exit(1)
def main ():
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Override::Options::Help"),
('d',"done","Override::Options::Done", "HasArg"),
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
if not arguments:
- daklib.utils.fubar("package name is a required argument.")
+ utils.fubar("package name is a required argument.")
package = arguments.pop(0)
suite = Options["Suite"]
if arguments and len(arguments) > 2:
- daklib.utils.fubar("Too many arguments")
+ utils.fubar("Too many arguments")
if arguments and len(arguments) == 1:
# Determine if the argument is a priority or a section...
elif r[0][1] == 1:
arguments = (".",arg)
else:
- daklib.utils.fubar("%s is not a valid section or priority" % (arg))
+ utils.fubar("%s is not a valid section or priority" % (arg))
# Retrieve current section/priority...
oldsection, oldsourcesection, oldpriority = None, None, None
if q.ntuples() == 0:
continue
if q.ntuples() > 1:
- daklib.utils.fubar("%s is ambiguous. Matches %d packages" % (package,q.ntuples()))
+ utils.fubar("%s is ambiguous. Matches %d packages" % (package,q.ntuples()))
r = q.getresult()
if type == 'binary':
oldsourcesection = r[0][1]
if not oldpriority and not oldsourcesection:
- daklib.utils.fubar("Unable to find package %s" % (package))
+ utils.fubar("Unable to find package %s" % (package))
if oldsection and oldsourcesection and oldsection != oldsourcesection:
# When setting overrides, both source & binary will become the same section
- daklib.utils.warn("Source is in section '%s' instead of '%s'" % (oldsourcesection, oldsection))
+ utils.warn("Source is in section '%s' instead of '%s'" % (oldsourcesection, oldsection))
if not oldsection:
oldsection = oldsourcesection
pg._quote(newsection,"str")))
if q.ntuples() == 0:
- daklib.utils.fubar("Supplied section %s is invalid" % (newsection))
+ utils.fubar("Supplied section %s is invalid" % (newsection))
newsecid = q.getresult()[0][0]
q = projectB.query("SELECT id FROM priority WHERE priority=%s" % (
pg._quote(newpriority,"str")))
if q.ntuples() == 0:
- daklib.utils.fubar("Supplied priority %s is invalid" % (newpriority))
+ utils.fubar("Supplied priority %s is invalid" % (newpriority))
newprioid = q.getresult()[0][0]
if newpriority == oldpriority and newsection == oldsection:
sys.exit(0)
if newpriority and not oldpriority:
- daklib.utils.fubar("Trying to set priority of a source-only package")
+ utils.fubar("Trying to set priority of a source-only package")
# If we're in no-action mode
if Options["No-Action"]:
if not Options.has_key("Done"):
pass
- #daklib.utils.warn("No bugs to close have been specified. Noone will know you have done this.")
+ #utils.warn("No bugs to close have been specified. Noone will know you have done this.")
else:
print "I: Will close bug(s): %s" % (Options["Done"])
game_over()
- Logger = daklib.logging.Logger(Cnf, "override")
+ Logger = logging.Logger(Cnf, "override")
projectB.query("BEGIN WORK")
# We're in "do it" mode, we have something to do... do it
AND override.type != %d
AND suite = (SELECT id FROM suite WHERE suite_name=%s)""" % (
newprioid,
- pg._quote(package,"str"), daklib.database.get_override_type_id("dsc"),
+ pg._quote(package,"str"), database.get_override_type_id("dsc"),
pg._quote(suite,"str") ))
Logger.log(["changed priority",package,oldpriority,newpriority])
Subst["__CC__"] = "X-DAK: dak override\nX-Katie: alicia $Revision: 1.6$"
Subst["__ADMIN_ADDRESS__"] = Cnf["Dinstall::MyAdminAddress"]
Subst["__DISTRO__"] = Cnf["Dinstall::MyDistribution"]
- Subst["__WHOAMI__"] = daklib.utils.whoami()
+ Subst["__WHOAMI__"] = utils.whoami()
summary = "Concerning package %s...\n" % (package)
summary += "Operating on the %s suite\n" % (suite)
summary += "Changed section from %s to %s\n" % (oldsection,newsection)
Subst["__SUMMARY__"] = summary
- for bug in daklib.utils.split_args(Options["Done"]):
+ for bug in utils.split_args(Options["Done"]):
Subst["__BUG_NUMBER__"] = bug
- mail_message = daklib.utils.TemplateSubst(
+ mail_message = utils.TemplateSubst(
Subst,Cnf["Dir::Templates"]+"/override.bug-close")
- daklib.utils.send_mail(mail_message)
+ utils.send_mail(mail_message)
Logger.log(["closed bug",bug])
Logger.close()
import errno, fcntl, os, sys, time, re
import apt_pkg
-import daklib.database
-import daklib.logging
-import daklib.queue
-import daklib.utils
+import daklib.database as database
+import daklib.logging as logging
+import daklib.queue as queue
+import daklib.utils as utils
###############################################################################
# Create the log directory if it doesn't exist
self.log_dir = Cnf["Dir::UrgencyLog"]
if not os.path.exists(self.log_dir) or not os.access(self.log_dir, os.W_OK):
- daklib.utils.warn("UrgencyLog directory %s does not exist or is not writeable, using /srv/ftp.debian.org/tmp/ instead" % (self.log_dir))
+ 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):
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 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"),
if Options["Help"]:
usage()
- Upload = daklib.queue.Upload(Cnf)
+ Upload = queue.Upload(Cnf)
projectB = Upload.projectB
changes = Upload.pkg.changes
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 = queue.re_default_answer.match(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
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 <foo>.reason file
reason_filename = os.path.basename(pkg.changes_file[:-8]) + ".reason"
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])
###############################################################################
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)
+ files[file]["files id"] = 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))
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)
# 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"], 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
u = u.replace("'", "\\'")
u = u.strip()
uploader_ids.append(
- daklib.database.get_or_set_maintainer_id(u))
+ 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))
+ 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))
version = files[file]["version"]
maintainer = files[file]["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"])
+ maintainer_id = database.get_or_set_maintainer_id(maintainer)
+ fingerprint_id = database.get_or_set_fingerprint_id(changes["fingerprint"])
architecture = files[file]["architecture"]
- architecture_id = daklib.database.get_architecture_id (architecture)
+ architecture_id = 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())
+ files[file]["location id"] = database.get_location_id(Cnf["Dir::Pool"],files[file]["component"],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)
+ files[file]["files id"] = database.set_files_id (filename, files[file]["size"], files[file]["md5sum"], files[file]["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))
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))
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
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_location = 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)
+ 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"]))
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)
+ 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)
+ utils.copy(old_filename, Cnf["Dir::Pool"] + new_filename)
+ new_files_id = 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))
# 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)
+ utils.move(file, destination)
Logger.log(["installed", file, files[file]["type"], files[file]["size"], files[file]["architecture"]])
install_bytes += float(files[file]["size"])
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
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)
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"])
+ pool_location = utils.poolify (changes["source"], files[file]["component"])
src = os.path.join(Cnf["Dir::Pool"], pool_location, os.path.basename(file))
if os.path.islink(dest):
os.unlink(dest)
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)
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"
if os.path.exists(new_changelog_filename):
os.unlink (new_changelog_filename)
- new_changelog = daklib.utils.open_file(new_changelog_filename, 'w')
+ new_changelog = 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):
+ elif utils.re_issource.match(file):
new_changelog.write("stable/%s/source/%s\n" % (files[file]["component"], file))
else:
new_changelog.write("%s\n" % (file))
- chop_changes = daklib.queue.re_fdnic.sub("\n", changes["changes"])
+ chop_changes = queue.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
# 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:
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)
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:
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"]:
import copy, errno, os, readline, stat, sys, time
import apt_pkg, apt_inst
import examine_package
-import daklib.database
-import daklib.logging
-import daklib.queue
-import daklib.utils
+import daklib.database as database
+import daklib.logging as logging
+import daklib.queue as queue
+import daklib.utils as utils
# Globals
Cnf = 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 = utils.re_no_epoch.sub('', source_version)
dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version)
found = 0
for q in ["Accepted", "Embargoed", "Unembargoed"]:
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, file))
+ 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)
+ 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:
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 = queue.re_default_answer.match(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
################################################################################
def print_new (new, indexed, file=sys.stdout):
- daklib.queue.check_valid(new)
+ queue.check_valid(new)
broken = 0
index = 0
for pkg in new.keys():
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')
+ temp_filename = utils.temp_filename()
+ temp_file = utils.open_file(temp_filename, '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 = queue.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 queue.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_filename = utils.temp_filename()
+ temp_file = utils.open_file(temp_filename, 'w')
temp_file.write(note)
temp_file.close()
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)
+ temp_file = utils.open_file(temp_filename)
note = temp_file.read().rstrip()
temp_file.close()
print "Note:"
- print daklib.utils.prefix_multi_line_string(note," ")
+ print utils.prefix_multi_line_string(note," ")
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 = queue.re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
sys.stdout = less_fd
examine_package.display_changes(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(f)
+ elif ftype == "dsc":
+ examine_package.check_dsc(f)
finally:
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 ():
# Here we prepare an editor and get them ready to prod...
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
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()
+ f = utils.open_file(temp_filename)
+ prod_message = "".join(f.readlines())
+ f.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 = queue.re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
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)
+ (olderr, newerr) = (database.get_suite_id(suite) == -1,
+ database.get_suite_id(override) == -1)
if olderr or newerr:
(oinv, newinv) = ("", "")
if olderr: oinv = "invalid "
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.queue.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 = queue.re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
elif answer == 'P':
prod_maintainer()
elif answer == 'R':
- confirm = daklib.utils.our_raw_input("Really clear note (y/N)? ").lower()
+ confirm = utils.our_raw_input("Really clear note (y/N)? ").lower()
if confirm == "y":
del changes["process-new note"]
elif answer == 'S':
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"),
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")
+ Logger = Upload.Logger = logging.Logger(Cnf, "process-new")
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 = queue.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")
retry = 0
while retry < 10:
try:
- lock_fd = os.open(Cnf["Process-New::AcceptedLockFile"], os.O_RDONLY | os.O_CREAT | os.O_EXCL)
+ 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':
+ if e.errno == errno.EACCES or e.errno == errno.EEXIST:
retry += 1
if (retry >= 10):
- daklib.utils.fubar("Couldn't obtain lock; assuming 'dak process-unchecked' is already running.")
+ 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)
raise
def move_to_dir (dest, perms=0660, changesperms=0664):
- daklib.utils.move (Upload.pkg.changes_file, dest, perms=changesperms)
+ utils.move (Upload.pkg.changes_file, dest, perms=changesperms)
file_keys = Upload.pkg.files.keys()
- for file in file_keys:
- daklib.utils.move (file, dest, perms=perms)
+ for f in file_keys:
+ utils.move (f, dest, perms=perms)
def do_accept():
print "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)
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"]:
and x.endswith(".changes") ]
changes_files = sort_changes(changes_files)
for f in changes_files:
- f = daklib.utils.validate_changes_file_arg(f, 0)
+ f = utils.validate_changes_file_arg(f, 0)
if not f: continue
print "\n" + f
fn(f, "".join(lines[1:]))
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
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
import commands, errno, fcntl, os, re, shutil, stat, sys, time, tempfile, traceback
import apt_inst, apt_pkg
-import daklib.database
-import daklib.logging
-import daklib.queue
-import daklib.utils
+import daklib.database as database
+import daklib.logging as logging
+import daklib.queue as queue
+import daklib.utils as utils
from types import *
apt_pkg.init()
Cnf = apt_pkg.newConfiguration()
- apt_pkg.ReadConfigFileISC(Cnf,daklib.utils.which_conf_file())
+ apt_pkg.ReadConfigFileISC(Cnf,utils.which_conf_file())
Arguments = [('a',"automatic","Dinstall::Options::Automatic"),
('h',"help","Dinstall::Options::Help"),
if Options["Help"]:
usage()
- Upload = daklib.queue.Upload(Cnf)
+ Upload = queue.Upload(Cnf)
changes = Upload.pkg.changes
dsc = Upload.pkg.dsc
cwd = os.getcwd()
os.chdir(Cnf["Dir::Queue::Holding"])
- for file in in_holding.keys():
- if os.path.exists(file):
- if file.find('/') != -1:
- daklib.utils.fubar("WTF? clean_holding() got a file ('%s') with / in it!" % (file))
+ for f in in_holding.keys():
+ if os.path.exists(f):
+ if f.find('/') != -1:
+ utils.fubar("WTF? clean_holding() got a file ('%s') with / in it!" % (f))
else:
- os.unlink(file)
+ os.unlink(f)
in_holding = {}
os.chdir(cwd)
# Parse the .changes field into a dictionary
try:
- changes.update(daklib.utils.parse_changes(filename))
- except daklib.utils.cant_open_exc:
+ changes.update(utils.parse_changes(filename))
+ except utils.cant_open_exc:
reject("%s: can't read file." % (filename))
return 0
- except daklib.utils.changes_parse_error_exc, line:
+ except utils.changes_parse_error_exc, line:
reject("%s: parse error, can't grok: %s." % (filename, line))
return 0
# Parse the Files field from the .changes into another dictionary
try:
- files.update(daklib.utils.build_file_list(changes))
- except daklib.utils.changes_parse_error_exc, line:
+ files.update(utils.build_file_list(changes))
+ except utils.changes_parse_error_exc, line:
reject("%s: parse error, can't grok: %s." % (filename, line))
- except daklib.utils.nk_format_exc, format:
+ except utils.nk_format_exc, format:
reject("%s: unknown format '%s'." % (filename, format))
return 0
try:
(changes["maintainer822"], changes["maintainer2047"],
changes["maintainername"], changes["maintaineremail"]) = \
- daklib.utils.fix_maintainer (changes["maintainer"])
- except daklib.utils.ParseMaintError, msg:
+ utils.fix_maintainer (changes["maintainer"])
+ except utils.ParseMaintError, msg:
reject("%s: Maintainer field ('%s') failed to parse: %s" \
% (filename, changes["maintainer"], msg))
try:
(changes["changedby822"], changes["changedby2047"],
changes["changedbyname"], changes["changedbyemail"]) = \
- daklib.utils.fix_maintainer (changes.get("changed-by", ""))
- except daklib.utils.ParseMaintError, msg:
+ utils.fix_maintainer (changes.get("changed-by", ""))
+ except utils.ParseMaintError, msg:
(changes["changedby822"], changes["changedby2047"],
changes["changedbyname"], changes["changedbyemail"]) = \
("", "", "", "")
# Ensure all the values in Closes: are numbers
if changes.has_key("closes"):
for i in changes["closes"].keys():
- if daklib.queue.re_isanum.match (i) == None:
+ if queue.re_isanum.match (i) == None:
reject("%s: `%s' from Closes field isn't a number." % (filename, i))
# chopversion = no epoch; chopversion2 = no epoch and no revision (e.g. for .orig.tar.gz comparison)
- changes["chopversion"] = daklib.utils.re_no_epoch.sub('', changes["version"])
- changes["chopversion2"] = daklib.utils.re_no_revision.sub('', changes["chopversion"])
+ changes["chopversion"] = utils.re_no_epoch.sub('', changes["version"])
+ changes["chopversion2"] = utils.re_no_revision.sub('', changes["chopversion"])
# Check there isn't already a changes file of the same name in one
# of the queue directories.
base_filename = os.path.basename(filename)
- for dir in [ "Accepted", "Byhand", "Done", "New", "ProposedUpdates", "OldProposedUpdates" ]:
- if os.path.exists(Cnf["Dir::Queue::%s" % (dir) ]+'/'+base_filename):
- reject("%s: a file with this name already exists in the %s directory." % (base_filename, dir))
+ for d in [ "Accepted", "Byhand", "Done", "New", "ProposedUpdates", "OldProposedUpdates" ]:
+ if os.path.exists(Cnf["Dir::Queue::%s" % (d) ]+'/'+base_filename):
+ reject("%s: a file with this name already exists in the %s directory." % (base_filename, d))
# Check the .changes is non-empty
if not files:
"Check and map the Distribution field of a .changes file."
# Handle suite mappings
- for map in Cnf.ValueList("SuiteMappings"):
- args = map.split()
- type = args[0]
- if type == "map" or type == "silent-map":
+ for m in Cnf.ValueList("SuiteMappings"):
+ args = m.split()
+ mtype = args[0]
+ if mtype == "map" or mtype == "silent-map":
(source, dest) = args[1:3]
if changes["distribution"].has_key(source):
del changes["distribution"][source]
changes["distribution"][dest] = 1
- if type != "silent-map":
+ if mtype != "silent-map":
reject("Mapping %s to %s." % (source, dest),"")
if changes.has_key("distribution-version"):
if changes["distribution-version"].has_key(source):
changes["distribution-version"][source]=dest
- elif type == "map-unreleased":
+ elif mtype == "map-unreleased":
(source, dest) = args[1:3]
if changes["distribution"].has_key(source):
for arch in changes["architecture"].keys():
del changes["distribution"][source]
changes["distribution"][dest] = 1
break
- elif type == "ignore":
+ elif mtype == "ignore":
suite = args[1]
if changes["distribution"].has_key(suite):
del changes["distribution"][suite]
reject("Ignoring %s as a target suite." % (suite), "Warning: ")
- elif type == "reject":
+ elif mtype == "reject":
suite = args[1]
if changes["distribution"].has_key(suite):
reject("Uploads to %s are not accepted." % (suite))
- elif type == "propup-version":
+ elif mtype == "propup-version":
# give these as "uploaded-to(non-mapped) suites-to-add-when-upload-obsoletes"
#
# changes["distribution-version"] looks like: {'testing': 'testing-proposed-updates'}
################################################################################
-def check_deb_ar(filename, control):
+def check_deb_ar(filename):
"""Sanity check the ar of a .deb, i.e. that there is:
o debian-binary
(result, output) = commands.getstatusoutput(cmd)
if result != 0:
reject("%s: 'ar t' invocation failed." % (filename))
- reject(daklib.utils.prefix_multi_line_string(output, " [ar output:] "), "")
+ reject(utils.prefix_multi_line_string(output, " [ar output:] "), "")
chunks = output.split('\n')
if len(chunks) != 3:
reject("%s: found %d chunks, expected 3." % (filename, len(chunks)))
def check_files():
global reprocess
- archive = daklib.utils.where_am_i()
+ archive = utils.where_am_i()
file_keys = files.keys()
# if reprocess is 2 we've already done this and we're checking
if not Options["No-Action"] and reprocess < 2:
cwd = os.getcwd()
os.chdir(pkg.directory)
- for file in file_keys:
- copy_to_holding(file)
+ for f in file_keys:
+ copy_to_holding(f)
os.chdir(cwd)
# Check there isn't already a .changes or .dak file of the same name in
has_binaries = 0
has_source = 0
- for file in file_keys:
+ for f in file_keys:
# Ensure the file does not already exist in one of the accepted directories
- for dir in [ "Accepted", "Byhand", "New", "ProposedUpdates", "OldProposedUpdates", "Embargoed", "Unembargoed" ]:
- if not Cnf.has_key("Dir::Queue::%s" % (dir)): continue
- if os.path.exists(Cnf["Dir::Queue::%s" % (dir) ]+'/'+file):
- reject("%s file already exists in the %s directory." % (file, dir))
- if not daklib.utils.re_taint_free.match(file):
- reject("!!WARNING!! tainted filename: '%s'." % (file))
+ for d in [ "Accepted", "Byhand", "New", "ProposedUpdates", "OldProposedUpdates", "Embargoed", "Unembargoed" ]:
+ if not Cnf.has_key("Dir::Queue::%s" % (d)): continue
+ if os.path.exists(Cnf["Dir::Queue::%s" % (d) ] + '/' + f):
+ reject("%s file already exists in the %s directory." % (f, d))
+ if not utils.re_taint_free.match(f):
+ reject("!!WARNING!! tainted filename: '%s'." % (f))
# Check the file is readable
- if os.access(file,os.R_OK) == 0:
+ if os.access(f, os.R_OK) == 0:
# When running in -n, copy_to_holding() won't have
# generated the reject_message, so we need to.
if Options["No-Action"]:
- if os.path.exists(file):
- reject("Can't read `%s'. [permission denied]" % (file))
+ if os.path.exists(f):
+ reject("Can't read `%s'. [permission denied]" % (f))
else:
- reject("Can't read `%s'. [file not found]" % (file))
- files[file]["type"] = "unreadable"
+ reject("Can't read `%s'. [file not found]" % (f))
+ files[f]["type"] = "unreadable"
continue
# If it's byhand skip remaining checks
- if files[file]["section"] == "byhand" or files[file]["section"][:4] == "raw-":
- files[file]["byhand"] = 1
- files[file]["type"] = "byhand"
+ if files[f]["section"] == "byhand" or files[f]["section"][:4] == "raw-":
+ files[f]["byhand"] = 1
+ files[f]["type"] = "byhand"
# Checks for a binary package...
- elif daklib.utils.re_isadeb.match(file):
+ elif utils.re_isadeb.match(f):
has_binaries = 1
- files[file]["type"] = "deb"
+ files[f]["type"] = "deb"
# Extract package control information
- deb_file = daklib.utils.open_file(file)
+ deb_file = utils.open_file(f)
try:
control = apt_pkg.ParseSection(apt_inst.debExtractControl(deb_file))
except:
- reject("%s: debExtractControl() raised %s." % (file, sys.exc_type))
+ reject("%s: debExtractControl() raised %s." % (f, sys.exc_type))
deb_file.close()
# Can't continue, none of the checks on control would work.
continue
# Check for mandatory fields
for field in [ "Package", "Architecture", "Version" ]:
if control.Find(field) == None:
- reject("%s: No %s field in control." % (file, field))
+ reject("%s: No %s field in control." % (f, field))
# Can't continue
continue
# Ensure the package name matches the one give in the .changes
if not changes["binary"].has_key(control.Find("Package", "")):
- reject("%s: control file lists name as `%s', which isn't in changes file." % (file, control.Find("Package", "")))
+ reject("%s: control file lists name as `%s', which isn't in changes file." % (f, control.Find("Package", "")))
# Validate the package field
package = control.Find("Package")
if not re_valid_pkg_name.match(package):
- reject("%s: invalid package name '%s'." % (file, package))
+ reject("%s: invalid package name '%s'." % (f, package))
# Validate the version field
version = control.Find("Version")
if not re_valid_version.match(version):
- reject("%s: invalid version number '%s'." % (file, version))
+ reject("%s: invalid version number '%s'." % (f, version))
# Ensure the architecture of the .deb is one we know about.
default_suite = Cnf.get("Dinstall::DefaultSuite", "Unstable")
# Ensure the architecture of the .deb is one of the ones
# listed in the .changes.
if not changes["architecture"].has_key(architecture):
- reject("%s: control file lists arch as `%s', which isn't in changes file." % (file, architecture))
+ reject("%s: control file lists arch as `%s', which isn't in changes file." % (f, architecture))
# Sanity-check the Depends field
depends = control.Find("Depends")
if depends == '':
- reject("%s: Depends field is empty." % (file))
+ reject("%s: Depends field is empty." % (f))
# Sanity-check the Provides field
provides = control.Find("Provides")
if provides:
provide = re_spacestrip.sub('', provides)
if provide == '':
- reject("%s: Provides field is empty." % (file))
+ reject("%s: Provides field is empty." % (f))
prov_list = provide.split(",")
for prov in prov_list:
if not re_valid_pkg_name.match(prov):
- reject("%s: Invalid Provides field content %s." % (file, prov))
+ reject("%s: Invalid Provides field content %s." % (f, prov))
# Check the section & priority match those given in the .changes (non-fatal)
- if control.Find("Section") and files[file]["section"] != "" and files[file]["section"] != control.Find("Section"):
- reject("%s control file lists section as `%s', but changes file has `%s'." % (file, control.Find("Section", ""), files[file]["section"]), "Warning: ")
- if control.Find("Priority") and files[file]["priority"] != "" and files[file]["priority"] != control.Find("Priority"):
- reject("%s control file lists priority as `%s', but changes file has `%s'." % (file, control.Find("Priority", ""), files[file]["priority"]),"Warning: ")
-
- files[file]["package"] = package
- files[file]["architecture"] = architecture
- files[file]["version"] = version
- files[file]["maintainer"] = control.Find("Maintainer", "")
- if file.endswith(".udeb"):
- files[file]["dbtype"] = "udeb"
- elif file.endswith(".deb"):
- files[file]["dbtype"] = "deb"
+ if control.Find("Section") and files[f]["section"] != "" and files[f]["section"] != control.Find("Section"):
+ reject("%s control file lists section as `%s', but changes file has `%s'." % (f, control.Find("Section", ""), files[f]["section"]), "Warning: ")
+ if control.Find("Priority") and files[f]["priority"] != "" and files[f]["priority"] != control.Find("Priority"):
+ reject("%s control file lists priority as `%s', but changes file has `%s'." % (f, control.Find("Priority", ""), files[f]["priority"]),"Warning: ")
+
+ files[f]["package"] = package
+ files[f]["architecture"] = architecture
+ files[f]["version"] = version
+ files[f]["maintainer"] = control.Find("Maintainer", "")
+ if f.endswith(".udeb"):
+ files[f]["dbtype"] = "udeb"
+ elif f.endswith(".deb"):
+ files[f]["dbtype"] = "deb"
else:
- reject("%s is neither a .deb or a .udeb." % (file))
- files[file]["source"] = control.Find("Source", files[file]["package"])
+ reject("%s is neither a .deb or a .udeb." % (f))
+ files[f]["source"] = control.Find("Source", files[f]["package"])
# Get the source version
- source = files[file]["source"]
+ source = files[f]["source"]
source_version = ""
if source.find("(") != -1:
- m = daklib.utils.re_extract_src_version.match(source)
+ m = utils.re_extract_src_version.match(source)
source = m.group(1)
source_version = m.group(2)
if not source_version:
- source_version = files[file]["version"]
- files[file]["source package"] = source
- files[file]["source version"] = source_version
+ source_version = files[f]["version"]
+ files[f]["source package"] = source
+ files[f]["source version"] = source_version
# Ensure the filename matches the contents of the .deb
- m = daklib.utils.re_isadeb.match(file)
+ m = utils.re_isadeb.match(f)
# package name
file_package = m.group(1)
- if files[file]["package"] != file_package:
- reject("%s: package part of filename (%s) does not match package name in the %s (%s)." % (file, file_package, files[file]["dbtype"], files[file]["package"]))
- epochless_version = daklib.utils.re_no_epoch.sub('', control.Find("Version"))
+ if files[f]["package"] != file_package:
+ reject("%s: package part of filename (%s) does not match package name in the %s (%s)." % (f, file_package, files[f]["dbtype"], files[f]["package"]))
+ epochless_version = utils.re_no_epoch.sub('', control.Find("Version"))
# version
file_version = m.group(2)
if epochless_version != file_version:
- reject("%s: version part of filename (%s) does not match package version in the %s (%s)." % (file, file_version, files[file]["dbtype"], epochless_version))
+ reject("%s: version part of filename (%s) does not match package version in the %s (%s)." % (f, file_version, files[f]["dbtype"], epochless_version))
# architecture
file_architecture = m.group(3)
- if files[file]["architecture"] != file_architecture:
- reject("%s: architecture part of filename (%s) does not match package architecture in the %s (%s)." % (file, file_architecture, files[file]["dbtype"], files[file]["architecture"]))
+ if files[f]["architecture"] != file_architecture:
+ reject("%s: architecture part of filename (%s) does not match package architecture in the %s (%s)." % (f, file_architecture, files[f]["dbtype"], files[f]["architecture"]))
# Check for existent source
- source_version = files[file]["source version"]
- source_package = files[file]["source package"]
+ source_version = files[f]["source version"]
+ source_package = files[f]["source package"]
if changes["architecture"].has_key("source"):
if source_version != changes["version"]:
- reject("source version (%s) for %s doesn't match changes version %s." % (source_version, file, changes["version"]))
+ reject("source version (%s) for %s doesn't match changes version %s." % (source_version, f, changes["version"]))
else:
# Check in the SQL database
if not Upload.source_exists(source_package, source_version, changes["distribution"].keys()):
# Check in one of the other directories
- source_epochless_version = daklib.utils.re_no_epoch.sub('', source_version)
+ source_epochless_version = utils.re_no_epoch.sub('', source_version)
dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version)
if os.path.exists(Cnf["Dir::Queue::Byhand"] + '/' + dsc_filename):
- files[file]["byhand"] = 1
+ files[f]["byhand"] = 1
elif os.path.exists(Cnf["Dir::Queue::New"] + '/' + dsc_filename):
- files[file]["new"] = 1
+ files[f]["new"] = 1
else:
dsc_file_exists = 0
for myq in ["Accepted", "Embargoed", "Unembargoed", "ProposedUpdates", "OldProposedUpdates"]:
dsc_file_exists = 1
break
if not dsc_file_exists:
- 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, f))
# Check the version and for file overwrites
- reject(Upload.check_binary_against_db(file),"")
+ reject(Upload.check_binary_against_db(f),"")
- check_deb_ar(file, control)
+ check_deb_ar(f)
# Checks for a source package...
else:
- m = daklib.utils.re_issource.match(file)
+ m = utils.re_issource.match(f)
if m:
has_source = 1
- files[file]["package"] = m.group(1)
- files[file]["version"] = m.group(2)
- files[file]["type"] = m.group(3)
+ files[f]["package"] = m.group(1)
+ files[f]["version"] = m.group(2)
+ files[f]["type"] = m.group(3)
# Ensure the source package name matches the Source filed in the .changes
- if changes["source"] != files[file]["package"]:
- reject("%s: changes file doesn't say %s for Source" % (file, files[file]["package"]))
+ if changes["source"] != files[f]["package"]:
+ reject("%s: changes file doesn't say %s for Source" % (f, files[f]["package"]))
# Ensure the source version matches the version in the .changes file
- if files[file]["type"] == "orig.tar.gz":
+ if files[f]["type"] == "orig.tar.gz":
changes_version = changes["chopversion2"]
else:
changes_version = changes["chopversion"]
- if changes_version != files[file]["version"]:
- reject("%s: should be %s according to changes file." % (file, changes_version))
+ if changes_version != files[f]["version"]:
+ reject("%s: should be %s according to changes file." % (f, changes_version))
# Ensure the .changes lists source in the Architecture field
if not changes["architecture"].has_key("source"):
- reject("%s: changes file doesn't list `source' in Architecture field." % (file))
+ reject("%s: changes file doesn't list `source' in Architecture field." % (f))
# Check the signature of a .dsc file
- if files[file]["type"] == "dsc":
- dsc["fingerprint"] = daklib.utils.check_signature(file, reject)
+ if files[f]["type"] == "dsc":
+ dsc["fingerprint"] = utils.check_signature(f, reject)
- files[file]["architecture"] = "source"
+ files[f]["architecture"] = "source"
# Not a binary or source package? Assume byhand...
else:
- files[file]["byhand"] = 1
- files[file]["type"] = "byhand"
+ files[f]["byhand"] = 1
+ files[f]["type"] = "byhand"
# Per-suite file checks
- files[file]["oldfiles"] = {}
+ files[f]["oldfiles"] = {}
for suite in changes["distribution"].keys():
# Skip byhand
- if files[file].has_key("byhand"):
+ if files[f].has_key("byhand"):
continue
# Handle component mappings
- for map in Cnf.ValueList("ComponentMappings"):
- (source, dest) = map.split()
- if files[file]["component"] == source:
- files[file]["original component"] = source
- files[file]["component"] = dest
+ for m in Cnf.ValueList("ComponentMappings"):
+ (source, dest) = m.split()
+ if files[f]["component"] == source:
+ files[f]["original component"] = source
+ files[f]["component"] = dest
# Ensure the component is valid for the target suite
if Cnf.has_key("Suite:%s::Components" % (suite)) and \
- files[file]["component"] not in Cnf.ValueList("Suite::%s::Components" % (suite)):
- reject("unknown component `%s' for suite `%s'." % (files[file]["component"], suite))
+ files[f]["component"] not in Cnf.ValueList("Suite::%s::Components" % (suite)):
+ reject("unknown component `%s' for suite `%s'." % (files[f]["component"], suite))
continue
# Validate the component
- component = files[file]["component"]
- component_id = daklib.database.get_component_id(component)
+ component = files[f]["component"]
+ component_id = database.get_component_id(component)
if component_id == -1:
- reject("file '%s' has unknown component '%s'." % (file, component))
+ reject("file '%s' has unknown component '%s'." % (f, component))
continue
# See if the package is NEW
- if not Upload.in_override_p(files[file]["package"], files[file]["component"], suite, files[file].get("dbtype",""), file):
- files[file]["new"] = 1
+ if not Upload.in_override_p(files[f]["package"], files[f]["component"], suite, files[f].get("dbtype",""), f):
+ files[f]["new"] = 1
# Validate the priority
- if files[file]["priority"].find('/') != -1:
- reject("file '%s' has invalid priority '%s' [contains '/']." % (file, files[file]["priority"]))
+ if files[f]["priority"].find('/') != -1:
+ reject("file '%s' has invalid priority '%s' [contains '/']." % (f, files[f]["priority"]))
# Determine the location
location = Cnf["Dir::Pool"]
- location_id = daklib.database.get_location_id (location, component, archive)
+ location_id = database.get_location_id (location, component, archive)
if location_id == -1:
reject("[INTERNAL ERROR] couldn't determine location (Component: %s, Archive: %s)" % (component, archive))
- files[file]["location id"] = location_id
+ files[f]["location id"] = location_id
# Check the md5sum & size against existing files (if any)
- files[file]["pool name"] = daklib.utils.poolify (changes["source"], files[file]["component"])
- files_id = daklib.database.get_files_id(files[file]["pool name"] + file, files[file]["size"], files[file]["md5sum"], files[file]["location id"])
+ files[f]["pool name"] = utils.poolify (changes["source"], files[f]["component"])
+ files_id = database.get_files_id(files[f]["pool name"] + f, files[f]["size"], files[f]["md5sum"], files[f]["location id"])
if files_id == -1:
- reject("INTERNAL ERROR, get_files_id() returned multiple matches for %s." % (file))
+ reject("INTERNAL ERROR, get_files_id() returned multiple matches for %s." % (f))
elif files_id == -2:
- reject("md5sum and/or size mismatch on existing copy of %s." % (file))
- files[file]["files id"] = files_id
+ reject("md5sum and/or size mismatch on existing copy of %s." % (f))
+ files[f]["files id"] = files_id
# Check for packages that have moved from one component to another
q = Upload.projectB.query("""
AND (a.arch_string = '%s' OR a.arch_string = 'all')
AND ba.bin = b.id AND ba.suite = s.id AND b.architecture = a.id
AND f.location = l.id AND l.component = c.id AND b.file = f.id"""
- % (files[file]["package"], suite,
- files[file]["architecture"]))
+ % (files[f]["package"], suite,
+ files[f]["architecture"]))
ql = q.getresult()
if ql:
- files[file]["othercomponents"] = ql[0][0]
+ files[f]["othercomponents"] = ql[0][0]
# If the .changes file says it has source, it must have source.
if changes["architecture"].has_key("source"):
# Find the .dsc
dsc_filename = None
- for file in files.keys():
- if files[file]["type"] == "dsc":
+ for f in files.keys():
+ if files[f]["type"] == "dsc":
if dsc_filename:
reject("can not process a .changes file with multiple .dsc's.")
return 0
else:
- dsc_filename = file
+ dsc_filename = f
# If there isn't one, we have nothing to do. (We have reject()ed the upload already)
if not dsc_filename:
# Parse the .dsc file
try:
- dsc.update(daklib.utils.parse_changes(dsc_filename, signing_rules=1))
- except daklib.utils.cant_open_exc:
+ dsc.update(utils.parse_changes(dsc_filename, signing_rules=1))
+ except utils.cant_open_exc:
# if not -n copy_to_holding() will have done this for us...
if Options["No-Action"]:
reject("%s: can't read file." % (dsc_filename))
- except daklib.utils.changes_parse_error_exc, line:
+ except utils.changes_parse_error_exc, line:
reject("%s: parse error, can't grok: %s." % (dsc_filename, line))
- except daklib.utils.invalid_dsc_format_exc, line:
+ except utils.invalid_dsc_format_exc, line:
reject("%s: syntax error on line %s." % (dsc_filename, line))
# Build up the file list of files mentioned by the .dsc
try:
- dsc_files.update(daklib.utils.build_file_list(dsc, is_a_dsc=1))
- except daklib.utils.no_files_exc:
+ dsc_files.update(utils.build_file_list(dsc, is_a_dsc=1))
+ except utils.no_files_exc:
reject("%s: no Files: field." % (dsc_filename))
return 0
- except daklib.utils.changes_parse_error_exc, line:
+ except utils.changes_parse_error_exc, line:
reject("%s: parse error, can't grok: %s." % (dsc_filename, line))
return 0
# Validate the Maintainer field
try:
- daklib.utils.fix_maintainer (dsc["maintainer"])
- except daklib.utils.ParseMaintError, msg:
+ utils.fix_maintainer (dsc["maintainer"])
+ except utils.ParseMaintError, msg:
reject("%s: Maintainer field ('%s') failed to parse: %s" \
% (dsc_filename, dsc["maintainer"], msg))
pass
# Ensure the version number in the .dsc matches the version number in the .changes
- epochless_dsc_version = daklib.utils.re_no_epoch.sub('', dsc["version"])
+ epochless_dsc_version = utils.re_no_epoch.sub('', dsc["version"])
changes_version = files[dsc_filename]["version"]
if epochless_dsc_version != files[dsc_filename]["version"]:
reject("version ('%s') in .dsc does not match version ('%s') in .changes." % (epochless_dsc_version, changes_version))
# Ensure there is a .tar.gz in the .dsc file
has_tar = 0
for f in dsc_files.keys():
- m = daklib.utils.re_issource.match(f)
+ m = utils.re_issource.match(f)
if not m:
reject("%s: %s in Files field not recognised as source." % (dsc_filename, f))
continue
- type = m.group(3)
- if type == "orig.tar.gz" or type == "tar.gz":
+ ftype = m.group(3)
+ if ftype == "orig.tar.gz" or ftype == "tar.gz":
has_tar = 1
if not has_tar:
reject("%s: no .tar.gz or .orig.tar.gz in 'Files' field." % (dsc_filename))
# Find the .dsc (again)
dsc_filename = None
- for file in files.keys():
- if files[file]["type"] == "dsc":
- dsc_filename = file
+ for f in files.keys():
+ if files[f]["type"] == "dsc":
+ dsc_filename = f
# If there isn't one, we have nothing to do. (We have reject()ed the upload already)
if not dsc_filename:
# Create a symlink mirror of the source files in our temporary directory
for f in files.keys():
- m = daklib.utils.re_issource.match(f)
+ m = utils.re_issource.match(f)
if m:
src = os.path.join(source_dir, f)
# If a file is missing for whatever reason, give up.
if not os.path.exists(src):
return
- type = m.group(3)
- if type == "orig.tar.gz" and pkg.orig_tar_gz:
+ ftype = m.group(3)
+ if ftype == "orig.tar.gz" and pkg.orig_tar_gz:
continue
dest = os.path.join(os.getcwd(), f)
os.symlink(src, dest)
(result, output) = commands.getstatusoutput(cmd)
if (result != 0):
reject("'dpkg-source -x' failed for %s [return code: %s]." % (dsc_filename, result))
- reject(daklib.utils.prefix_multi_line_string(output, " [dpkg-source output:] "), "")
+ reject(utils.prefix_multi_line_string(output, " [dpkg-source output:] "), "")
return
if not Cnf.Find("Dir::Queue::BTSVersionTrack"):
return
# Get the upstream version
- upstr_version = daklib.utils.re_no_epoch.sub('', dsc["version"])
+ upstr_version = utils.re_no_epoch.sub('', dsc["version"])
if re_strip_revision.search(upstr_version):
upstr_version = re_strip_revision.sub('', upstr_version)
# Parse the changelog
dsc["bts changelog"] = ""
- changelog_file = daklib.utils.open_file(changelog_filename)
+ changelog_file = utils.open_file(changelog_filename)
for line in changelog_file.readlines():
m = re_changelog_versions.match(line)
if m:
# Create a temporary directory to extract the source into
if Options["No-Action"]:
- tmpdir = tempfile.mktemp()
+ tmpdir = tempfile.mkdtemp()
else:
# We're in queue/holding and can create a random directory.
tmpdir = "%s" % (os.getpid())
- os.mkdir(tmpdir)
+ os.mkdir(tmpdir)
# Move into the temporary directory
cwd = os.getcwd()
shutil.rmtree(tmpdir)
except OSError, e:
if errno.errorcode[e.errno] != 'EACCES':
- daklib.utils.fubar("%s: couldn't remove tmp dir for source tree." % (dsc["source"]))
+ utils.fubar("%s: couldn't remove tmp dir for source tree." % (dsc["source"]))
reject("%s: source tree could not be cleanly removed." % (dsc["source"]))
# We probably have u-r or u-w directories so chmod everything
cmd = "chmod -R u+rwx %s" % (tmpdir)
result = os.system(cmd)
if result != 0:
- daklib.utils.fubar("'%s' failed with result %s." % (cmd, result))
+ utils.fubar("'%s' failed with result %s." % (cmd, result))
shutil.rmtree(tmpdir)
except:
- daklib.utils.fubar("%s: couldn't remove tmp dir for source tree." % (dsc["source"]))
+ utils.fubar("%s: couldn't remove tmp dir for source tree." % (dsc["source"]))
################################################################################
for h,f in hashes:
try:
- fs = daklib.utils.build_file_list(changes, 0, "checksums-%s" % h, h)
+ fs = utils.build_file_list(changes, 0, "checksums-%s" % h, h)
check_hash(".changes %s" % (h), fs, h, f, files)
- except daklib.utils.no_files_exc:
+ except utils.no_files_exc:
reject("No Checksums-%s: field in .changes" % (h))
- except daklib.utils.changes_parse_error_exc, line:
+ except utils.changes_parse_error_exc, line:
reject("parse error for Checksums-%s in .changes, can't grok: %s." % (h, line))
if "source" not in changes["architecture"]: continue
try:
- fs = daklib.utils.build_file_list(dsc, 1, "checksums-%s" % h, h)
+ fs = utils.build_file_list(dsc, 1, "checksums-%s" % h, h)
check_hash(".dsc %s" % (h), fs, h, f, dsc_files)
- except daklib.utils.no_files_exc:
+ except utils.no_files_exc:
reject("No Checksums-%s: field in .dsc" % (h))
- except daklib.utils.changes_parse_error_exc, line:
+ except utils.changes_parse_error_exc, line:
reject("parse error for Checksums-%s in .dsc, can't grok: %s." % (h, line))
################################################################################
-def check_hash (where, files, key, testfn, basedict = None):
+def check_hash (where, lfiles, key, testfn, basedict = None):
if basedict:
- for file in basedict.keys():
- if file not in files:
- reject("%s: no %s checksum" % (file, key))
+ for f in basedict.keys():
+ if f not in lfiles:
+ reject("%s: no %s checksum" % (f, key))
- for file in files.keys():
- if basedict and file not in basedict:
- reject("%s: extraneous entry in %s checksums" % (file, key))
+ for f in lfiles.keys():
+ if basedict and f not in basedict:
+ reject("%s: extraneous entry in %s checksums" % (f, key))
try:
- file_handle = daklib.utils.open_file(file)
- except daklib.utils.cant_open_exc:
+ file_handle = utils.open_file(f)
+ except utils.cant_open_exc:
continue
# Check hash
- if testfn(file_handle) != files[file][key]:
- reject("%s: %s check failed." % (file, key))
+ if testfn(file_handle) != lfiles[f][key]:
+ reject("%s: %s check failed." % (f, key))
file_handle.close()
# Check size
- actual_size = os.stat(file)[stat.ST_SIZE]
- size = int(files[file]["size"])
+ actual_size = os.stat(f)[stat.ST_SIZE]
+ size = int(lfiles[f]["size"])
if size != actual_size:
reject("%s: actual file size (%s) does not match size (%s) in %s"
- % (file, actual_size, size, where))
+ % (f, actual_size, size, where))
################################################################################
if files[filename]["type"] == "deb":
tar.reset()
try:
- deb_file = daklib.utils.open_file(filename)
+ deb_file = utils.open_file(filename)
apt_inst.debExtract(deb_file,tar.callback,"control.tar.gz")
deb_file.seek(0)
try:
else:
sponsored = 1
if ("source" in changes["architecture"] and
- uid_email and daklib.utils.is_email_alias(uid_email)):
- sponsor_addresses = daklib.utils.gpg_get_key_addresses(changes["fingerprint"])
+ uid_email and utils.is_email_alias(uid_email)):
+ sponsor_addresses = utils.gpg_get_key_addresses(changes["fingerprint"])
if (changes["maintaineremail"] not in sponsor_addresses and
changes["changedbyemail"] not in sponsor_addresses):
changes["sponsoremail"] = uid_email
check_suites = changes["distribution"].keys()
if "unstable" not in check_suites: check_suites.append("unstable")
for suite in check_suites:
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
q = Upload.projectB.query("SELECT s.id FROM source s JOIN src_associations sa ON (s.id = sa.source) WHERE s.source = '%s' AND sa.suite = %d" % (changes["source"], suite_id))
for si in q.getresult():
if si[0] not in source_ids: source_ids.append(si[0])
is_nmu = 1
q = Upload.projectB.query("SELECT m.name FROM maintainer m WHERE m.id IN (SELECT maintainer FROM src_uploaders WHERE src_uploaders.source = %s)" % (si))
for m in q.getresult():
- (rfc822, rfc2047, name, email) = daklib.utils.fix_maintainer(m[0])
+ (rfc822, rfc2047, name, email) = utils.fix_maintainer(m[0])
if email == uid_email or name == uid_name:
is_nmu=0
break
for b in changes["binary"].keys():
for suite in changes["distribution"].keys():
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
q = Upload.projectB.query("SELECT DISTINCT s.source FROM source s JOIN binaries b ON (s.id = b.source) JOIN bin_associations ba On (b.id = ba.bin) WHERE b.package = '%s' AND ba.suite = %s" % (b, suite_id))
for s in q.getresult():
if s[0] != changes["source"]:
reject("%s may not hijack %s from source package %s in suite %s" % (uid, b, s, suite))
- for file in files.keys():
- if files[file].has_key("byhand"):
- reject("%s may not upload BYHAND file %s" % (uid, file))
- if files[file].has_key("new"):
- reject("%s may not upload NEW file %s" % (uid, file))
+ for f in files.keys():
+ if files[f].has_key("byhand"):
+ reject("%s may not upload BYHAND file %s" % (uid, f))
+ if files[f].has_key("new"):
+ reject("%s may not upload NEW file %s" % (uid, f))
# The remaining checks only apply to binary-only uploads right now
if changes["architecture"].has_key("source"):
if restrictions.Exists("Components"):
restricted_components = restrictions.SubTree("Components").ValueList()
is_restricted = False
- for file in files:
- if files[file]["component"] in restricted_components:
+ for f in files:
+ if files[f]["component"] in restricted_components:
is_restricted = True
break
if not is_restricted:
file_list = pkg.files.keys()
file_list.extend(pkg.dsc_files.keys())
file_list.append(pkg.changes_file)
- for file in file_list:
+ for f in file_list:
try:
- last_modified = time.time()-os.path.getmtime(file)
+ last_modified = time.time()-os.path.getmtime(f)
if last_modified < int(Cnf["Dinstall::SkipTime"]):
too_new = 1
break
if Options["Automatic"]:
answer = 'R'
else:
- queue = None
+ qu = None
for q in queues:
if queue_info[q]["is"]():
- queue = q
+ qu = q
break
- if queue:
+ if qu:
print "%s for %s\n%s%s" % (
- queue.upper(), ", ".join(changes["distribution"].keys()),
+ qu.upper(), ", ".join(changes["distribution"].keys()),
reject_message, summary),
- queuekey = queue[0].upper()
+ queuekey = qu[0].upper()
if queuekey in "RQSA":
queuekey = "D"
prompt = "[D]ivert, Skip, Quit ?"
else:
- prompt = "[%s]%s, Skip, Quit ?" % (queuekey, queue[1:].lower())
+ prompt = "[%s]%s, Skip, Quit ?" % (queuekey, qu[1:].lower())
if Options["Automatic"]:
answer = queuekey
else:
answer = 'A'
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 = queue.re_default_answer.match(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
accept(summary, short_summary)
remove_from_unchecked()
elif answer == queuekey:
- queue_info[queue]["process"](summary, short_summary)
+ queue_info[qu]["process"](summary, short_summary)
remove_from_unchecked()
elif answer == 'Q':
sys.exit(0)
def remove_from_unchecked():
os.chdir (pkg.directory)
- for file in files.keys():
- os.unlink(file)
+ for f in files.keys():
+ os.unlink(f)
os.unlink(pkg.changes_file)
################################################################################
################################################################################
def move_to_dir (dest, perms=0660, changesperms=0664):
- daklib.utils.move (pkg.changes_file, dest, perms=changesperms)
+ utils.move (pkg.changes_file, dest, perms=changesperms)
file_keys = files.keys()
- for file in file_keys:
- daklib.utils.move (file, dest, perms=perms)
+ for f in file_keys:
+ utils.move (f, dest, perms=perms)
################################################################################
return 0
if not changes["architecture"].has_key("source"):
- pusuite = daklib.database.get_suite_id("proposed-updates")
+ pusuite = database.get_suite_id("proposed-updates")
q = Upload.projectB.query(
"SELECT S.source FROM source s JOIN src_associations sa ON (s.id = sa.source) WHERE s.source = '%s' AND s.version = '%s' AND sa.suite = %d" %
(changes["source"], changes["version"], pusuite))
return 0
if not changes["architecture"].has_key("source"):
- pusuite = daklib.database.get_suite_id("oldstable-proposed-updates")
+ pusuite = database.get_suite_id("oldstable-proposed-updates")
q = Upload.projectB.query(
"SELECT S.source FROM source s JOIN src_associations sa ON (s.id = sa.source) WHERE s.source = '%s' AND s.version = '%s' AND sa.suite = %d" %
(changes["source"], changes["version"], pusuite))
def is_autobyhand ():
all_auto = 1
any_auto = 0
- for file in files.keys():
- if files[file].has_key("byhand"):
+ for f in files.keys():
+ if files[f].has_key("byhand"):
any_auto = 1
# filename is of form "PKG_VER_ARCH.EXT" where PKG, VER and ARCH
# don't contain underscores, and ARCH doesn't contain dots.
# further VER matches the .changes Version:, and ARCH should be in
# the .changes Architecture: list.
- if file.count("_") < 2:
+ if f.count("_") < 2:
all_auto = 0
continue
- (pkg, ver, archext) = file.split("_", 2)
+ (pckg, ver, archext) = f.split("_", 2)
if archext.count(".") < 1 or changes["version"] != ver:
all_auto = 0
continue
ABH = Cnf.SubTree("AutomaticByHandPackages")
- if not ABH.has_key(pkg) or \
- ABH["%s::Source" % (pkg)] != changes["source"]:
- print "not match %s %s" % (pkg, changes["source"])
+ if not ABH.has_key(pckg) or \
+ ABH["%s::Source" % (pckg)] != changes["source"]:
+ print "not match %s %s" % (pckg, changes["source"])
all_auto = 0
continue
all_auto = 0
continue
- files[file]["byhand-arch"] = arch
- files[file]["byhand-script"] = ABH["%s::Script" % (pkg)]
+ files[f]["byhand-arch"] = arch
+ files[f]["byhand-script"] = ABH["%s::Script" % (pckg)]
return any_auto and all_auto
def do_autobyhand (summary, short_summary):
print "Attempting AUTOBYHAND."
byhandleft = 0
- for file in files.keys():
- byhandfile = file
- if not files[file].has_key("byhand"):
+ for f in files.keys():
+ byhandfile = f
+ if not files[f].has_key("byhand"):
continue
- if not files[file].has_key("byhand-script"):
+ if not files[f].has_key("byhand-script"):
byhandleft = 1
continue
os.system("ls -l %s" % byhandfile)
result = os.system("%s %s %s %s %s" % (
- files[file]["byhand-script"], byhandfile,
- changes["version"], files[file]["byhand-arch"],
+ files[f]["byhand-script"], byhandfile,
+ changes["version"], files[f]["byhand-arch"],
os.path.abspath(pkg.changes_file)))
if result == 0:
os.unlink(byhandfile)
- del files[file]
+ del files[f]
else:
- print "Error processing %s, left as byhand." % (file)
+ print "Error processing %s, left as byhand." % (f)
byhandleft = 1
if byhandleft:
################################################################################
def is_byhand ():
- for file in files.keys():
- if files[file].has_key("byhand"):
+ for f in files.keys():
+ if files[f].has_key("byhand"):
return 1
return 0
################################################################################
def is_new ():
- for file in files.keys():
- if files[file].has_key("new"):
+ for f in files.keys():
+ if files[f].has_key("new"):
return 1
return 0
if not Options["No-Mail"]:
print "Sending new ack."
Subst["__SUMMARY__"] = summary
- new_ack_message = daklib.utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-unchecked.new")
- daklib.utils.send_mail(new_ack_message)
+ new_ack_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/process-unchecked.new")
+ utils.send_mail(new_ack_message)
################################################################################
# Relativize the filename so we use the copy in holding
# rather than the original...
pkg.changes_file = os.path.basename(pkg.changes_file)
- changes["fingerprint"] = daklib.utils.check_signature(pkg.changes_file, reject)
+ changes["fingerprint"] = utils.check_signature(pkg.changes_file, reject)
if changes["fingerprint"]:
valid_changes_p = check_changes()
else:
Options["Automatic"] = ""
# Ensure all the arguments we were given are .changes files
- for file in changes_files:
- if not file.endswith(".changes"):
- daklib.utils.warn("Ignoring '%s' because it's not a .changes file." % (file))
- changes_files.remove(file)
+ for f in changes_files:
+ if not f.endswith(".changes"):
+ utils.warn("Ignoring '%s' because it's not a .changes file." % (f))
+ changes_files.remove(f)
if changes_files == []:
- daklib.utils.fubar("Need at least one .changes file as an argument.")
+ utils.fubar("Need at least one .changes file as an argument.")
# Check that we aren't going to clash with the daily cron job
if not Options["No-Action"] and os.path.exists("%s/daily.lock" % (Cnf["Dir::Lock"])) and not Options["No-Lock"]:
- daklib.utils.fubar("Archive maintenance in progress. Try again later.")
+ utils.fubar("Archive maintenance in progress. Try again later.")
# Obtain lock if not in no-action mode and initialize the log
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-unchecked' is already running.")
+ utils.fubar("Couldn't obtain lock; assuming another 'dak process-unchecked' is already running.")
else:
raise
- Logger = Upload.Logger = daklib.logging.Logger(Cnf, "process-unchecked")
+ Logger = Upload.Logger = logging.Logger(Cnf, "process-unchecked")
# debian-{devel-,}-changes@lists.debian.org toggles writes access based on this header
bcc = "X-DAK: dak process-unchecked\nX-Katie: $Revision: 1.65 $"
# 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:
sets = "set"
if accept_count > 1:
sets = "sets"
- print "Accepted %d package %s, %s." % (accept_count, sets, daklib.utils.size_type(int(accept_bytes)))
+ print "Accepted %d package %s, %s." % (accept_count, sets, utils.size_type(int(accept_bytes)))
Logger.log(["total",accept_count,accept_bytes])
if not Options["No-Action"]:
import copy, glob, os, stat, sys, time
import apt_pkg
-import daklib.queue
-import daklib.utils
+import daklib.queue as queue
+import daklib.utils as utils
Cnf = None
Upload = None
maint=""
distribution=""
closes=""
- source_exists=""
for i in per_source_items:
last_modified = time.time()-i[1]["oldest"]
source = i[1]["list"][0]["source"]
try:
(maintainer["maintainer822"], maintainer["maintainer2047"],
maintainer["maintainername"], maintainer["maintaineremail"]) = \
- daklib.utils.fix_maintainer (j["maintainer"])
- except daklib.utils.ParseMaintError, msg:
+ utils.fix_maintainer (j["maintainer"])
+ except utils.ParseMaintError, msg:
print "Problems while parsing maintainer address\n"
maintainer["maintainername"] = "Unknown"
maintainer["maintaineremail"] = "Unknown"
version = j["version"]
versions[version] = ""
arches_list = arches.keys()
- arches_list.sort(daklib.utils.arch_compare_sw)
+ arches_list.sort(utils.arch_compare_sw)
arch_list = " ".join(arches_list)
version_list = " ".join(versions.keys())
if len(version_list) > max_version_len:
def main():
global Cnf, Upload
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Queue-Report::Options::Help"),
('n',"new","Queue-Report::Options::New"),
('s',"sort","Queue-Report::Options::Sort", "HasArg"),
if Options["Help"]:
usage()
- Upload = daklib.queue.Upload(Cnf)
+ Upload = queue.Upload(Cnf)
if Cnf.has_key("Queue-Report::Options::New"):
header()
import os, pg, sys
import apt_pkg
-import daklib.database
-import daklib.logging
-import daklib.queue
-import daklib.utils
+import daklib.database as database
+import daklib.logging as logging
+import daklib.queue as queue
+import daklib.utils as utils
################################################################################
def main():
global Cnf, Logger, Options, projectB, Upload
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Reject-Proposed-Updates::Options::Help"),
('m',"manual-reject","Reject-Proposed-Updates::Options::Manual-Reject", "HasArg"),
('s',"no-mail", "Reject-Proposed-Updates::Options::No-Mail")]
if Options["Help"]:
usage()
if not arguments:
- daklib.utils.fubar("need at least one .changes filename as an argument.")
+ utils.fubar("need at least one .changes filename as an argument.")
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
- Upload = daklib.queue.Upload(Cnf)
- Logger = Upload.Logger = daklib.logging.Logger(Cnf, "reject-proposed-updates")
+ Upload = queue.Upload(Cnf)
+ Logger = Upload.Logger = logging.Logger(Cnf, "reject-proposed-updates")
bcc = "X-DAK: dak rejected-proposed-updates\nX-Katie: lauren $Revision: 1.4 $"
if Cnf.has_key("Dinstall::Bcc"):
Upload.Subst["__BCC__"] = bcc
for arg in arguments:
- arg = daklib.utils.validate_changes_file_arg(arg)
+ arg = utils.validate_changes_file_arg(arg)
Upload.pkg.changes_file = arg
Upload.init_vars()
cwd = os.getcwd()
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 = queue.re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
# If we weren't given a manual rejection message, spawn an editor
# so the user can add one in...
if not reject_message:
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
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)
- reject_message = "".join(file.readlines())
- file.close()
+ f = utils.open_file(temp_filename)
+ reject_message = "".join(f.readlines())
+ f.close()
print "Reject message:"
- print daklib.utils.prefix_multi_line_string(reject_message," ", include_blank_lines=1)
+ print utils.prefix_multi_line_string(reject_message," ", include_blank_lines=1)
prompt = "[R]eject, 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 = queue.re_default_answer.search(prompt)
if answer == "":
answer = m.group(1)
answer = answer[:1].upper()
reject_fd = os.open(reject_filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
# Build up the rejection email
- user_email_address = daklib.utils.whoami() + " <%s>" % (Cnf["Dinstall::MyAdminAddress"])
+ user_email_address = utils.whoami() + " <%s>" % (Cnf["Dinstall::MyAdminAddress"])
Upload.Subst["__REJECTOR_ADDRESS__"] = user_email_address
Upload.Subst["__MANUAL_REJECT_MESSAGE__"] = reject_message
Upload.Subst["__STABLE_REJECTOR__"] = Cnf["Reject-Proposed-Updates::StableRejector"]
Upload.Subst["__MORE_INFO_URL__"] = Cnf["Reject-Proposed-Updates::MoreInfoURL"]
Upload.Subst["__CC__"] = "Cc: " + Cnf["Dinstall::MyEmailAddress"]
- reject_mail_message = daklib.utils.TemplateSubst(Upload.Subst,Cnf["Dir::Templates"]+"/reject-proposed-updates.rejected")
+ reject_mail_message = utils.TemplateSubst(Upload.Subst,Cnf["Dir::Templates"]+"/reject-proposed-updates.rejected")
# Write the rejection email out as the <foo>.reason file
os.write(reject_fd, reject_mail_message)
os.close(reject_fd)
# Remove the packages from proposed-updates
- suite_id = daklib.database.get_suite_id('proposed-updates')
+ suite_id = database.get_suite_id('proposed-updates')
projectB.query("BEGIN WORK")
# Remove files from proposed-updates suite
- for file in files.keys():
- if files[file]["type"] == "dsc":
+ for f in files.keys():
+ if files[f]["type"] == "dsc":
package = dsc["source"]
- version = dsc["version"]; # NB: not files[file]["version"], that has no epoch
+ version = dsc["version"]; # NB: not files[f]["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("reject: Couldn't find %s_%s in source table." % (package, version))
+ utils.fubar("reject: Couldn't find %s_%s in source table." % (package, version))
source_id = ql[0][0]
projectB.query("DELETE FROM src_associations WHERE suite = '%s' AND source = '%s'" % (suite_id, source_id))
- elif files[file]["type"] == "deb":
- package = files[file]["package"]
- version = files[file]["version"]
- architecture = files[file]["architecture"]
+ elif files[f]["type"] == "deb":
+ package = files[f]["package"]
+ version = files[f]["version"]
+ architecture = files[f]["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()
# newer version of the package and only do the
# warn&continue thing if it finds one.
if not ql:
- daklib.utils.warn("reject: Couldn't find %s_%s_%s in binaries table." % (package, version, architecture))
+ utils.warn("reject: Couldn't find %s_%s_%s in binaries table." % (package, version, architecture))
else:
binary_id = ql[0][0]
projectB.query("DELETE FROM bin_associations WHERE suite = '%s' AND bin = '%s'" % (suite_id, binary_id))
# Send the rejection mail if appropriate
if not Options["No-Mail"]:
- daklib.utils.send_mail(reject_mail_message)
+ utils.send_mail(reject_mail_message)
# Finally remove the .dak file
dot_dak_file = os.path.join(Cnf["Suite::Proposed-Updates::CopyDotDak"], os.path.basename(changes_file[:-8]+".dak"))
import commands, os, pg, re, sys
import apt_pkg, apt_inst
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
################################################################################
# the fuck are we gonna do now? What are we gonna do?"
def game_over():
- answer = daklib.utils.our_raw_input("Continue (y/N)? ").lower()
+ answer = utils.our_raw_input("Continue (y/N)? ").lower()
if answer != "y":
print "Aborted."
sys.exit(1)
for component in components:
filename = "%s/dists/%s/%s/binary-%s/Packages.gz" % (Cnf["Dir::Root"], suites[0], component, architecture)
# apt_pkg.ParseTagFile needs a real file handle and can't handle a GzipFile instance...
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
(result, output) = commands.getstatusoutput("gunzip -c %s > %s" % (filename, temp_filename))
if (result != 0):
- daklib.utils.fubar("Gunzip invocation failed!\n%s\n" % (output), result)
- packages = daklib.utils.open_file(temp_filename)
+ utils.fubar("Gunzip invocation failed!\n%s\n" % (output), result)
+ packages = utils.open_file(temp_filename)
Packages = apt_pkg.ParseTagFile(packages)
while Packages.Step():
package = Packages.Section.Find("Package")
what = "%s/%s" % (package, component)
else:
what = "** %s" % (package)
- print "%s has an unsatisfied dependency on %s: %s" % (what, architecture, daklib.utils.pp_deps(dep))
+ print "%s has an unsatisfied dependency on %s: %s" % (what, architecture, utils.pp_deps(dep))
dep_problem = 1
# Check source dependencies (Build-Depends and Build-Depends-Indep)
for component in components:
filename = "%s/dists/%s/%s/source/Sources.gz" % (Cnf["Dir::Root"], suites[0], component)
# apt_pkg.ParseTagFile needs a real file handle and can't handle a GzipFile instance...
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
result, output = commands.getstatusoutput("gunzip -c %s > %s" % (filename, temp_filename))
if result != 0:
sys.stderr.write("Gunzip invocation failed!\n%s\n" % (output))
sys.exit(result)
- sources = daklib.utils.open_file(temp_filename, "r")
+ sources = utils.open_file(temp_filename, "r")
Sources = apt_pkg.ParseTagFile(sources)
while Sources.Step():
source = Sources.Section.Find("Package")
source = "%s/%s" % (source, component)
else:
source = "** %s" % (source)
- print "%s has an unsatisfied build-dependency: %s" % (source, daklib.utils.pp_deps(dep))
+ print "%s has an unsatisfied build-dependency: %s" % (source, utils.pp_deps(dep))
dep_problem = 1
sources.close()
os.unlink(temp_filename)
def main ():
global Cnf, Options, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Rm::Options::Help"),
('a',"architecture","Rm::Options::Architecture", "HasArg"),
usage()
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
# Sanity check options
if not arguments:
- daklib.utils.fubar("need at least one package name as an argument.")
+ utils.fubar("need at least one package name as an argument.")
if Options["Architecture"] and Options["Source-Only"]:
- daklib.utils.fubar("can't use -a/--architecutre and -S/--source-only options simultaneously.")
+ utils.fubar("can't use -a/--architecutre and -S/--source-only options simultaneously.")
if Options["Binary-Only"] and Options["Source-Only"]:
- daklib.utils.fubar("can't use -b/--binary-only and -S/--source-only options simultaneously.")
+ utils.fubar("can't use -b/--binary-only and -S/--source-only options simultaneously.")
if Options.has_key("Carbon-Copy") and not Options.has_key("Done"):
- daklib.utils.fubar("can't use -C/--carbon-copy without also using -d/--done option.")
+ utils.fubar("can't use -C/--carbon-copy without also using -d/--done option.")
if Options["Architecture"] and not Options["Partial"]:
- daklib.utils.warn("-a/--architecture implies -p/--partial.")
+ utils.warn("-a/--architecture implies -p/--partial.")
Options["Partial"] = "true"
# Force the admin to tell someone if we're not doing a 'dak
# as telling someone).
if not Options["No-Action"] and not Options["Carbon-Copy"] \
and not Options["Done"] and Options["Reason"].find("[auto-cruft]") == -1:
- daklib.utils.fubar("Need a -C/--carbon-copy if not closing a bug and not doing a cruft removal.")
+ utils.fubar("Need a -C/--carbon-copy if not closing a bug and not doing a cruft removal.")
# Process -C/--carbon-copy
#
# 3) contains a '@' - assumed to be an email address, used unmofidied
#
carbon_copy = []
- for copy_to in daklib.utils.split_args(Options.get("Carbon-Copy")):
+ for copy_to in utils.split_args(Options.get("Carbon-Copy")):
if copy_to.isdigit():
carbon_copy.append(copy_to + "@" + Cnf["Dinstall::BugServer"])
elif copy_to == 'package':
elif '@' in copy_to:
carbon_copy.append(copy_to)
else:
- daklib.utils.fubar("Invalid -C/--carbon-copy argument '%s'; not a bug number, 'package' or email address." % (copy_to))
+ utils.fubar("Invalid -C/--carbon-copy argument '%s'; not a bug number, 'package' or email address." % (copy_to))
if Options["Binary-Only"]:
field = "b.package"
con_packages = "AND %s IN (%s)" % (field, ", ".join([ repr(i) for i in arguments ]))
(con_suites, con_architectures, con_components, check_source) = \
- daklib.utils.parse_args(Options)
+ utils.parse_args(Options)
# Additional suite checks
suite_ids_list = []
- suites = daklib.utils.split_args(Options["Suite"])
- suites_list = daklib.utils.join_with_commas_and(suites)
+ suites = utils.split_args(Options["Suite"])
+ suites_list = utils.join_with_commas_and(suites)
if not Options["No-Action"]:
for suite in suites:
- suite_id = daklib.database.get_suite_id(suite)
+ suite_id = database.get_suite_id(suite)
if suite_id != -1:
suite_ids_list.append(suite_id)
if suite == "stable":
# Additional architecture checks
if Options["Architecture"] and check_source:
- daklib.utils.warn("'source' in -a/--argument makes no sense and is ignored.")
+ utils.warn("'source' in -a/--argument makes no sense and is ignored.")
# Additional component processing
over_con_components = con_components.replace("c.id", "component")
for i in source_packages.keys():
filename = "/".join(source_packages[i])
try:
- dsc = daklib.utils.parse_changes(filename)
- except daklib.utils.cant_open_exc:
- daklib.utils.warn("couldn't open '%s'." % (filename))
+ dsc = utils.parse_changes(filename)
+ except utils.cant_open_exc:
+ utils.warn("couldn't open '%s'." % (filename))
continue
for package in dsc.get("binary").split(','):
package = package.strip()
q = projectB.query("SELECT l.path, f.filename, b.package, b.version, a.arch_string, b.id, b.maintainer FROM binaries b, bin_associations ba, architecture a, suite su, files f, location l, component c WHERE ba.bin = b.id AND ba.suite = su.id AND b.architecture = a.id AND b.file = f.id AND f.location = l.id AND l.component = c.id %s %s %s AND b.package = '%s'" % (con_suites, con_components, con_architectures, package))
for i in q.getresult():
filename = "/".join(i[:2])
- control = apt_pkg.ParseSection(apt_inst.debExtractControl(daklib.utils.open_file(filename)))
+ control = apt_pkg.ParseSection(apt_inst.debExtractControl(utils.open_file(filename)))
source = control.Find("Source", control.Find("Package"))
source = re_strip_source_version.sub('', source)
if source_packages.has_key(source):
# If we don't have a reason; spawn an editor so the user can add one
# Write the rejection email out as the <foo>.reason file
if not Options["Reason"] and not Options["No-Action"]:
- temp_filename = daklib.utils.temp_filename()
+ temp_filename = utils.temp_filename()
editor = os.environ.get("EDITOR","vi")
result = os.system("%s %s" % (editor, temp_filename))
if result != 0:
- daklib.utils.fubar ("vi invocation failed for `%s'!" % (temp_filename), result)
- temp_file = daklib.utils.open_file(temp_filename)
+ utils.fubar ("vi invocation failed for `%s'!" % (temp_filename), result)
+ temp_file = utils.open_file(temp_filename)
for line in temp_file.readlines():
Options["Reason"] += line
temp_file.close()
maintainer_list = []
for maintainer_id in maintainers.keys():
- maintainer_list.append(daklib.database.get_maintainer(maintainer_id))
+ maintainer_list.append(database.get_maintainer(maintainer_id))
summary = ""
removals = d.keys()
removals.sort()
versions = d[package].keys()
versions.sort(apt_pkg.VersionCompare)
for version in versions:
- d[package][version].sort(daklib.utils.arch_compare_sw)
+ d[package][version].sort(utils.arch_compare_sw)
summary += "%10s | %10s | %s\n" % (package, version, ", ".join(d[package][version]))
print "Will remove the following packages from %s:" % (suites_list)
print
print "Going to remove the packages now."
game_over()
- whoami = daklib.utils.whoami()
+ whoami = utils.whoami()
date = commands.getoutput('date -R')
# Log first; if it all falls apart I want a record that we at least tried.
- logfile = daklib.utils.open_file(Cnf["Rm::LogFile"], 'a')
+ logfile = utils.open_file(Cnf["Rm::LogFile"], 'a')
logfile.write("=========================================================================\n")
logfile.write("[Date: %s] [ftpmaster: %s]\n" % (date, whoami))
logfile.write("Removed the following packages from %s:\n\n%s" % (suites_list, summary))
logfile.write("----------------------------------------------\n")
logfile.flush()
- dsc_type_id = daklib.database.get_override_type_id('dsc')
- deb_type_id = daklib.database.get_override_type_id('deb')
+ dsc_type_id = database.get_override_type_id('dsc')
+ deb_type_id = database.get_override_type_id('deb')
# Do the actual deletion
print "Deleting...",
Subst["__ADMIN_ADDRESS__"] = Cnf["Dinstall::MyAdminAddress"]
Subst["__DISTRO__"] = Cnf["Dinstall::MyDistribution"]
Subst["__WHOAMI__"] = whoami
- whereami = daklib.utils.where_am_i()
+ whereami = utils.where_am_i()
Archive = Cnf.SubTree("Archive::%s" % (whereami))
Subst["__MASTER_ARCHIVE__"] = Archive["OriginServer"]
Subst["__PRIMARY_MIRROR__"] = Archive["PrimaryMirror"]
- for bug in daklib.utils.split_args(Options["Done"]):
+ for bug in utils.split_args(Options["Done"]):
Subst["__BUG_NUMBER__"] = bug
- mail_message = daklib.utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/rm.bug-close")
- daklib.utils.send_mail(mail_message)
+ mail_message = utils.TemplateSubst(Subst,Cnf["Dir::Templates"]+"/rm.bug-close")
+ utils.send_mail(mail_message)
logfile.write("=========================================================================\n")
logfile.close()
import commands, os, pwd, re, sys, time
import apt_pkg
-import daklib.queue
+import daklib.queue as queue
import daklib.utils
################################################################################
print "Not uploading amd64 part to ftp-master\n"
continue
# Build the file list for this .changes file
- for file in files.keys():
+ for f in files.keys():
poolname = os.path.join(Cnf["Dir::Root"], Cnf["Dir::PoolRoot"],
- daklib.utils.poolify(changes["source"], files[file]["component"]),
- file)
+ daklib.utils.poolify(changes["source"], files[f]["component"]),
+ f)
file_list.append(poolname)
- orig_component = files[file].get("original component", files[file]["component"])
+ orig_component = files[f].get("original component", files[f]["component"])
components[orig_component] = ""
# Determine the upload uri for this .changes file
for component in components.keys():
if not Options["No-Action"]:
filename = "%s/testing-processed" % (Cnf["Dir::Log"])
- file = daklib.utils.open_file(filename, 'a')
+ f = daklib.utils.open_file(filename, 'a')
for source in package_list.keys():
for version in package_list[source].keys():
- file.write(" ".join([source, version])+'\n')
- file.close()
+ f.write(" ".join([source, version])+'\n')
+ f.close()
######################################################################
# This function was originally written by aj and NIHishly merged into
updated_pkgs[suite] = {}
files = Upload.pkg.files
- for file in files.keys():
- arch = files[file]["architecture"]
- md5 = files[file]["md5sum"]
- size = files[file]["size"]
+ for f in files.keys():
+ arch = files[f]["architecture"]
+ md5 = files[f]["md5sum"]
+ size = files[f]["size"]
poolname = Cnf["Dir::PoolRoot"] + \
- daklib.utils.poolify(src, files[file]["component"])
- if arch == "source" and file.endswith(".dsc"):
+ daklib.utils.poolify(src, files[f]["component"])
+ if arch == "source" and f.endswith(".dsc"):
dscpoolname = poolname
for suite in suites:
if not updated_pkgs[suite].has_key(arch):
updated_pkgs[suite][arch] = {}
- updated_pkgs[suite][arch][file] = {
+ updated_pkgs[suite][arch][f] = {
"md5": md5, "size": size,
"poolname": poolname }
dsc_files = Upload.pkg.dsc_files
- for file in dsc_files.keys():
+ for f in dsc_files.keys():
arch = "source"
- if not dsc_files[file].has_key("files id"):
+ if not dsc_files[f].has_key("files id"):
continue
# otherwise, it's already in the pool and needs to be
# listed specially
- md5 = dsc_files[file]["md5sum"]
- size = dsc_files[file]["size"]
+ md5 = dsc_files[f]["md5sum"]
+ size = dsc_files[f]["size"]
for suite in suites:
if not updated_pkgs[suite].has_key(arch):
updated_pkgs[suite][arch] = {}
- updated_pkgs[suite][arch][file] = {
+ updated_pkgs[suite][arch][f] = {
"md5": md5, "size": size,
"poolname": dscpoolname }
adv += " %s architecture (%s)\n\n" % (a,
Cnf["Architectures::%s" % a])
- for file in updated_pkgs[suite][a].keys():
+ for f in updated_pkgs[suite][a].keys():
adv += " http://%s/%s%s\n" % (
- archive, updated_pkgs[suite][a][file]["poolname"], file)
+ archive, updated_pkgs[suite][a][f]["poolname"], f)
adv += " Size/MD5 checksum: %8s %s\n" % (
- updated_pkgs[suite][a][file]["size"],
- updated_pkgs[suite][a][file]["md5"])
+ updated_pkgs[suite][a][f]["size"],
+ updated_pkgs[suite][a][f]["md5"])
adv += "\n"
adv = adv.rstrip()
arguments = apt_pkg.ParseCommandLine(Cnf,Arguments,sys.argv)
Options = Cnf.SubTree("Security-Install::Options")
- Upload = daklib.queue.Upload(Cnf)
+ Upload = queue.Upload(Cnf)
if Options["Help"]:
usage(0)
if advisory_number.endswith(".changes"):
daklib.utils.warn("first argument must be the advisory number.")
usage(1)
- for file in changes_files:
- file = daklib.utils.validate_changes_file_arg(file)
+ for f in changes_files:
+ f = daklib.utils.validate_changes_file_arg(f)
return (advisory_number, changes_files)
######################################################################
if not Options["No-Action"]:
print "About to install the following files: "
- for file in changes_files:
- print " %s" % (file)
+ for f in changes_files:
+ print " %s" % (f)
answer = yes_no("Continue (Y/n)?")
if answer == "n":
sys.exit(0)
import copy, os, sys, time
import apt_pkg
import examine_package
-import daklib.database
-import daklib.queue
-import daklib.utils
+import daklib.database as database
+import daklib.queue as queue
+import daklib.utils as utils
# Globals
Cnf = None
changes["suite"] = copy.copy(changes["distribution"])
# Find out what's new
- new = daklib.queue.determine_new(changes, files, projectB, 0)
+ new = queue.determine_new(changes, files, projectB, 0)
stdout_fd = sys.stdout
html_header(changes["source"], filestoexamine)
- daklib.queue.check_valid(new)
+ queue.check_valid(new)
examine_package.display_changes(Upload.pkg.changes_file)
for fn in filter(lambda fn: fn.endswith(".dsc"), filestoexamine):
def init():
global Cnf, Options, Upload, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Show-New::Options::Help"),
("p","html-path","Show-New::HTMLPath","HasArg")]
if Options["help"]:
usage()
- Upload = daklib.queue.Upload(Cnf)
+ Upload = queue.Upload(Cnf)
projectB = Upload.projectB
examine_package.use_html=1
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)
files = set(os.listdir(Cnf["Show-New::HTMLPath"]))
to_delete = filter(lambda x: x.endswith(".html"), files.difference(sources))
- for file in to_delete:
- os.remove(os.path.join(Cnf["Show-New::HTMLPath"],file))
+ for f in to_delete:
+ os.remove(os.path.join(Cnf["Show-New::HTMLPath"],f))
################################################################################
################################################################################
import glob, os, stat, time
-import daklib.utils
+import daklib.utils as utils
################################################################################
def main():
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
count = 0
move_date = int(time.time())-(30*84600)
os.chdir(Cnf["Dir::Queue::Done"])
os.makedirs(dirname)
dest = dirname + '/' + os.path.basename(filename)
if os.path.exists(dest):
- daklib.utils.fubar("%s already exists." % (dest))
+ utils.fubar("%s already exists." % (dest))
print "Move: %s -> %s" % (filename, dest)
os.rename(filename, dest)
count = count + 1
import pg, sys
import apt_pkg
-import daklib.utils
+import daklib.utils as utils
################################################################################
def daily_install_stats():
stats = {}
- file = daklib.utils.open_file("2001-11")
- for line in file.readlines():
+ f = utils.open_file("2001-11")
+ for line in f.readlines():
split = line.strip().split('|')
program = split[1]
if program != "katie" and program != "process-accepted":
q = projectB.query("SELECT id, suite_name FROM suite")
suite_ql = q.getresult()
for i in suite_ql:
- (id, name) = i
- suites[id] = name
- suite_ids[name] = id
+ (sid, name) = i
+ suites[sid] = name
+ suite_ids[name] = sid
# Build up architecture mapping
q = projectB.query("SELECT id, arch_string FROM architecture")
for i in q.getresult():
- (id, name) = i
- arches[id] = name
- arch_ids[name] = id
+ (aid, name) = i
+ arches[aid] = name
+ arch_ids[name] = aid
# Pre-create the dictionary
for suite_id in suites.keys():
d[suite_id] = {}
def main ():
global Cnf, projectB
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Stats::Options::Help")]
for i in [ "help" ]:
if not Cnf.has_key("Stats::Options::%s" % (i)):
usage()
if len(args) < 1:
- daklib.utils.warn("dak stats requires a MODE argument")
+ utils.warn("dak stats requires a MODE argument")
usage(1)
elif len(args) > 1:
- daklib.utils.warn("dak stats accepts only one MODE argument")
+ utils.warn("dak stats accepts only one MODE argument")
usage(1)
mode = args[0].lower()
elif mode == "daily-install":
daily_install_stats()
else:
- daklib.utils.warn("unknown mode '%s'" % (mode))
+ utils.warn("unknown mode '%s'" % (mode))
usage(1)
################################################################################
################################################################################
-def find_dislocated_stable(Cnf, projectB):
+def find_dislocated_stable(Conf, DBConn):
dislocated_files = {}
- codename = Cnf["Suite::Stable::Codename"]
+ codename = Conf["Suite::Stable::Codename"]
# Source
- q = projectB.query("""
+ q = DBConn.query("""
SELECT DISTINCT ON (f.id) c.name, sec.section, l.path, f.filename, f.id
FROM component c, override o, section sec, source s, files f, location l,
dsc_files df, suite su, src_associations sa, files f2, location l2
# AND NOT EXISTS (SELECT 1 FROM location l WHERE l.component IS NOT NULL AND f.location = l.id)
for i in q.getresult():
(component, section) = fix_component_section(i[0], i[1])
- if Cnf.FindB("Dinstall::LegacyStableHasNoSections"):
+ if Conf.FindB("Dinstall::LegacyStableHasNoSections"):
section=""
- dest = "%sdists/%s/%s/source/%s%s" % (Cnf["Dir::Root"], codename, component, section, os.path.basename(i[3]))
+ dest = "%sdists/%s/%s/source/%s%s" % (Conf["Dir::Root"], codename, component, section, os.path.basename(i[3]))
if not os.path.exists(dest):
src = i[2]+i[3]
- src = daklib.utils.clean_symlink(src, dest, Cnf["Dir::Root"])
- if Cnf.Find("Symlink-Dists::Options::Verbose"):
+ src = daklib.utils.clean_symlink(src, dest, Conf["Dir::Root"])
+ if Conf.Find("Symlink-Dists::Options::Verbose"):
print src+' -> '+dest
os.symlink(src, dest)
dislocated_files[i[4]] = dest
# Binary
- architectures = filter(daklib.utils.real_arch, Cnf.ValueList("Suite::Stable::Architectures"))
- q = projectB.query("""
+ architectures = filter(daklib.utils.real_arch, Conf.ValueList("Suite::Stable::Architectures"))
+ q = DBConn.query("""
SELECT DISTINCT ON (f.id) c.name, a.arch_string, sec.section, b.package,
b.version, l.path, f.filename, f.id
FROM architecture a, bin_associations ba, binaries b, component c, files f,
# (SELECT 1 FROM location l WHERE l.component IS NOT NULL AND f.location = l.id)
for i in q.getresult():
(component, section) = fix_component_section(i[0], i[2])
- if Cnf.FindB("Dinstall::LegacyStableHasNoSections"):
+ if Conf.FindB("Dinstall::LegacyStableHasNoSections"):
section=""
architecture = i[1]
package = i[3]
version = daklib.utils.re_no_epoch.sub('', i[4])
src = i[5]+i[6]
- dest = "%sdists/%s/%s/binary-%s/%s%s_%s.deb" % (Cnf["Dir::Root"], codename, component, architecture, section, package, version)
- src = daklib.utils.clean_symlink(src, dest, Cnf["Dir::Root"])
+ dest = "%sdists/%s/%s/binary-%s/%s%s_%s.deb" % (Conf["Dir::Root"], codename, component, architecture, section, package, version)
+ src = daklib.utils.clean_symlink(src, dest, Conf["Dir::Root"])
if not os.path.exists(dest):
- if Cnf.Find("Symlink-Dists::Options::Verbose"):
+ if Conf.Find("Symlink-Dists::Options::Verbose"):
print src+' -> '+dest
os.symlink(src, dest)
dislocated_files[i[7]] = dest
# Add per-arch symlinks for arch: all debs
if architecture == "all":
for arch in architectures:
- dest = "%sdists/%s/%s/binary-%s/%s%s_%s.deb" % (Cnf["Dir::Root"], codename, component, arch, section, package, version)
+ dest = "%sdists/%s/%s/binary-%s/%s%s_%s.deb" % (Conf["Dir::Root"], codename, component, arch, section, package, version)
if not os.path.exists(dest):
- if Cnf.Find("Symlink-Dists::Options::Verbose"):
+ if Conf.Find("Symlink-Dists::Options::Verbose"):
print src+' -> '+dest
os.symlink(src, dest)
import os, pg, sys, time, errno, fcntl, tempfile, pwd, re
import apt_pkg
-import daklib.database
-import daklib.utils
+import daklib.database as database
+import daklib.utils as utils
import syck
# Globals
apt_pkg.init()
- Cnf = daklib.utils.get_conf()
+ Cnf = utils.get_conf()
Arguments = [('h',"help","Edit-Transitions::Options::Help"),
('e',"edit","Edit-Transitions::Options::Edit"),
Options["sudo"] = "y"
projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
- daklib.database.init(Cnf, projectB)
+ database.init(Cnf, projectB)
################################################################################
#####################################
#### This may run within sudo !! ####
#####################################
-def lock_file(file):
+def lock_file(f):
for retry in range(10):
- lock_fd = os.open(file, os.O_RDWR | os.O_CREAT)
+ lock_fd = os.open(f, os.O_RDWR | os.O_CREAT)
try:
fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
return lock_fd
else:
raise
- daklib.utils.fubar("Couldn't obtain lock for %s." % (lockfile))
+ utils.fubar("Couldn't obtain lock for %s." % (f))
################################################################################
result = os.system("%s %s" % (editor, edit_file))
if result != 0:
os.unlink(edit_file)
- daklib.utils.fubar("%s invocation failed for %s, not removing tempfile." % (editor, edit_file))
+ utils.fubar("%s invocation failed for %s, not removing tempfile." % (editor, edit_file))
# Now try to load the new file
test = load_transitions(edit_file)
answer = "XXX"
while prompt.find(answer) == -1:
- answer = daklib.utils.our_raw_input(prompt)
+ answer = utils.our_raw_input(prompt)
if answer == "":
answer = default
answer = answer[:1].upper()
expected = t["new"]
# Will be None if nothing is in testing.
- current = daklib.database.get_suite_version(source, "testing")
+ current = database.get_suite_version(source, "testing")
print_info(trans, source, expected, t["rm"], t["reason"], t["packages"])
if Options["no-action"]:
answer="n"
else:
- answer = daklib.utils.our_raw_input(prompt).lower()
+ answer = utils.our_raw_input(prompt).lower()
if answer == "":
answer = "n"
expected = t["new"]
# Will be None if nothing is in testing.
- current = daklib.database.get_suite_version(source, "testing")
+ current = database.get_suite_version(source, "testing")
print_info(trans, source, expected, t["rm"], t["reason"], t["packages"])
# Check if there is a file defined (and existant)
transpath = Cnf.get("Dinstall::Reject::ReleaseTransitions", "")
if transpath == "":
- daklib.utils.warn("Dinstall::Reject::ReleaseTransitions not defined")
+ utils.warn("Dinstall::Reject::ReleaseTransitions not defined")
sys.exit(1)
if not os.path.exists(transpath):
- daklib.utils.warn("ReleaseTransitions file, %s, not found." %
+ utils.warn("ReleaseTransitions file, %s, not found." %
(Cnf["Dinstall::Reject::ReleaseTransitions"]))
sys.exit(1)
# Also check if our temp directory is defined and existant
temppath = Cnf.get("Transitions::TempPath", "")
if temppath == "":
- daklib.utils.warn("Transitions::TempPath not defined")
+ utils.warn("Transitions::TempPath not defined")
sys.exit(1)
if not os.path.exists(temppath):
- daklib.utils.warn("Temporary path %s not found." %
+ utils.warn("Temporary path %s not found." %
(Cnf["Transitions::TempPath"]))
sys.exit(1)
transitions = load_transitions(transpath)
if transitions == None:
# Something very broken with the transitions, exit
- daklib.utils.warn("Could not parse existing transitions file. Aborting.")
+ utils.warn("Could not parse existing transitions file. Aborting.")
sys.exit(2)
if Options["edit"]:
projects / dak.git / commitdiff