]> git.decadent.org.uk Git - dak.git/blob - dak/process_accepted.py
Merge commit 'lamby/master' into merge
[dak.git] / dak / process_accepted.py
1 #!/usr/bin/env python
2
3 """
4 Installs Debian packages from queue/accepted into the pool
5
6 @contact: Debian FTP Master <ftpmaster@debian.org>
7 @copyright: 2000, 2001, 2002, 2003, 2004, 2006  James Troup <james@nocrew.org>
8 @copyright: 2009  Joerg Jaspert <joerg@debian.org>
9 @license: GNU General Public License version 2 or later
10
11 """
12 # This program is free software; you can redistribute it and/or modify
13 # it under the terms of the GNU General Public License as published by
14 # the Free Software Foundation; either version 2 of the License, or
15 # (at your option) any later version.
16
17 # This program is distributed in the hope that it will be useful,
18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 # GNU General Public License for more details.
21
22 # You should have received a copy of the GNU General Public License
23 # along with this program; if not, write to the Free Software
24 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25
26 ###############################################################################
27
28 #    Cartman: "I'm trying to make the best of a bad situation, I don't
29 #              need to hear crap from a bunch of hippy freaks living in
30 #              denial.  Screw you guys, I'm going home."
31 #
32 #    Kyle: "But Cartman, we're trying to..."
33 #
34 #    Cartman: "uhh.. screw you guys... home."
35
36 ###############################################################################
37
38 import errno
39 import fcntl
40 import os
41 import sys
42 from datetime import datetime
43 import apt_pkg
44
45 from daklib import daklog
46 from daklib.queue import *
47 from daklib import utils
48 from daklib.dbconn import *
49 from daklib.dak_exceptions import *
50 from daklib.regexes import re_default_answer, re_issource, re_fdnic
51 from daklib.urgencylog import UrgencyLog
52 from daklib.summarystats import SummaryStats
53 from daklib.config import Config
54
55 ###############################################################################
56
57 Options = None
58 Logger = None
59
60 ###############################################################################
61
62 def init():
63     global Options
64
65     # Initialize config and connection to db
66     cnf = Config()
67     DBConn()
68
69     Arguments = [('a',"automatic","Dinstall::Options::Automatic"),
70                  ('h',"help","Dinstall::Options::Help"),
71                  ('n',"no-action","Dinstall::Options::No-Action"),
72                  ('p',"no-lock", "Dinstall::Options::No-Lock"),
73                  ('s',"no-mail", "Dinstall::Options::No-Mail"),
74                  ('d',"directory", "Dinstall::Options::Directory", "HasArg")]
75
76     for i in ["automatic", "help", "no-action", "no-lock", "no-mail",
77               "version", "directory"]:
78         if not cnf.has_key("Dinstall::Options::%s" % (i)):
79             cnf["Dinstall::Options::%s" % (i)] = ""
80
81     changes_files = apt_pkg.ParseCommandLine(cnf.Cnf, Arguments, sys.argv)
82     Options = cnf.SubTree("Dinstall::Options")
83
84     if Options["Help"]:
85         usage()
86
87     # If we have a directory flag, use it to find our files
88     if cnf["Dinstall::Options::Directory"] != "":
89         # Note that we clobber the list of files we were given in this case
90         # so warn if the user has done both
91         if len(changes_files) > 0:
92             utils.warn("Directory provided so ignoring files given on command line")
93
94         changes_files = utils.get_changes_files(cnf["Dinstall::Options::Directory"])
95
96     return changes_files
97
98 ###############################################################################
99
100 def usage (exit_code=0):
101     print """Usage: dak process-accepted [OPTION]... [CHANGES]...
102   -a, --automatic           automatic run
103   -h, --help                show this help and exit.
104   -n, --no-action           don't do anything
105   -p, --no-lock             don't check lockfile !! for cron.daily only !!
106   -s, --no-mail             don't send any mail
107   -V, --version             display the version number and exit"""
108     sys.exit(exit_code)
109
110 ###############################################################################
111
112 def action (u, stable_queue=None, log_urgency=True, session=None):
113     (summary, short_summary) = u.build_summaries()
114     pi = u.package_info()
115
116     (prompt, answer) = ("", "XXX")
117     if Options["No-Action"] or Options["Automatic"]:
118         answer = 'S'
119
120     if len(u.rejects) > 0:
121         print "REJECT\n" + pi
122         prompt = "[R]eject, Skip, Quit ?"
123         if Options["Automatic"]:
124             answer = 'R'
125     else:
126         print "INSTALL to " + ", ".join(u.pkg.changes["distribution"].keys())
127         print pi + summary,
128         prompt = "[I]nstall, Skip, Quit ?"
129         if Options["Automatic"]:
130             answer = 'I'
131
132     while prompt.find(answer) == -1:
133         answer = utils.our_raw_input(prompt)
134         m = re_default_answer.match(prompt)
135         if answer == "":
136             answer = m.group(1)
137         answer = answer[:1].upper()
138
139     if answer == 'R':
140         u.do_unaccept()
141         Logger.log(["unaccepted", u.pkg.changes_file])
142     elif answer == 'I':
143         if stable_queue:
144             stable_install(u, summary, short_summary, stable_queue, log_urgency)
145         else:
146             install(u, session, log_urgency)
147     elif answer == 'Q':
148         sys.exit(0)
149
150
151 ###############################################################################
152 def add_poolfile(filename, datadict, location_id, session):
153     poolfile = PoolFile()
154     poolfile.filename = filename
155     poolfile.filesize = datadict["size"]
156     poolfile.md5sum = datadict["md5sum"]
157     poolfile.sha1sum = datadict["sha1sum"]
158     poolfile.sha256sum = datadict["sha256sum"]
159     poolfile.location_id = location_id
160
161     session.add(poolfile)
162     # Flush to get a file id (NB: This is not a commit)
163     session.flush()
164
165     return poolfile
166
167 def add_dsc_to_db(u, filename, session):
168     entry = u.pkg.files[filename]
169     source = DBSource()
170
171     source.source = u.pkg.dsc["source"]
172     source.version = u.pkg.dsc["version"] # NB: not files[file]["version"], that has no epoch
173     source.maintainer_id = get_or_set_maintainer(u.pkg.dsc["maintainer"], session).maintainer_id
174     source.changedby_id = get_or_set_maintainer(u.pkg.changes["changed-by"], session).maintainer_id
175     source.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
176     source.install_date = datetime.now().date()
177
178     dsc_component = entry["component"]
179     dsc_location_id = entry["location id"]
180
181     source.dm_upload_allowed = (u.pkg.dsc.get("dm-upload-allowed", '') == "yes")
182
183     # Set up a new poolfile if necessary
184     if not entry.has_key("files id") or not entry["files id"]:
185         filename = entry["pool name"] + filename
186         poolfile = add_poolfile(filename, entry, dsc_location_id, session)
187         entry["files id"] = poolfile.file_id
188
189     source.poolfile_id = entry["files id"]
190     session.add(source)
191     session.flush()
192
193     for suite_name in u.pkg.changes["distribution"].keys():
194         sa = SrcAssociation()
195         sa.source_id = source.source_id
196         sa.suite_id = get_suite(suite_name).suite_id
197         session.add(sa)
198
199     session.flush()
200
201     # Add the source files to the DB (files and dsc_files)
202     dscfile = DSCFile()
203     dscfile.source_id = source.source_id
204     dscfile.poolfile_id = entry["files id"]
205     session.add(dscfile)
206
207     for dsc_file, dentry in u.pkg.dsc_files.items():
208         df = DSCFile()
209         df.source_id = source.source_id
210
211         # If the .orig tarball is already in the pool, it's
212         # files id is stored in dsc_files by check_dsc().
213         files_id = dentry.get("files id", None)
214
215         # Find the entry in the files hash
216         # TODO: Bail out here properly
217         dfentry = None
218         for f, e in u.pkg.files.items():
219             if f == dsc_file:
220                 dfentry = e
221                 break
222
223         if files_id is None:
224             filename = dfentry["pool name"] + dsc_file
225
226             (found, obj) = check_poolfile(filename, dentry["size"], dentry["md5sum"], dsc_location_id)
227             # FIXME: needs to check for -1/-2 and or handle exception
228             if found and obj is not None:
229                 files_id = obj.file_id
230
231             # If still not found, add it
232             if files_id is None:
233                 # HACK: Force sha1sum etc into dentry
234                 dentry["sha1sum"] = dfentry["sha1sum"]
235                 dentry["sha256sum"] = dfentry["sha256sum"]
236                 poolfile = add_poolfile(filename, dentry, dsc_location_id, session)
237                 files_id = poolfile.file_id
238
239         df.poolfile_id = files_id
240         session.add(df)
241
242     session.flush()
243
244     # Add the src_uploaders to the DB
245     uploader_ids = [source.maintainer_id]
246     if u.pkg.dsc.has_key("uploaders"):
247         for up in u.pkg.dsc["uploaders"].split(","):
248             up = up.strip()
249             uploader_ids.append(get_or_set_maintainer(up, session).maintainer_id)
250
251     added_ids = {}
252     for up in uploader_ids:
253         if added_ids.has_key(up):
254             utils.warn("Already saw uploader %s for source %s" % (up, source.source))
255             continue
256
257         added_ids[u]=1
258
259         su = SrcUploader()
260         su.maintainer_id = up
261         su.source_id = source.source_id
262         session.add(su)
263
264     session.flush()
265
266     return dsc_component, dsc_location_id
267
268 def add_deb_to_db(u, filename, session):
269     """
270     Contrary to what you might expect, this routine deals with both
271     debs and udebs.  That info is in 'dbtype', whilst 'type' is
272     'deb' for both of them
273     """
274     cnf = Config()
275     entry = u.pkg.files[filename]
276
277     bin = DBBinary()
278     bin.package = entry["package"]
279     bin.version = entry["version"]
280     bin.maintainer_id = get_or_set_maintainer(entry["maintainer"], session).maintainer_id
281     bin.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
282     bin.arch_id = get_architecture(entry["architecture"], session).arch_id
283     bin.binarytype = entry["dbtype"]
284
285     # Find poolfile id
286     filename = entry["pool name"] + filename
287     fullpath = os.path.join(cnf["Dir::Pool"], filename)
288     if not entry.get("location id", None):
289         entry["location id"] = get_location(cnf["Dir::Pool"], entry["component"], utils.where_am_i(), session).location_id
290
291     if not entry.get("files id", None):
292         poolfile = add_poolfile(filename, entry, entry["location id"], session)
293         entry["files id"] = poolfile.file_id
294
295     bin.poolfile_id = entry["files id"]
296
297     # Find source id
298     bin_sources = get_sources_from_name(entry["source package"], entry["source version"], session=session)
299     if len(bin_sources) != 1:
300         raise NoSourceFieldError, "Unable to find a unique source id for %s (%s), %s, file %s, type %s, signed by %s" % \
301                                   (bin.package, bin.version, bin.architecture.arch_string,
302                                    filename, bin.binarytype, u.pkg.changes["fingerprint"])
303
304     bin.source_id = bin_sources[0].source_id
305
306     # Add and flush object so it has an ID
307     session.add(bin)
308     session.flush()
309
310     # Add BinAssociations
311     for suite_name in u.pkg.changes["distribution"].keys():
312         ba = BinAssociation()
313         ba.binary_id = bin.binary_id
314         ba.suite_id = get_suite(suite_name).suite_id
315         session.add(ba)
316
317     session.flush()
318
319     # Deal with contents - disabled for now
320     #contents = copy_temporary_contents(bin.package, bin.version, bin.architecture.arch_string, os.path.basename(filename), None, session)
321     #if not contents:
322     #    print "REJECT\nCould not determine contents of package %s" % bin.package
323     #    session.rollback()
324     #    raise MissingContents, "No contents stored for package %s, and couldn't determine contents of %s" % (bin.package, filename)
325
326
327 def install(u, session, log_urgency=True):
328     cnf = Config()
329     summarystats = SummaryStats()
330
331     print "Installing."
332
333     Logger.log(["installing changes", u.pkg.changes_file])
334
335     # Ensure that we have all the hashes we need below.
336     u.ensure_hashes()
337     if len(u.rejects) > 0:
338         # There were errors.  Print them and SKIP the changes.
339         for msg in u.rejects:
340             utils.warn(msg)
341         return
342
343     # Add the .dsc file to the DB first
344     for newfile, entry in u.pkg.files.items():
345         if entry["type"] == "dsc":
346             dsc_component, dsc_location_id = add_dsc_to_db(u, newfile, session)
347
348     # Add .deb / .udeb files to the DB (type is always deb, dbtype is udeb/deb)
349     for newfile, entry in u.pkg.files.items():
350         if entry["type"] == "deb":
351             add_deb_to_db(u, newfile, session)
352
353     # If this is a sourceful diff only upload that is moving
354     # cross-component we need to copy the .orig files into the new
355     # component too for the same reasons as above.
356     if u.pkg.changes["architecture"].has_key("source"):
357         for orig_file in u.pkg.orig_files.keys():
358             if not u.pkg.orig_files[orig_file].has_key("id"):
359                 continue # Skip if it's not in the pool
360             orig_file_id = u.pkg.orig_files[orig_file]["id"]
361             if u.pkg.orig_files[orig_file]["location"] == dsc_location_id:
362                 continue # Skip if the location didn't change
363
364             # Do the move
365             oldf = get_poolfile_by_id(orig_file_id, session)
366             old_filename = os.path.join(oldf.location.path, oldf.filename)
367             old_dat = {'size': oldf.filesize,   'md5sum': oldf.md5sum,
368                        'sha1sum': oldf.sha1sum, 'sha256sum': oldf.sha256sum}
369
370             new_filename = os.path.join(utils.poolify(u.pkg.changes["source"], dsc_component), os.path.basename(old_filename))
371
372             # TODO: Care about size/md5sum collisions etc
373             (found, newf) = check_poolfile(new_filename, file_size, file_md5sum, dsc_location_id, session)
374
375             if newf is None:
376                 utils.copy(old_filename, os.path.join(cnf["Dir::Pool"], new_filename))
377                 newf = add_poolfile(new_filename, old_dat, dsc_location_id, session)
378
379                 # TODO: Check that there's only 1 here
380                 source = get_sources_from_name(u.pkg.changes["source"], u.pkg.changes["version"])[0]
381                 dscf = get_dscfiles(source_id=source.source_id, poolfile_id=orig_file_id, session=session)[0]
382                 dscf.poolfile_id = newf.file_id
383                 session.add(dscf)
384                 session.flush()
385
386     # Install the files into the pool
387     for newfile, entry in u.pkg.files.items():
388         destination = os.path.join(cnf["Dir::Pool"], entry["pool name"], newfile)
389         utils.move(newfile, destination)
390         Logger.log(["installed", newfile, entry["type"], entry["size"], entry["architecture"]])
391         summarystats.accept_bytes += float(entry["size"])
392
393     # Copy the .changes file across for suite which need it.
394     copy_changes = {}
395     copy_dot_dak = {}
396     for suite_name in u.pkg.changes["distribution"].keys():
397         if cnf.has_key("Suite::%s::CopyChanges" % (suite_name)):
398             copy_changes[cnf["Suite::%s::CopyChanges" % (suite_name)]] = ""
399         # and the .dak file...
400         if cnf.has_key("Suite::%s::CopyDotDak" % (suite_name)):
401             copy_dot_dak[cnf["Suite::%s::CopyDotDak" % (suite_name)]] = ""
402
403     for dest in copy_changes.keys():
404         utils.copy(u.pkg.changes_file, os.path.join(cnf["Dir::Root"], dest))
405
406     for dest in copy_dot_dak.keys():
407         utils.copy(u.pkg.changes_file[:-8]+".dak", dest)
408
409     # We're done - commit the database changes
410     session.commit()
411
412     # Move the .changes into the 'done' directory
413     utils.move(u.pkg.changes_file,
414                os.path.join(cnf["Dir::Queue::Done"], os.path.basename(u.pkg.changes_file)))
415
416     # Remove the .dak file
417     os.unlink(u.pkg.changes_file[:-8] + ".dak")
418
419     if u.pkg.changes["architecture"].has_key("source") and log_urgency:
420         UrgencyLog().log(u.pkg.dsc["source"], u.pkg.dsc["version"], u.pkg.changes["urgency"])
421
422     # Our SQL session will automatically start a new transaction after
423     # the last commit
424
425     # Undo the work done in queue.py(accept) to help auto-building
426     # from accepted.
427     now_date = datetime.now()
428
429     for suite_name in u.pkg.changes["distribution"].keys():
430         if suite_name not in cnf.ValueList("Dinstall::QueueBuildSuites"):
431             continue
432
433         suite = get_suite(suite_name, session)
434         dest_dir = cnf["Dir::QueueBuild"]
435
436         if cnf.FindB("Dinstall::SecurityQueueBuild"):
437             dest_dir = os.path.join(dest_dir, suite_name)
438
439         for newfile, entry in u.pkg.files.items():
440             dest = os.path.join(dest_dir, newfile)
441
442             qb = get_queue_build(dest, suite.suite_id, session)
443
444             # Remove it from the list of packages for later processing by apt-ftparchive
445             if qb:
446                 qb.last_used = now_date
447                 qb.in_queue = False
448                 session.add(qb)
449
450             if not cnf.FindB("Dinstall::SecurityQueueBuild"):
451                 # Update the symlink to point to the new location in the pool
452                 pool_location = utils.poolify(u.pkg.changes["source"], entry["component"])
453                 src = os.path.join(cnf["Dir::Pool"], pool_location, os.path.basename(newfile))
454                 if os.path.islink(dest):
455                     os.unlink(dest)
456                 os.symlink(src, dest)
457
458         # Update last_used on any non-uploaded .orig symlink
459         for orig_file in u.pkg.orig_files.keys():
460             # Determine the .orig.tar.gz file name
461             if not u.pkg.orig_files[orig_file].has_key("id"):
462                 continue # Skip files not in the pool
463             # XXX: do we really want to update the orig_files dict here
464             # instead of using a temporary variable?
465             u.pkg.orig_files[orig_file]["path"] = os.path.join(dest_dir, orig_file)
466
467             # Remove it from the list of packages for later processing by apt-ftparchive
468             qb = get_queue_build(u.pkg.orig_files[orig_file]["path"], suite.suite_id, session)
469             if qb:
470                 qb.in_queue = False
471                 qb.last_used = now_date
472                 session.add(qb)
473
474     session.commit()
475
476     # Finally...
477     summarystats.accept_count += 1
478
479 ################################################################################
480
481 def stable_install(u, session, summary, short_summary, fromsuite_name="proposed-updates"):
482     summarystats = SummaryStats()
483
484     fromsuite_name = fromsuite_name.lower()
485     tosuite_name = "Stable"
486     if fromsuite_name == "oldstable-proposed-updates":
487         tosuite_name = "OldStable"
488
489     print "Installing from %s to %s." % (fromsuite_name, tosuite_name)
490
491     fromsuite = get_suite(fromsuite_name)
492     tosuite = get_suite(tosuite_name)
493
494     # Add the source to stable (and remove it from proposed-updates)
495     for newfile, entry in u.pkg.files.items():
496         if entry["type"] == "dsc":
497             package = u.pkg.dsc["source"]
498             # NB: not files[file]["version"], that has no epoch
499             version = u.pkg.dsc["version"]
500
501             source = get_sources_from_name(package, version, session)
502             if len(source) < 1:
503                 utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s) in source table." % (package, version))
504             source = source[0]
505
506             # Remove from old suite
507             old = session.query(SrcAssociation).filter_by(source_id = source.source_id)
508             old = old.filter_by(suite_id = fromsuite.suite_id)
509             old.delete()
510
511             # Add to new suite
512             new = SrcAssociation()
513             new.source_id = source.source_id
514             new.suite_id = tosuite.suite_id
515             session.add(new)
516
517     # Add the binaries to stable (and remove it/them from proposed-updates)
518     for newfile, entry in u.pkg.files.items():
519         if entry["type"] == "deb":
520             package = entry["package"]
521             version = entry["version"]
522             architecture = entry["architecture"]
523
524             binary = get_binaries_from_name(package, version, [architecture, 'all'])
525
526             if len(binary) < 1:
527                 utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s for %s architecture) in binaries table." % (package, version, architecture))
528             binary = binary[0]
529
530             # Remove from old suite
531             old = session.query(BinAssociation).filter_by(binary_id = binary.binary_id)
532             old = old.filter_by(suite_id = fromsuite.suite_id)
533             old.delete()
534
535             # Add to new suite
536             new = BinAssociation()
537             new.binary_id = binary.binary_id
538             new.suite_id = tosuite.suite_id
539             session.add(new)
540
541     session.commit()
542
543     utils.move(u.pkg.changes_file,
544                os.path.join(cnf["Dir::Morgue"], 'process-accepted', os.path.basename(u.pkg.changes_file)))
545
546     ## Update the Stable ChangeLog file
547     # TODO: URGH - Use a proper tmp file
548     new_changelog_filename = cnf["Dir::Root"] + cnf["Suite::%s::ChangeLogBase" % (tosuite.suite_name)] + ".ChangeLog"
549     changelog_filename = cnf["Dir::Root"] + cnf["Suite::%s::ChangeLogBase" % (tosuite.suite_name)] + "ChangeLog"
550     if os.path.exists(new_changelog_filename):
551         os.unlink(new_changelog_filename)
552
553     new_changelog = utils.open_file(new_changelog_filename, 'w')
554     for newfile, entry in u.pkg.files.items():
555         if entry["type"] == "deb":
556             new_changelog.write("%s/%s/binary-%s/%s\n" % (tosuite.suite_name,
557                                                           entry["component"],
558                                                           entry["architecture"],
559                                                           newfile))
560         elif re_issource.match(newfile):
561             new_changelog.write("%s/%s/source/%s\n" % (tosuite.suite_name,
562                                                        entry["component"],
563                                                        newfile))
564         else:
565             new_changelog.write("%s\n" % (newfile))
566
567     chop_changes = re_fdnic.sub("\n", u.pkg.changes["changes"])
568     new_changelog.write(chop_changes + '\n\n')
569
570     if os.access(changelog_filename, os.R_OK) != 0:
571         changelog = utils.open_file(changelog_filename)
572         new_changelog.write(changelog.read())
573
574     new_changelog.close()
575
576     if os.access(changelog_filename, os.R_OK) != 0:
577         os.unlink(changelog_filename)
578     utils.move(new_changelog_filename, changelog_filename)
579
580     summarystats.accept_count += 1
581
582     if not Options["No-Mail"] and u.pkg.changes["architecture"].has_key("source"):
583         u.Subst["__SUITE__"] = " into %s" % (tosuite)
584         u.Subst["__SUMMARY__"] = summary
585         u.Subst["__BCC__"] = "X-DAK: dak process-accepted"
586
587         if cnf.has_key("Dinstall::Bcc"):
588             u.Subst["__BCC__"] += "\nBcc: %s" % (cnf["Dinstall::Bcc"])
589
590         template = os.path.join(cnf["Dir::Templates"], 'process-accepted.install')
591
592         mail_message = utils.TemplateSubst(u.Subst, template)
593         utils.send_mail(mail_message)
594         u.announce(short_summary, True)
595
596     # Finally remove the .dak file
597     dot_dak_file = os.path.join(cnf["Suite::%s::CopyDotDak" % (fromsuite.suite_name)],
598                                 os.path.basename(u.pkg.changes_file[:-8]+".dak"))
599     os.unlink(dot_dak_file)
600
601 ################################################################################
602
603 def process_it(changes_file, stable_queue, log_urgency, session):
604     cnf = Config()
605     u = Upload()
606
607     overwrite_checks = True
608
609     # Absolutize the filename to avoid the requirement of being in the
610     # same directory as the .changes file.
611     cfile = os.path.abspath(changes_file)
612
613     # And since handling of installs to stable munges with the CWD
614     # save and restore it.
615     u.prevdir = os.getcwd()
616
617     if stable_queue:
618         old = cfile
619         cfile = os.path.basename(old)
620         os.chdir(cnf["Suite::%s::CopyDotDak" % (stable_queue)])
621         # overwrite_checks should not be performed if installing to stable
622         overwrite_checks = False
623
624     u.pkg.load_dot_dak(cfile)
625     u.update_subst()
626
627     if stable_queue:
628         u.pkg.changes_file = old
629
630     u.accepted_checks(overwrite_checks, session)
631     action(u, stable_queue, log_urgency, session)
632
633     # Restore CWD
634     os.chdir(u.prevdir)
635
636 ###############################################################################
637
638 def main():
639     global Logger
640
641     cnf = Config()
642     summarystats = SummaryStats()
643     changes_files = init()
644     log_urgency = False
645     stable_queue = None
646
647     # -n/--dry-run invalidates some other options which would involve things happening
648     if Options["No-Action"]:
649         Options["Automatic"] = ""
650
651     # Check that we aren't going to clash with the daily cron job
652
653     if not Options["No-Action"] and os.path.exists("%s/Archive_Maintenance_In_Progress" % (cnf["Dir::Root"])) and not Options["No-Lock"]:
654         utils.fubar("Archive maintenance in progress.  Try again later.")
655
656     # If running from within proposed-updates; assume an install to stable
657     queue = ""
658     if os.getenv('PWD').find('oldstable-proposed-updates') != -1:
659         stable_queue = "Oldstable-Proposed-Updates"
660     elif os.getenv('PWD').find('proposed-updates') != -1:
661         stable_queue = "Proposed-Updates"
662
663     # Obtain lock if not in no-action mode and initialize the log
664     if not Options["No-Action"]:
665         lock_fd = os.open(cnf["Dinstall::LockFile"], os.O_RDWR | os.O_CREAT)
666         try:
667             fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
668         except IOError, e:
669             if errno.errorcode[e.errno] == 'EACCES' or errno.errorcode[e.errno] == 'EAGAIN':
670                 utils.fubar("Couldn't obtain lock; assuming another 'dak process-accepted' is already running.")
671             else:
672                 raise
673         Logger = daklog.Logger(cnf, "process-accepted")
674         if not stable_queue and cnf.get("Dir::UrgencyLog"):
675             # Initialise UrgencyLog()
676             log_urgency = True
677             UrgencyLog()
678
679     # Sort the .changes files so that we process sourceful ones first
680     changes_files.sort(utils.changes_compare)
681
682
683     # Process the changes files
684     for changes_file in changes_files:
685         print "\n" + changes_file
686         session = DBConn().session()
687         process_it(changes_file, stable_queue, log_urgency, session)
688         session.close()
689
690     if summarystats.accept_count:
691         sets = "set"
692         if summarystats.accept_count > 1:
693             sets = "sets"
694         sys.stderr.write("Installed %d package %s, %s.\n" % (summarystats.accept_count, sets,
695                                                              utils.size_type(int(summarystats.accept_bytes))))
696         Logger.log(["total", summarystats.accept_count, summarystats.accept_bytes])
697
698     if not Options["No-Action"]:
699         Logger.close()
700         if log_urgency:
701             UrgencyLog().close()
702
703 ###############################################################################
704
705 if __name__ == '__main__':
706     main()