X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;f=daklib%2Fqueue.py;h=3169e7a2122e1cdfbb846d77a200b5b0cbb58108;hb=b21637628cd8a4b4ac060efc6396ff966ddfe8a8;hp=d77f5f357796c000998bb47a63601586c331bbe3;hpb=dca650055f023509bf797c760c11e01f03d894bb;p=dak.git diff --git a/daklib/queue.py b/daklib/queue.py old mode 100644 new mode 100755 index d77f5f35..3169e7a2 --- a/daklib/queue.py +++ b/daklib/queue.py @@ -32,6 +32,175 @@ re_default_answer = re.compile(r"\[(.*)\]") re_fdnic = re.compile(r"\n\n") re_bin_only_nmu = re.compile(r"\+b\d+$") +################################################################################ + +# Determine what parts in a .changes are NEW + +def determine_new(changes, files, projectB, warn=1): + new = {} + + # Build up a list of potentially new things + for file in files.keys(): + f = files[file] + # Skip byhand elements + if f["type"] == "byhand": + continue + pkg = f["package"] + priority = f["priority"] + section = f["section"] + type = get_type(f) + component = f["component"] + + if type == "dsc": + priority = "source" + if not new.has_key(pkg): + new[pkg] = {} + new[pkg]["priority"] = priority + new[pkg]["section"] = section + new[pkg]["type"] = type + new[pkg]["component"] = component + new[pkg]["files"] = [] + else: + old_type = new[pkg]["type"] + if old_type != type: + # source gets trumped by deb or udeb + if old_type == "dsc": + new[pkg]["priority"] = priority + new[pkg]["section"] = section + new[pkg]["type"] = type + new[pkg]["component"] = component + new[pkg]["files"].append(file) + if f.has_key("othercomponents"): + new[pkg]["othercomponents"] = f["othercomponents"] + + for suite in changes["suite"].keys(): + suite_id = database.get_suite_id(suite) + for pkg in new.keys(): + component_id = database.get_component_id(new[pkg]["component"]) + type_id = database.get_override_type_id(new[pkg]["type"]) + q = projectB.query("SELECT package FROM override WHERE package = '%s' AND suite = %s AND component = %s AND type = %s" % (pkg, suite_id, component_id, type_id)) + ql = q.getresult() + if ql: + for file in new[pkg]["files"]: + if files[file].has_key("new"): + del files[file]["new"] + del new[pkg] + + if warn: + if changes["suite"].has_key("stable"): + print "WARNING: overrides will be added for stable!" + if changes["suite"].has_key("oldstable"): + print "WARNING: overrides will be added for OLDstable!" + for pkg in new.keys(): + if new[pkg].has_key("othercomponents"): + print "WARNING: %s already present in %s distribution." % (pkg, new[pkg]["othercomponents"]) + + return new + +################################################################################ + +def get_type(f): + # Determine the type + if f.has_key("dbtype"): + type = f["dbtype"] + elif f["type"] in [ "orig.tar.gz", "orig.tar.bz2", "tar.gz", "tar.bz2", "diff.gz", "diff.bz2", "dsc" ]: + type = "dsc" + else: + fubar("invalid type (%s) for new. Dazed, confused and sure as heck not continuing." % (type)) + + # Validate the override type + type_id = database.get_override_type_id(type) + if type_id == -1: + fubar("invalid type (%s) for new. Say wha?" % (type)) + + return type + +################################################################################ + +# check if section/priority values are valid + +def check_valid(new): + for pkg in new.keys(): + section = new[pkg]["section"] + priority = new[pkg]["priority"] + type = new[pkg]["type"] + new[pkg]["section id"] = database.get_section_id(section) + new[pkg]["priority id"] = database.get_priority_id(new[pkg]["priority"]) + # Sanity checks + di = section.find("debian-installer") != -1 + if (di and type != "udeb") or (not di and type == "udeb"): + new[pkg]["section id"] = -1 + if (priority == "source" and type != "dsc") or \ + (priority != "source" and type == "dsc"): + new[pkg]["priority id"] = -1 + +################################################################################ + +# We reject packages if the release team defined a transition for them +def check_transition(sourcepkg, cleanup=0): + to_dump = 0 + + # Only check if there is a file defined (and existant) with checks. It's a little bit + # specific to Debian, not much use for others, so return early there. + if not Cnf.has_key("Dinstall::Reject::ReleaseTransitions") and + not os.path.exists("%s" % (Cnf["Dinstall::Reject::ReleaseTransitions"])): + return + + # Parse the yaml file + sourcefile = file(Cnf["Dinstall::Reject::ReleaseTransitions"], 'r') + try: + transitions = load(sourcefile) + except error, msg: + utils.warn("Not checking transitions, the transitions file is broken: %s." % (msg)) + return + + # Now look through all defined transitions + for trans in transition: + t = transition[trans] + # We check if the transition is still valid + # If not we remove the whole setting from the dictionary and later dump it, + # so we don't process it again. + source = t["source"] + new_vers = t["new"] + q = Upload.projectB.query(""" + SELECT s.version FROM source s, suite su, src_associations sa + WHERE sa.source=s.id + AND sa.suite=su.id + AND su.suite_name='testing' + AND s.source='%s'""" + % (source)) + ql = q.getresult() + if ql and apt_pkg.VersionCompare(new_vers, ql[0][0]) == 1: + # This is still valid, the current version in database is older than + # the new version we wait for + + # Check if the source we look at is affected by this. + if sourcepkg in t['packages']: + # The source is affected, lets reject it. + reject("""%s: part of the %s transition. + + Your package is part of a testing transition to get %s migrated. + + Transition description: %s + + This transition will finish when %s, version %s, reaches testing. + This transition is managed by the Release Team and %s + is the Release-Team member responsible for it. + Please contact them or debian-release@lists.debian.org if you + need further assistance. + """ + % (sourcepkg, trans, source, t["reason"], source, new_vers, t["rm"])) + return 0 + else: + # We either have the wanted or a newer version in testing, or the package got + # removed completly. In that case we don't need to keep the transition blocker + del transition[trans] + to_dump = 1 + + if cleanup and to_dump: + destfile = file(Cnf["Dinstall::Reject::ReleaseTransitions"], 'w') + dump(transition, destfile) + ############################################################################### # Convenience wrapper to carry around all the package information in @@ -471,9 +640,6 @@ distribution.""" section = files[file]["section"] override_section = files[file]["override section"] if section.lower() != override_section.lower() and section != "-": - # Ignore this; it's a common mistake and not worth whining about - if section.lower() == "non-us/main" and override_section.lower() == "non-us": - continue summary += "%s: package says section is %s, override says %s.\n" % (file, section, override_section) priority = files[file]["priority"] override_priority = files[file]["override priority"] @@ -673,10 +839,6 @@ distribution.""" component_id = database.get_component_id(component) type_id = database.get_override_type_id(type) - # FIXME: nasty non-US speficic hack - if component.lower().startswith("non-us/"): - component = component[7:] - q = self.projectB.query("SELECT s.section, p.priority FROM override o, section s, priority p WHERE package = '%s' AND suite = %s AND component = %s AND type = %s AND o.section = s.id AND o.priority = p.id" % (package, suite_id, component_id, type_id)) result = q.getresult() @@ -831,7 +993,7 @@ SELECT s.version, su.suite_name FROM source s, src_associations sa, suite su # the .orig.tar.gz is a duplicate of the one in the archive]; if # you're iterating over 'files' and call this function as part of # the loop, be sure to add a check to the top of the loop to - # ensure you haven't just tried to derefernece the deleted entry. + # ensure you haven't just tried to dereference the deleted entry. # **WARNING** def check_dsc_against_db(self, file):