X modular bumpchecker version 1.0

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()