diff options
author | Tomáš Chvátal <scarabeus@gentoo.org> | 2009-10-03 14:43:03 +0200 |
---|---|---|
committer | Tomáš Chvátal <scarabeus@gentoo.org> | 2009-10-03 14:43:03 +0200 |
commit | e5ec1045380530d7173cbd2f1af4be9784262f7a (patch) | |
tree | fb1733e24bcbd9c7d3adf5394993139f4c3e6470 | |
parent | Fix crash happening when upstream releng version list has a nonsensical versi... (diff) | |
download | gentoo-bumpchecker-e5ec1045380530d7173cbd2f1af4be9784262f7a.tar.gz gentoo-bumpchecker-e5ec1045380530d7173cbd2f1af4be9784262f7a.tar.bz2 gentoo-bumpchecker-e5ec1045380530d7173cbd2f1af4be9784262f7a.zip |
X modular bumpchecker version 1.0
-rwxr-xr-x | gnome-bumpchecker.py (renamed from gentoo-bumpchecker.py) | 3 | ||||
-rw-r--r-- | modules/clioptions_module.py | 4 | ||||
-rw-r--r-- | modules/xmodular_module.py | 195 | ||||
-rw-r--r-- | modules/xmodular_output.py | 130 | ||||
-rwxr-xr-x | x-modular-bumpchecker.py | 48 |
5 files changed, 376 insertions, 4 deletions
diff --git a/gentoo-bumpchecker.py b/gnome-bumpchecker.py index 0486336..7069f93 100755 --- a/gentoo-bumpchecker.py +++ b/gnome-bumpchecker.py @@ -10,9 +10,10 @@ version = "0.0.2" sys.path = ["modules"]+sys.path if __name__ == '__main__': - import clioptions_module options = clioptions_module.Options() + if (options.options.release_number == None): + options.parser.error("No revision") # generate 2 lists. # 1st list is the packages needed for a release ( from GNOME FTP ) diff --git a/modules/clioptions_module.py b/modules/clioptions_module.py index 2f0b1a2..0020f7f 100644 --- a/modules/clioptions_module.py +++ b/modules/clioptions_module.py @@ -7,7 +7,7 @@ from optparse import OptionParser class Options: def __init__(self): - usage = "usage: %prog [-qkn] -o <filename> -r <release>" + usage = "usage: %prog [-qkn] -o <filename> -r <release_number>" self.parser = OptionParser(usage=usage) self.setup_parser() @@ -41,6 +41,4 @@ class Options: def get_arguments(self): if (self.options.output == None): self.parser.error("No output file") - if (self.options.release_number == None): - self.parser.error("No revision") return self.options diff --git a/modules/xmodular_module.py b/modules/xmodular_module.py new file mode 100644 index 0000000..98a3a5a --- /dev/null +++ b/modules/xmodular_module.py @@ -0,0 +1,195 @@ +# Copyright Tomas Chvatal <scarabeus@gentoo.org> +# LICENSE - GPL2 + +# X11 module +import urllib2, package_module, string, simple_cache_module +import clioptions_module +import ftp_module + +DEBUG=False +class X_modular: + def __init__(self): + options = clioptions_module.Options() + args = options.get_arguments() + self.ftpserver = "ftp.x.org" + self.release_directories = [ "pub/current/src/app/", "pub/current/src/data/", "pub/current/src/doc/", + "pub/current/src/driver/", "pub/current/src/font/", "pub/current/src/lib/", "pub/current/src/proto/", + "pub/current/src/util/", "pub/current/src/xserver/" ] + + self.latest_directories = [ "pub/individual/app/", "pub/individual/data/", "pub/individual/doc/", + "pub/individual/driver/", "pub/individual/font/", "pub/individual/lib/", "pub/individual/proto/", + "pub/individual/util/", "pub/individual/xserver/" ] + + def generate_data_ftp(self): + walker = ftp_module.FTPWalker(self.ftpserver,"anonymous","test@test.com") + #files = [] + #for directory in self.release_directories: + # f_files = ftp_module.find_files(walker, directory,"","") + # files.extend(f_files) + # remove everything expect the tar.bz2 + #files = self.filter_files(files) + + individual_files = [] + for directory in self.latest_directories: + #print "working in: "+directory + f_files = ftp_module.find_files(walker, directory,"","") + individual_files.extend(f_files) + individual_files = self.filter_files(individual_files) + + # create package objects for the files + #release_packages = [] # the packages that are required for a release + #for package_name in files: + # release_package = package_module.Package(package_name) + # release_packages.append(release_package) + + individual_packages = [] + for individual_package_name in individual_files: + individual_package = package_module.Package(individual_package_name) + individual_packages.append(individual_package) + + latest_packages = [] # the latest versions + package_in_use = [] # checker so we dont repeat packages + for package in individual_packages: + # i am lazy so lets do just one way sort. Should be rewritten into something faster :] + used = "false" + for packname in package_in_use: + if packname == package.name: + used = "true" + break + if used == "true": + continue + + package_in_use.append(package.name) + latest = self.get_latest(individual_packages, package.name, package.version) + + latest_packages.append(package_module.Package(package.name + "-" + latest)) + + snapshot_packages = [] + for package in latest_packages: + latest = self.get_latest(individual_packages, package.name, package.version, "true") + snapshot_packages.append(package_module.Package(package.name + "-" + latest)) + + return (latest_packages, snapshot_packages) + + def get_latest(self, rel_packages, name, version, snapshots="false"): + length = len(version.split(".")) + major = int(version.split(".")[0]) + minor = int(version.split(".")[1]) + if length < 3: + latest = str(major)+"."+str(minor) + subminor = 0 + else: + subminor = int(version.split(".")[2]) # usually the lovely .99. + if length < 4: + latest = str(major)+"."+str(minor)+"."+str(subminor) + subsubminor = 0 + else: + subsubminor = int(version.split(".")[3]) + if length >= 4: + latest = str(major)+"."+str(minor)+"."+str(subminor)+"."+str(subsubminor) + #rel_packages.sort() + for paclist in rel_packages: + if name == paclist.name: # we have the correct package name + length = len(paclist.version.split(".")) + loc_major = int(paclist.version.split(".")[0]) + loc_minor = int(paclist.version.split(".")[1]) + if length < 3: + loc_subminor = 0 + else: + loc_subminor = int(paclist.version.split(".")[2]) + if length < 4: + loc_subsubminor = 0 + else: + loc_subsubminor = int(paclist.version.split(".")[3]) + + if snapshots == "false" and ( loc_major > 98 or loc_minor > 98 or loc_subminor > 98 or loc_subsubminor > 98 ): + continue + + if loc_major < major: + continue + if loc_major == major and loc_minor < minor: + continue + if loc_major == major and loc_minor == minor and loc_subminor < subminor: + continue + if loc_major == major and loc_minor == minor and loc_subminor == subminor and loc_subsubminor < subsubminor: + continue + + major = loc_major + minor = loc_minor + subminor = loc_subminor + subsubminor = loc_subsubminor + if length <3: + latest = str(major)+"."+str(minor) + elif length < 4: + latest = str(major)+"."+str(minor)+"."+str(subminor) + else: + latest = str(major)+"."+str(minor)+"."+str(subminor)+"."+str(subsubminor) + else: + continue + return latest + + def filter_files(self, files): + # we want to filter out all the bad files. + newfiles = [] + for file in files: + # only keep files with .tar.bz2 ending. + if ( 0 < file.find(".tar.") and 0 < file.find(".bz2") ): + file = string.replace(file,".tar.bz2","") + file = string.replace(file,".asc","") + newfiles.append(file) + + return newfiles + +import portage_module +def compare_packages(release_packages, latest_packages, packages_in_portage): + # we care about 5 cases + # 1. portage version is less than the release version. (RED) + # 2. portage version is equal to the release version, but less than the latest version. (LIGHT GREEN) + # 3. portage version is equal to the release version and the latest version. (GREEN) + # 4. portage version is greater than the release version (GREEN) + # 5. package does not exist in portage (GREY) + + # again, we choose release_packages as the enumerator for the package names + # since it will have ALL packages ( for example, if we used portage_packages, we + # might miss the packages that do not exist in portage ) + status_packages = [] + for package in release_packages: + color = None + release_package = package + latest_package = portage_module.findpackage(package.name, latest_packages) + portage_package = portage_module.findpackage(package.name, packages_in_portage) + + if portage_package == None: + status = package_module.Status.NotFound + # we need to create a phony package since findpackage + # returns None + portage_package = package_module.Package(package.name) + + elif portage_module.best_version_test(portage_package.name_plus_version, \ + release_package.name_plus_version) == 2: + status = package_module.Status.NeedUpdate + + elif portage_module.best_version_test(portage_package.name_plus_version, \ + latest_package.name_plus_version) == 2: + status = package_module.Status.NewerVersion + + else: + status = package_module.Status.Compliant + + #if portage_package != None: + + # FIXME: Reports release version as latest version to not have to deal with this right now + if latest_package == None: + print "No latest version known for %s, FIXME!" % release_package.name + latest_package = release_package + + if DEBUG: + print "package: " + str(release_package.name) + \ + " | pp: " + str(portage_package.version) + \ + " | rp: " + str(release_package.version) + \ + " | lp: " + str(latest_package.version) + \ + " | status: " + str(status) + + status_packages.append(package_module.PackageStatus(release_package.name, str(portage_package.version), str(release_package.version), str(latest_package.version), status)) + + return status_packages diff --git a/modules/xmodular_output.py b/modules/xmodular_output.py new file mode 100644 index 0000000..fafd528 --- /dev/null +++ b/modules/xmodular_output.py @@ -0,0 +1,130 @@ +# Copyright John N. Laliberte <allanonjl@gentoo.org> +# LICENSE - GPL2 + +import package_module,time,clioptions_module,gnome_module,os + +class Output: + + def __init__(self, packages, to_calculate): + self.packages = packages + + if to_calculate: + self.calculate_stats() + + def calculate_stats(self): + # variables to hold for stats + total_packs = len(self.packages) + self.update_needed = float(0) + self.compliant = float(0) + self.not_found = float(0) + self.newer = float(0) + + for package in self.packages: + if package.status == package_module.Status.Compliant: + self.compliant +=1 + elif package.status == package_module.Status.NewerVersion: + self.newer +=1 + elif package.status == package_module.Status.NotFound: + self.not_found +=1 + elif package.status == package_module.Status.NeedUpdate: + self.update_needed +=1 + + try: + self.update_percent = float(self.update_needed / total_packs) * 100 + except ZeroDivisionError: + self.update_percent = 0 + try: + self.compliant_percent = float(self.compliant / total_packs) * 100 + except ZeroDivisionError: + self.compliant_percent = 0 + try: + self.notfound_percent = float(self.not_found / total_packs) * 100 + except ZeroDivisionError: + self.notfound_percent = 0 + try: + self.total_percent = float( (self.update_needed + self.not_found ) / total_packs ) * 100 + except ZeroDivisionError: + self.total_percent = 0 + + def generate_html(self): + + # now we have all the results in the results list. + # just time to generate some kind of "useful" output. + # for now, lets just make a crappy html file. ( this should use css and the like ) + # name, portage_version, gnome_version, status <-- is whats in the PackageUpdate object + current_time = str(time.asctime(time.localtime())) + + lines = [] + + # header + lines.append('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">') + lines.append("<html>") + lines.append('<head>') + lines.append('<title>Xorg progress Table</title>') + lines.append('<link rel="stylesheet" type="text/css" href="default.css"></link>') + lines.append('</head>') + lines.append("<body>") + lines.append("<h2>Xorg progress Table</h2>") + lines.append("contact " + os.environ["USER"] + "@gentoo.org if anything is not correct<br>") + lines.append("Generated date: " + current_time + "<br>") + # stats + lines.append("<br>") + lines.append("Compliant Packs: " + str('%0.2f' % self.compliant_percent)+ "%" + " Number = " + str(self.compliant) + "<br>") + lines.append("Packs that need to be updated: " + str('%0.2f' % self.update_percent)+ "%" + " Number = " + str(self.update_needed) + "<br>") + lines.append("New Packs that need to be added: " + str('%0.2f' % self.notfound_percent)+ "%" + " Number = " + str(self.not_found) + "<br>") + lines.append("<br>") + + lines.append('<table cellpadding="3">') + lines.append('<tr>') + lines.append("<th>Package Name</th><th>Portage Version</th><th>Official Version</th><th>Latest Version</th>") + lines.append('</tr>') + + # data + for package in self.packages: + if package.status == package_module.Status.NeedUpdate: + lines.append('<tr bgcolor="#FF8A75">') # "red" + elif package.status == package_module.Status.Compliant: + lines.append('<tr bgcolor="#D0EE80">') # "green" + elif package.status == package_module.Status.NotFound: + lines.append('<tr bgcolor="#EBEBEB">') # "grey" + elif package.status == package_module.Status.NewerVersion: + lines.append('<tr bgcolor="#FFFF95">') # "yellow" + + lines.append("<td>" + str(package.name) + "</td>") + lines.append("<td>" + str(package.portage_version) + "</td>") + lines.append("<td>" + str(package.gnome_version) + "</td>") + lines.append("<td>" + str(package.latest_version) + "</td>") + + lines.append("</tr>") + + lines.append("</table>") + + # footer + lines.append("<br>Official Version: Latest stable Xorg released individual packages") + lines.append("<br>Latest Version: Latest available Xorg released individual packages. Including the snapshots") + lines.append("</html>") + + self.write_file(lines, clioptions_module.Options().get_arguments().output) + + print "Generated html output." + + def generate_keywords(self): + lines = [] + for package in self.packages: + package_string = package.category + "/" + package.name + "-" + package.version + # only append revision if its not -r0 + if "r0" != package.revision: + package_string += "-" + package.revision + + lines.append("=" + package_string) + + self.write_file(lines, "package.keywords") + + print "Generate package.keywords output." + + def write_file(self, lines, filename): + file = open(filename, "w") + file.writelines(x +'\n' for x in lines) + file.flush() + file.close() + del file diff --git a/x-modular-bumpchecker.py b/x-modular-bumpchecker.py new file mode 100755 index 0000000..3970dff --- /dev/null +++ b/x-modular-bumpchecker.py @@ -0,0 +1,48 @@ +#! /usr/bin/python +# Copyright John N. Laliberte <allanonjl@gentoo.org> +# Copyright Daniel Gryniewicz <dang@gentoo.org> +# Copyright Tomas Chvatal <scarabeus@gentoo.org> +# LICENSE - GPL2 + +import os,sys + +exename=os.path.basename(sys.argv[0]) +version = "0.0.1" +sys.path = ["modules"]+sys.path + +if __name__ == '__main__': + + import clioptions_module + options = clioptions_module.Options() + + import xmodular_module + + x11 = xmodular_module.X_modular() + + # Quick versions file parsing + release_packages, latest_packages = x11.generate_data_ftp() + + # figure out what versions of these packages are in portage. + # we need a list of package names to check for, so we choose + # to use the release_packages list. + import portage_module + packages_in_portage = \ + portage_module.find_packages_in_tree(release_packages, \ + options.get_arguments().portdir, \ + options.get_arguments().all_overlays, \ + options.get_arguments().overlays) + + # compare the versions in order to check if we are up to date. + comparison_result_packages = xmodular_module.compare_packages(release_packages, \ + latest_packages, \ + packages_in_portage) + + # output these results to a nice html document + import xmodular_output + xmodular_output.Output(comparison_result_packages, True).generate_html() + + # if we specified to generate a keywords file, generate it + # keep in mind this will do it for the versions in portage, which + # may not be the release versions if we are not up to date. + if True == options.get_arguments().keywords: + xmodular_output.Output(packages_in_portage, False).generate_keywords() |