dak/import_archive.py

   1 #!/usr/bin/env python
   2
   3 # Populate the DB
   4 # Copyright (C) 2000, 2001, 2002, 2003, 2004, 2006  James Troup <james@nocrew.org>
   5
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19
  20 ###############################################################################
  21
  22 # 04:36|<aj> elmo: you're making me waste 5 seconds per architecture!!!!!! YOU BASTARD!!!!!
  23
  24 ###############################################################################
  25
  26 # This code is a horrible mess for two reasons:
  27
  28 #   (o) For Debian's usage, it's doing something like 160k INSERTs,
  29 #   even on auric, that makes the program unusable unless we get
  30 #   involed in sorts of silly optimization games (local dicts to avoid
  31 #   redundant SELECTS, using COPY FROM rather than INSERTS etc.)
  32
  33 #   (o) It's very site specific, because I don't expect to use this
  34 #   script again in a hurry, and I don't want to spend any more time
  35 #   on it than absolutely necessary.
  36
  37 ###############################################################################
  38
  39 import commands, os, pg, re, sys, time
  40 import apt_pkg
  41 import dak.lib.database, dak.lib.utils
  42
  43 ###############################################################################
  44
  45 re_arch_from_filename = re.compile(r"binary-[^/]+")
  46
  47 ###############################################################################
  48
  49 Cnf = None
  50 projectB = None
  51 files_id_cache = {}
  52 source_cache = {}
  53 arch_all_cache = {}
  54 binary_cache = {}
  55 location_path_cache = {}
  56 #
  57 files_id_serial = 0
  58 source_id_serial = 0
  59 src_associations_id_serial = 0
  60 dsc_files_id_serial = 0
  61 files_query_cache = None
  62 source_query_cache = None
  63 src_associations_query_cache = None
  64 dsc_files_query_cache = None
  65 orig_tar_gz_cache = {}
  66 #
  67 binaries_id_serial = 0
  68 binaries_query_cache = None
  69 bin_associations_id_serial = 0
  70 bin_associations_query_cache = None
  71 #
  72 source_cache_for_binaries = {}
  73 reject_message = ""
  74
  75 ################################################################################
  76
  77 def usage(exit_code=0):
  78     print """Usage: dak import-archive
  79 Initializes a projectB database from an existing archive
  80
  81   -a, --action              actually perform the initalization
  82   -h, --help                show this help and exit."""
  83     sys.exit(exit_code)
  84
  85 ###############################################################################
  86
  87 def reject (str, prefix="Rejected: "):
  88     global reject_message
  89     if str:
  90         reject_message += prefix + str + "\n"
  91
  92 ###############################################################################
  93
  94 def check_signature (filename):
  95     if not dak.lib.utils.re_taint_free.match(os.path.basename(filename)):
  96         reject("!!WARNING!! tainted filename: '%s'." % (filename))
  97         return None
  98
  99     status_read, status_write = os.pipe()
 100     cmd = "gpgv --status-fd %s --keyring %s --keyring %s %s" \
 101           % (status_write, Cnf["Dinstall::PGPKeyring"], Cnf["Dinstall::GPGKeyring"], filename)
 102     (output, status, exit_status) = dak.lib.utils.gpgv_get_status_output(cmd, status_read, status_write)
 103
 104     # Process the status-fd output
 105     keywords = {}
 106     bad = internal_error = ""
 107     for line in status.split('\n'):
 108         line = line.strip()
 109         if line == "":
 110             continue
 111         split = line.split()
 112         if len(split) < 2:
 113             internal_error += "gpgv status line is malformed (< 2 atoms) ['%s'].\n" % (line)
 114             continue
 115         (gnupg, keyword) = split[:2]
 116         if gnupg != "[GNUPG:]":
 117             internal_error += "gpgv status line is malformed (incorrect prefix '%s').\n" % (gnupg)
 118             continue
 119         args = split[2:]
 120         if keywords.has_key(keyword) and keyword != "NODATA" and keyword != "SIGEXPIRED":
 121             internal_error += "found duplicate status token ('%s').\n" % (keyword)
 122             continue
 123         else:
 124             keywords[keyword] = args
 125
 126     # If we failed to parse the status-fd output, let's just whine and bail now
 127     if internal_error:
 128         reject("internal error while performing signature check on %s." % (filename))
 129         reject(internal_error, "")
 130         reject("Please report the above errors to the Archive maintainers by replying to this mail.", "")
 131         return None
 132
 133     # Now check for obviously bad things in the processed output
 134     if keywords.has_key("SIGEXPIRED"):
 135         dak.lib.utils.warn("%s: signing key has expired." % (filename))
 136     if keywords.has_key("KEYREVOKED"):
 137         reject("key used to sign %s has been revoked." % (filename))
 138         bad = 1
 139     if keywords.has_key("BADSIG"):
 140         reject("bad signature on %s." % (filename))
 141         bad = 1
 142     if keywords.has_key("ERRSIG") and not keywords.has_key("NO_PUBKEY"):
 143         reject("failed to check signature on %s." % (filename))
 144         bad = 1
 145     if keywords.has_key("NO_PUBKEY"):
 146         args = keywords["NO_PUBKEY"]
 147         if len(args) < 1:
 148             reject("internal error while checking signature on %s." % (filename))
 149             bad = 1
 150         else:
 151             fingerprint = args[0]
 152     if keywords.has_key("BADARMOR"):
 153         reject("ascii armour of signature was corrupt in %s." % (filename))
 154         bad = 1
 155     if keywords.has_key("NODATA"):
 156         dak.lib.utils.warn("no signature found for %s." % (filename))
 157         return "NOSIG"
 158         #reject("no signature found in %s." % (filename))
 159         #bad = 1
 160
 161     if bad:
 162         return None
 163
 164     # Next check gpgv exited with a zero return code
 165     if exit_status and not keywords.has_key("NO_PUBKEY"):
 166         reject("gpgv failed while checking %s." % (filename))
 167         if status.strip():
 168             reject(dak.lib.utils.prefix_multi_line_string(status, " [GPG status-fd output:] "), "")
 169         else:
 170             reject(dak.lib.utils.prefix_multi_line_string(output, " [GPG output:] "), "")
 171         return None
 172
 173     # Sanity check the good stuff we expect
 174     if not keywords.has_key("VALIDSIG"):
 175         if not keywords.has_key("NO_PUBKEY"):
 176             reject("signature on %s does not appear to be valid [No VALIDSIG]." % (filename))
 177             bad = 1
 178     else:
 179         args = keywords["VALIDSIG"]
 180         if len(args) < 1:
 181             reject("internal error while checking signature on %s." % (filename))
 182             bad = 1
 183         else:
 184             fingerprint = args[0]
 185     if not keywords.has_key("GOODSIG") and not keywords.has_key("NO_PUBKEY"):
 186         reject("signature on %s does not appear to be valid [No GOODSIG]." % (filename))
 187         bad = 1
 188     if not keywords.has_key("SIG_ID") and not keywords.has_key("NO_PUBKEY"):
 189         reject("signature on %s does not appear to be valid [No SIG_ID]." % (filename))
 190         bad = 1
 191
 192     # Finally ensure there's not something we don't recognise
 193     known_keywords = dak.lib.utils.Dict(VALIDSIG="",SIG_ID="",GOODSIG="",BADSIG="",ERRSIG="",
 194                                 SIGEXPIRED="",KEYREVOKED="",NO_PUBKEY="",BADARMOR="",
 195                                 NODATA="")
 196
 197     for keyword in keywords.keys():
 198         if not known_keywords.has_key(keyword):
 199             reject("found unknown status token '%s' from gpgv with args '%r' in %s." % (keyword, keywords[keyword], filename))
 200             bad = 1
 201
 202     if bad:
 203         return None
 204     else:
 205         return fingerprint
 206
 207 ################################################################################
 208
 209 # Prepares a filename or directory (s) to be file.filename by stripping any part of the location (sub) from it.
 210 def poolify (s, sub):
 211     for i in xrange(len(sub)):
 212         if sub[i:] == s[0:len(sub)-i]:
 213             return s[len(sub)-i:]
 214     return s
 215
 216 def update_archives ():
 217     projectB.query("DELETE FROM archive")
 218     for archive in Cnf.SubTree("Archive").List():
 219         SubSec = Cnf.SubTree("Archive::%s" % (archive))
 220         projectB.query("INSERT INTO archive (name, origin_server, description) VALUES ('%s', '%s', '%s')"
 221                        % (archive, SubSec["OriginServer"], SubSec["Description"]))
 222
 223 def update_components ():
 224     projectB.query("DELETE FROM component")
 225     for component in Cnf.SubTree("Component").List():
 226         SubSec = Cnf.SubTree("Component::%s" % (component))
 227         projectB.query("INSERT INTO component (name, description, meets_dfsg) VALUES ('%s', '%s', '%s')" %
 228                        (component, SubSec["Description"], SubSec["MeetsDFSG"]))
 229
 230 def update_locations ():
 231     projectB.query("DELETE FROM location")
 232     for location in Cnf.SubTree("Location").List():
 233         SubSec = Cnf.SubTree("Location::%s" % (location))
 234         archive_id = dak.lib.database.get_archive_id(SubSec["archive"])
 235         type = SubSec.Find("type")
 236         if type == "legacy-mixed":
 237             projectB.query("INSERT INTO location (path, archive, type) VALUES ('%s', %d, '%s')" % (location, archive_id, SubSec["type"]))
 238         else:
 239             for component in Cnf.SubTree("Component").List():
 240                 component_id = dak.lib.database.get_component_id(component)
 241                 projectB.query("INSERT INTO location (path, component, archive, type) VALUES ('%s', %d, %d, '%s')" %
 242                                (location, component_id, archive_id, SubSec["type"]))
 243
 244 def update_architectures ():
 245     projectB.query("DELETE FROM architecture")
 246     for arch in Cnf.SubTree("Architectures").List():
 247         projectB.query("INSERT INTO architecture (arch_string, description) VALUES ('%s', '%s')" % (arch, Cnf["Architectures::%s" % (arch)]))
 248
 249 def update_suites ():
 250     projectB.query("DELETE FROM suite")
 251     for suite in Cnf.SubTree("Suite").List():
 252         SubSec = Cnf.SubTree("Suite::%s" %(suite))
 253         projectB.query("INSERT INTO suite (suite_name) VALUES ('%s')" % suite.lower())
 254         for i in ("Version", "Origin", "Description"):
 255             if SubSec.has_key(i):
 256                 projectB.query("UPDATE suite SET %s = '%s' WHERE suite_name = '%s'" % (i.lower(), SubSec[i], suite.lower()))
 257         for architecture in Cnf.ValueList("Suite::%s::Architectures" % (suite)):
 258             architecture_id = dak.lib.database.get_architecture_id (architecture)
 259             projectB.query("INSERT INTO suite_architectures (suite, architecture) VALUES (currval('suite_id_seq'), %d)" % (architecture_id))
 260
 261 def update_override_type():
 262     projectB.query("DELETE FROM override_type")
 263     for type in Cnf.ValueList("OverrideType"):
 264         projectB.query("INSERT INTO override_type (type) VALUES ('%s')" % (type))
 265
 266 def update_priority():
 267     projectB.query("DELETE FROM priority")
 268     for priority in Cnf.SubTree("Priority").List():
 269         projectB.query("INSERT INTO priority (priority, level) VALUES ('%s', %s)" % (priority, Cnf["Priority::%s" % (priority)]))
 270
 271 def update_section():
 272     projectB.query("DELETE FROM section")
 273     for component in Cnf.SubTree("Component").List():
 274         if Cnf["Control-Overrides::ComponentPosition"] == "prefix":
 275             suffix = ""
 276             if component != 'main':
 277                 prefix = component + '/'
 278             else:
 279                 prefix = ""
 280         else:
 281             prefix = ""
 282             component = component.replace("non-US/", "")
 283             if component != 'main':
 284                 suffix = '/' + component
 285             else:
 286                 suffix = ""
 287         for section in Cnf.ValueList("Section"):
 288             projectB.query("INSERT INTO section (section) VALUES ('%s%s%s')" % (prefix, section, suffix))
 289
 290 def get_location_path(directory):
 291     global location_path_cache
 292
 293     if location_path_cache.has_key(directory):
 294         return location_path_cache[directory]
 295
 296     q = projectB.query("SELECT DISTINCT path FROM location WHERE path ~ '%s'" % (directory))
 297     try:
 298         path = q.getresult()[0][0]
 299     except:
 300         dak.lib.utils.fubar("[import-archive] get_location_path(): Couldn't get path for %s" % (directory))
 301     location_path_cache[directory] = path
 302     return path
 303
 304 ################################################################################
 305
 306 def get_or_set_files_id (filename, size, md5sum, location_id):
 307     global files_id_cache, files_id_serial, files_query_cache
 308
 309     cache_key = "~".join((filename, size, md5sum, repr(location_id)))
 310     if not files_id_cache.has_key(cache_key):
 311         files_id_serial += 1
 312         files_query_cache.write("%d\t%s\t%s\t%s\t%d\t\\N\n" % (files_id_serial, filename, size, md5sum, location_id))
 313         files_id_cache[cache_key] = files_id_serial
 314
 315     return files_id_cache[cache_key]
 316
 317 ###############################################################################
 318
 319 def process_sources (filename, suite, component, archive):
 320     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
 321
 322     suite = suite.lower()
 323     suite_id = dak.lib.database.get_suite_id(suite)
 324     try:
 325         file = dak.lib.utils.open_file (filename)
 326     except dak.lib.utils.cant_open_exc:
 327         dak.lib.utils.warn("can't open '%s'" % (filename))
 328         return
 329     Scanner = apt_pkg.ParseTagFile(file)
 330     while Scanner.Step() != 0:
 331         package = Scanner.Section["package"]
 332         version = Scanner.Section["version"]
 333         directory = Scanner.Section["directory"]
 334         dsc_file = os.path.join(Cnf["Dir::Root"], directory, "%s_%s.dsc" % (package, dak.lib.utils.re_no_epoch.sub('', version)))
 335         # Sometimes the Directory path is a lie; check in the pool
 336         if not os.path.exists(dsc_file):
 337             if directory.split('/')[0] == "dists":
 338                 directory = Cnf["Dir::PoolRoot"] + dak.lib.utils.poolify(package, component)
 339                 dsc_file = os.path.join(Cnf["Dir::Root"], directory, "%s_%s.dsc" % (package, dak.lib.utils.re_no_epoch.sub('', version)))
 340         if not os.path.exists(dsc_file):
 341             dak.lib.utils.fubar("%s not found." % (dsc_file))
 342         install_date = time.strftime("%Y-%m-%d", time.localtime(os.path.getmtime(dsc_file)))
 343         fingerprint = check_signature(dsc_file)
 344         fingerprint_id = dak.lib.database.get_or_set_fingerprint_id(fingerprint)
 345         if reject_message:
 346             dak.lib.utils.fubar("%s: %s" % (dsc_file, reject_message))
 347         maintainer = Scanner.Section["maintainer"]
 348         maintainer = maintainer.replace("'", "\\'")
 349         maintainer_id = dak.lib.database.get_or_set_maintainer_id(maintainer)
 350         location = get_location_path(directory.split('/')[0])
 351         location_id = dak.lib.database.get_location_id (location, component, archive)
 352         if not directory.endswith("/"):
 353             directory += '/'
 354         directory = poolify (directory, location)
 355         if directory != "" and not directory.endswith("/"):
 356             directory += '/'
 357         no_epoch_version = dak.lib.utils.re_no_epoch.sub('', version)
 358         # Add all files referenced by the .dsc to the files table
 359         ids = []
 360         for line in Scanner.Section["files"].split('\n'):
 361             id = None
 362             (md5sum, size, filename) = line.strip().split()
 363             # Don't duplicate .orig.tar.gz's
 364             if filename.endswith(".orig.tar.gz"):
 365                 cache_key = "%s~%s~%s" % (filename, size, md5sum)
 366                 if orig_tar_gz_cache.has_key(cache_key):
 367                     id = orig_tar_gz_cache[cache_key]
 368                 else:
 369                     id = get_or_set_files_id (directory + filename, size, md5sum, location_id)
 370                     orig_tar_gz_cache[cache_key] = id
 371             else:
 372                 id = get_or_set_files_id (directory + filename, size, md5sum, location_id)
 373             ids.append(id)
 374             # If this is the .dsc itself; save the ID for later.
 375             if filename.endswith(".dsc"):
 376                 files_id = id
 377         filename = directory + package + '_' + no_epoch_version + '.dsc'
 378         cache_key = "%s~%s" % (package, version)
 379         if not source_cache.has_key(cache_key):
 380             nasty_key = "%s~%s" % (package, version)
 381             source_id_serial += 1
 382             if not source_cache_for_binaries.has_key(nasty_key):
 383                 source_cache_for_binaries[nasty_key] = source_id_serial
 384             tmp_source_id = source_id_serial
 385             source_cache[cache_key] = source_id_serial
 386             source_query_cache.write("%d\t%s\t%s\t%d\t%d\t%s\t%s\n" % (source_id_serial, package, version, maintainer_id, files_id, install_date, fingerprint_id))
 387             for id in ids:
 388                 dsc_files_id_serial += 1
 389                 dsc_files_query_cache.write("%d\t%d\t%d\n" % (dsc_files_id_serial, tmp_source_id,id))
 390         else:
 391             tmp_source_id = source_cache[cache_key]
 392
 393         src_associations_id_serial += 1
 394         src_associations_query_cache.write("%d\t%d\t%d\n" % (src_associations_id_serial, suite_id, tmp_source_id))
 395
 396     file.close()
 397
 398 ###############################################################################
 399
 400 def process_packages (filename, suite, component, archive):
 401     global arch_all_cache, binary_cache, binaries_id_serial, binaries_query_cache, bin_associations_id_serial, bin_associations_query_cache, reject_message
 402
 403     count_total = 0
 404     count_bad = 0
 405     suite = suite.lower()
 406     suite_id = dak.lib.database.get_suite_id(suite)
 407     try:
 408         file = dak.lib.utils.open_file (filename)
 409     except dak.lib.utils.cant_open_exc:
 410         dak.lib.utils.warn("can't open '%s'" % (filename))
 411         return
 412     Scanner = apt_pkg.ParseTagFile(file)
 413     while Scanner.Step() != 0:
 414         package = Scanner.Section["package"]
 415         version = Scanner.Section["version"]
 416         maintainer = Scanner.Section["maintainer"]
 417         maintainer = maintainer.replace("'", "\\'")
 418         maintainer_id = dak.lib.database.get_or_set_maintainer_id(maintainer)
 419         architecture = Scanner.Section["architecture"]
 420         architecture_id = dak.lib.database.get_architecture_id (architecture)
 421         fingerprint = "NOSIG"
 422         fingerprint_id = dak.lib.database.get_or_set_fingerprint_id(fingerprint)
 423         if not Scanner.Section.has_key("source"):
 424             source = package
 425         else:
 426             source = Scanner.Section["source"]
 427         source_version = ""
 428         if source.find("(") != -1:
 429             m = dak.lib.utils.re_extract_src_version.match(source)
 430             source = m.group(1)
 431             source_version = m.group(2)
 432         if not source_version:
 433             source_version = version
 434         filename = Scanner.Section["filename"]
 435         location = get_location_path(filename.split('/')[0])
 436         location_id = dak.lib.database.get_location_id (location, component, archive)
 437         filename = poolify (filename, location)
 438         if architecture == "all":
 439             filename = re_arch_from_filename.sub("binary-all", filename)
 440         cache_key = "%s~%s" % (source, source_version)
 441         source_id = source_cache_for_binaries.get(cache_key, None)
 442         size = Scanner.Section["size"]
 443         md5sum = Scanner.Section["md5sum"]
 444         files_id = get_or_set_files_id (filename, size, md5sum, location_id)
 445         type = "deb"; # FIXME
 446         cache_key = "%s~%s~%s~%d~%d~%d~%d" % (package, version, repr(source_id), architecture_id, location_id, files_id, suite_id)
 447         if not arch_all_cache.has_key(cache_key):
 448             arch_all_cache[cache_key] = 1
 449             cache_key = "%s~%s~%s~%d" % (package, version, repr(source_id), architecture_id)
 450             if not binary_cache.has_key(cache_key):
 451                 if not source_id:
 452                     source_id = "\N"
 453                     count_bad += 1
 454                 else:
 455                     source_id = repr(source_id)
 456                 binaries_id_serial += 1
 457                 binaries_query_cache.write("%d\t%s\t%s\t%d\t%s\t%d\t%d\t%s\t%s\n" % (binaries_id_serial, package, version, maintainer_id, source_id, architecture_id, files_id, type, fingerprint_id))
 458                 binary_cache[cache_key] = binaries_id_serial
 459                 tmp_binaries_id = binaries_id_serial
 460             else:
 461                 tmp_binaries_id = binary_cache[cache_key]
 462
 463             bin_associations_id_serial += 1
 464             bin_associations_query_cache.write("%d\t%d\t%d\n" % (bin_associations_id_serial, suite_id, tmp_binaries_id))
 465             count_total += 1
 466
 467     file.close()
 468     if count_bad != 0:
 469         print "%d binary packages processed; %d with no source match which is %.2f%%" % (count_total, count_bad, (float(count_bad)/count_total)*100)
 470     else:
 471         print "%d binary packages processed; 0 with no source match which is 0%%" % (count_total)
 472
 473 ###############################################################################
 474
 475 def do_sources(sources, suite, component, server):
 476     temp_filename = dak.lib.utils.temp_filename()
 477     (result, output) = commands.getstatusoutput("gunzip -c %s > %s" % (sources, temp_filename))
 478     if (result != 0):
 479         dak.lib.utils.fubar("Gunzip invocation failed!\n%s" % (output), result)
 480     print 'Processing '+sources+'...'
 481     process_sources (temp_filename, suite, component, server)
 482     os.unlink(temp_filename)
 483
 484 ###############################################################################
 485
 486 def do_da_do_da ():
 487     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
 488
 489     Cnf = dak.lib.utils.get_conf()
 490     Arguments = [('a', "action", "Import-Archive::Options::Action"),
 491                  ('h', "help", "Import-Archive::Options::Help")]
 492     for i in [ "action", "help" ]:
 493         if not Cnf.has_key("Import-Archive::Options::%s" % (i)):
 494             Cnf["Import-Archive::Options::%s" % (i)] = ""
 495
 496     apt_pkg.ParseCommandLine(Cnf, Arguments, sys.argv)
 497
 498     Options = Cnf.SubTree("Import-Archive::Options")
 499     if Options["Help"]:
 500         usage()
 501
 502     if not Options["Action"]:
 503         dak.lib.utils.warn("""no -a/--action given; not doing anything.
 504 Please read the documentation before running this script.
 505 """)
 506         usage(1)
 507
 508     print "Re-Creating DB..."
 509     (result, output) = commands.getstatusoutput("psql -f init_pool.sql template1")
 510     if (result != 0):
 511         dak.lib.utils.fubar("psql invocation failed!\n", result)
 512     print output
 513
 514     projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
 515
 516     dak.lib.database.init (Cnf, projectB)
 517
 518     print "Adding static tables from conf file..."
 519     projectB.query("BEGIN WORK")
 520     update_architectures()
 521     update_components()
 522     update_archives()
 523     update_locations()
 524     update_suites()
 525     update_override_type()
 526     update_priority()
 527     update_section()
 528     projectB.query("COMMIT WORK")
 529
 530     files_query_cache = dak.lib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"files","w")
 531     source_query_cache = dak.lib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"source","w")
 532     src_associations_query_cache = dak.lib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"src_associations","w")
 533     dsc_files_query_cache = dak.lib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"dsc_files","w")
 534     binaries_query_cache = dak.lib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"binaries","w")
 535     bin_associations_query_cache = dak.lib.utils.open_file(Cnf["Import-Archive::ExportDir"]+"bin_associations","w")
 536
 537     projectB.query("BEGIN WORK")
 538     # Process Sources files to popoulate `source' and friends
 539     for location in Cnf.SubTree("Location").List():
 540         SubSec = Cnf.SubTree("Location::%s" % (location))
 541         server = SubSec["Archive"]
 542         type = Cnf.Find("Location::%s::Type" % (location))
 543         if type == "legacy-mixed":
 544             sources = location + 'Sources.gz'
 545             suite = Cnf.Find("Location::%s::Suite" % (location))
 546             do_sources(sources, suite, "",  server)
 547         elif type == "legacy" or type == "pool":
 548             for suite in Cnf.ValueList("Location::%s::Suites" % (location)):
 549                 for component in Cnf.SubTree("Component").List():
 550                     sources = Cnf["Dir::Root"] + "dists/" + Cnf["Suite::%s::CodeName" % (suite)] + '/' + component + '/source/' + 'Sources.gz'
 551                     do_sources(sources, suite, component, server)
 552         else:
 553             dak.lib.utils.fubar("Unknown location type ('%s')." % (type))
 554
 555     # Process Packages files to populate `binaries' and friends
 556
 557     for location in Cnf.SubTree("Location").List():
 558         SubSec = Cnf.SubTree("Location::%s" % (location))
 559         server = SubSec["Archive"]
 560         type = Cnf.Find("Location::%s::Type" % (location))
 561         if type == "legacy-mixed":
 562             packages = location + 'Packages'
 563             suite = Cnf.Find("Location::%s::Suite" % (location))
 564             print 'Processing '+location+'...'
 565             process_packages (packages, suite, "", server)
 566         elif type == "legacy" or type == "pool":
 567             for suite in Cnf.ValueList("Location::%s::Suites" % (location)):
 568                 for component in Cnf.SubTree("Component").List():
 569                     architectures = filter(dak.lib.utils.real_arch,
 570                                            Cnf.ValueList("Suite::%s::Architectures" % (suite)))
 571                     for architecture in architectures:
 572                         packages = Cnf["Dir::Root"] + "dists/" + Cnf["Suite::%s::CodeName" % (suite)] + '/' + component + '/binary-' + architecture + '/Packages'
 573                         print 'Processing '+packages+'...'
 574                         process_packages (packages, suite, component, server)
 575
 576     files_query_cache.close()
 577     source_query_cache.close()
 578     src_associations_query_cache.close()
 579     dsc_files_query_cache.close()
 580     binaries_query_cache.close()
 581     bin_associations_query_cache.close()
 582     print "Writing data to `files' table..."
 583     projectB.query("COPY files FROM '%s'" % (Cnf["Import-Archive::ExportDir"]+"files"))
 584     print "Writing data to `source' table..."
 585     projectB.query("COPY source FROM '%s'" % (Cnf["Import-Archive::ExportDir"]+"source"))
 586     print "Writing data to `src_associations' table..."
 587     projectB.query("COPY src_associations FROM '%s'" % (Cnf["Import-Archive::ExportDir"]+"src_associations"))
 588     print "Writing data to `dsc_files' table..."
 589     projectB.query("COPY dsc_files FROM '%s'" % (Cnf["Import-Archive::ExportDir"]+"dsc_files"))
 590     print "Writing data to `binaries' table..."
 591     projectB.query("COPY binaries FROM '%s'" % (Cnf["Import-Archive::ExportDir"]+"binaries"))
 592     print "Writing data to `bin_associations' table..."
 593     projectB.query("COPY bin_associations FROM '%s'" % (Cnf["Import-Archive::ExportDir"]+"bin_associations"))
 594     print "Committing..."
 595     projectB.query("COMMIT WORK")
 596
 597     # Add the constraints and otherwise generally clean up the database.
 598     # See add_constraints.sql for more details...
 599
 600     print "Running add_constraints.sql..."
 601     (result, output) = commands.getstatusoutput("psql %s < add_constraints.sql" % (Cnf["DB::Name"]))
 602     print output
 603     if (result != 0):
 604         dak.lib.utils.fubar("psql invocation failed!\n%s" % (output), result)
 605
 606     return
 607
 608 ################################################################################
 609
 610 def main():
 611     dak.lib.utils.try_with_debug(do_da_do_da)
 612
 613 ################################################################################
 614
 615 if __name__ == '__main__':
 616     main()