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