X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;f=daklib%2Fchanges.py;h=3f305c9c0fe4cbc7f3082bd739e38400e0aebf6a;hb=b96fec590c5123bd91db1144ae813e2a133f3571;hp=150e7c5327a17b168dc2c9f65f3d4d8531ac0a38;hpb=126a1c72aa67a25d615e4417c15e8fa74419ca78;p=dak.git diff --git a/daklib/changes.py b/daklib/changes.py index 150e7c53..3f305c9c 100755 --- a/daklib/changes.py +++ b/daklib/changes.py @@ -29,6 +29,8 @@ Changes class for dak import os import stat + +import datetime from cPickle import Unpickler, Pickler from errno import EPERM @@ -36,6 +38,8 @@ from apt_inst import debExtractControl from apt_pkg import ParseSection from utils import open_file, fubar, poolify +from config import * +from dbconn import * ############################################################################### @@ -76,6 +80,10 @@ CHANGESFIELDS_DSCFILES_OPTIONAL = [ "files id" ] __all__.append('CHANGESFIELDS_DSCFILES_OPTIONAL') +CHANGESFIELDS_ORIGFILES = [ "id", "location" ] + +__all__.append('CHANGESFIELDS_ORIGFILES') + ############################################################################### class Changes(object): @@ -91,10 +99,7 @@ class Changes(object): self.dsc = {} self.files = {} self.dsc_files = {} - - self.orig_tar_id = None - self.orig_tar_location = "" - self.orig_tar_gz = None + self.orig_files = {} def file_summary(self): # changes["distribution"] may not exist in corner cases @@ -150,7 +155,6 @@ class Changes(object): or the text of a warning if there are """ - conf = Config() summary = "" # Abandon the check if it's a non-sourceful upload @@ -166,125 +170,156 @@ class Changes(object): entry["override section"]) if entry["priority"] != "-": - if entry["priority"] != entry["override_priority"]: + if entry["priority"] != entry["override priority"]: summary += "%s: package says priority is %s, override says %s.\n" % (name, entry["priority"], entry["override priority"]) return summary + @session_wrapper + def remove_known_changes(self, session=None): + session.delete(get_dbchange(self.changes_file, session)) - def load_dot_dak(self, changesfile): - """ - Update ourself by reading a previously created cPickle .dak dumpfile. - """ - - self.changes_file = changesfile - dump_filename = self.changes_file[:-8]+".dak" - dump_file = open_file(dump_filename) - - p = Unpickler(dump_file) + def mark_missing_fields(self): + """add "missing" in fields which we will require for the known_changes table""" + for key in ['urgency', 'maintainer', 'fingerprint', 'changed-by' ]: + if (not self.changes.has_key(key)) or (not self.changes[key]): + self.changes[key]='missing' - self.changes.update(p.load()) - self.dsc.update(p.load()) - self.files.update(p.load()) - self.dsc_files.update(p.load()) + @session_wrapper + def add_known_changes(self, dirpath, session=None): + """add "missing" in fields which we will require for the known_changes table""" + cnf = Config() - self.orig_tar_id = p.load() - self.orig_tar_location = p.load() + changesfile = os.path.join(dirpath, self.changes_file) + filetime = datetime.datetime.fromtimestamp(os.path.getctime(changesfile)) - dump_file.close() + self.mark_missing_fields() - def sanitised_files(self): - ret = {} + multivalues = {} + for key in ("distribution", "architecture", "binary"): + if isinstance(self.changes[key], dict): + multivalues[key] = " ".join(self.changes[key].keys()) + else: + multivalues[key] = self.changes[key].keys() + + session.execute( + """INSERT INTO changes + (changesname, seen, source, binaries, architecture, version, + distribution, urgency, maintainer, fingerprint, changedby, date) + VALUES (:changesfile,:filetime,:source,:binary, :architecture, + :version,:distribution,:urgency,:maintainer,:fingerprint,:changedby,:date)""", + { 'changesfile': self.changes_file, + 'filetime': filetime, + 'source': self.changes["source"], + 'binary': multivalues["binary"], + 'architecture': multivalues["architecture"], + 'version': self.changes["version"], + 'distribution': multivalues["distribution"], + 'urgency': self.changes["urgency"], + 'maintainer': self.changes["maintainer"], + 'fingerprint': self.changes["fingerprint"], + 'changedby': self.changes["changed-by"], + 'date': self.changes["date"]} ) + + def unknown_files_fields(self, name): + return sorted(list( set(self.files[name].keys()) - + set(CHANGESFIELDS_FILES))) + + def unknown_changes_fields(self): + return sorted(list( set(self.changes.keys()) - + set(CHANGESFIELDS_MANDATORY + CHANGESFIELDS_OPTIONAL))) + + def unknown_dsc_fields(self): + return sorted(list( set(self.dsc.keys()) - + set(CHANGESFIELDS_DSC))) + + def unknown_dsc_files_fields(self, name): + return sorted(list( set(self.dsc_files[name].keys()) - + set(CHANGESFIELDS_DSCFILES_MANDATORY + CHANGESFIELDS_DSCFILES_OPTIONAL))) + + def str_files(self): + r = [] for name, entry in self.files.items(): - ret[name] = {} + r.append(" %s:" % (name)) for i in CHANGESFIELDS_FILES: if entry.has_key(i): - ret[name][i] = entry[i] + r.append(" %s: %s" % (i.capitalize(), entry[i])) + xfields = self.unknown_files_fields(name) + if len(xfields) > 0: + r.append("files[%s] still has following unrecognised keys: %s" % (name, ", ".join(xfields))) - return ret + return r - def sanitised_changes(self): - ret = {} - # Mandatory changes fields + def str_changes(self): + r = [] for i in CHANGESFIELDS_MANDATORY: - ret[i] = self.changes[i] + val = self.changes[i] + if isinstance(val, list): + val = " ".join(val) + elif isinstance(val, dict): + val = " ".join(val.keys()) + r.append(' %s: %s' % (i.capitalize(), val)) - # Optional changes fields for i in CHANGESFIELDS_OPTIONAL: if self.changes.has_key(i): - ret[i] = self.changes[i] + r.append(' %s: %s' % (i.capitalize(), self.changes[i])) + + xfields = self.unknown_changes_fields() + if len(xfields) > 0: + r.append("Warning: changes still has the following unrecognised fields: %s" % ", ".join(xfields)) - return ret + return r - def sanitised_dsc(self): - ret = {} + def str_dsc(self): + r = [] for i in CHANGESFIELDS_DSC: if self.dsc.has_key(i): - ret[i] = self.dsc[i] + r.append(' %s: %s' % (i.capitalize(), self.dsc[i])) - return ret + xfields = self.unknown_dsc_fields() + if len(xfields) > 0: + r.append("Warning: dsc still has the following unrecognised fields: %s" % ", ".join(xfields)) - def sanitised_dsc_files(self): - ret = {} + return r + + def str_dsc_files(self): + r = [] for name, entry in self.dsc_files.items(): - ret[name] = {} - # Mandatory dsc_files fields + r.append(" %s:" % (name)) for i in CHANGESFIELDS_DSCFILES_MANDATORY: - ret[name][i] = entry[i] - - # Optional dsc_files fields + r.append(" %s: %s" % (i.capitalize(), entry[i])) for i in CHANGESFIELDS_DSCFILES_OPTIONAL: if entry.has_key(i): - ret[name][i] = entry[i] + r.append(" %s: %s" % (i.capitalize(), entry[i])) + xfields = self.unknown_dsc_files_fields(name) + if len(xfields) > 0: + r.append("dsc_files[%s] still has following unrecognised keys: %s" % (name, ", ".join(xfields))) - return ret + return r - def write_dot_dak(self, dest_dir): - """ - Dump ourself into a cPickle file. + def __str__(self): + r = [] - @type dest_dir: string - @param dest_dir: Path where the dumpfile should be stored + r.append(" Changes:") + r += self.str_changes() - @note: This could just dump the dictionaries as is, but I'd like to avoid this so - there's some idea of what process-accepted & process-new use from - process-unchecked. (JT) + r.append("") - """ + r.append(" Dsc:") + r += self.str_dsc() - dump_filename = os.path.join(dest_dir, self.changes_file[:-8] + ".dak") - dump_file = open_file(dump_filename, 'w') - - try: - os.chmod(dump_filename, 0664) - except OSError, e: - # chmod may fail when the dumpfile is not owned by the user - # invoking dak (like e.g. when NEW is processed by a member - # of ftpteam) - if e.errno == EPERM: - perms = stat.S_IMODE(os.stat(dump_filename)[stat.ST_MODE]) - # security precaution, should never happen unless a weird - # umask is set anywhere - if perms & stat.S_IWOTH: - fubar("%s is world writable and chmod failed." % \ - (dump_filename,)) - # ignore the failed chmod otherwise as the file should - # already have the right privileges and is just, at worst, - # unreadable for world - else: - raise + r.append("") + + r.append(" Files:") + r += self.str_files() - p = Pickler(dump_file, 1) + r.append("") - p.dump(self.sanitised_changes()) - p.dump(self.sanitised_dsc()) - p.dump(self.sanitised_files()) - p.dump(self.sanitised_dsc_files()) - p.dump(self.orig_tar_id) - p.dump(self.orig_tar_location) + r.append(" Dsc Files:") + r += self.str_dsc_files() - dump_file.close() + return "\n".join(r) __all__.append('Changes')