~debfx/+junk/kubuntu-web

#!/usr/bin/python

#  Copyright (C) 2012 Felix Geyer <debfx@ubuntu.com>
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 2 or (at your option)
#  version 3 of the License.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program.  If not, see <http://www.gnu.org/licenses/>.

from launchpadlib.launchpad import Launchpad
from collections import defaultdict
import sys
import urllib2
import StringIO
import gzip
import datetime
import psycopg2, psycopg2.extensions
from kubuntuweb import *

conn = pgsqlConnect()
conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
cur = conn.cursor()

launchpad = Launchpad.login_anonymously("kubuntu-buildstatus", "production", lpTmpDir())

ubuntu = launchpad.distributions["ubuntu"]
archive = ubuntu.main_archive
series = ubuntu.current_series
prev_series = series.parent_series

packages = parsePackageList()

archs = []
for arch in series.architectures_collection:
    archs.append(arch.architecture_tag)
if "amd64" in archs:
    archs.insert(0, archs.pop(archs.index("amd64")))
if "i386" in archs:
    archs.insert(0, archs.pop(archs.index("i386")))

def get_http_gzip(url):
    f = urllib2.urlopen(url)
    compresseddata = f.read()
    compressedstream = StringIO.StringIO(compresseddata)
    gzipper = gzip.GzipFile(fileobj=compressedstream)
    return gzipper.read()

def parse_buildlog(url):
    data = get_http_gzip(url)
    if "dpkg-gensymbols: warning: some symbols or patterns disappeared in the symbols file" in data:
        return "symbols_missing"
    elif "dpkg-gensymbols: warning: some new symbols appeared in the symbols file" in data:
        return "symbols_new"
    else:
        return "ok"

result = defaultdict(lambda: defaultdict(defaultdict))

for package in packages:
    sources = archive.getPublishedSources(distro_series=series, exact_match=True, pocket="Release", source_name=package)
    try:
        sources[0]
    except IndexError:
        print >> sys.stderr, "Package not found: " + package
        continue
    builds = sources[0].getBuilds()
    version = sources[0].source_package_version

    # workaround for packages that are copied over from the last series
    try:
        builds[0]
    except IndexError:
        sources = archive.getPublishedSources(distro_series=prev_series, exact_match=True, pocket="Release", source_name=package)
        builds = sources[0].getBuilds()
        version = sources[0].source_package_version

    result[package]["version"] = version

    for build in builds:
        if build.buildstate == "Successfully built":
            result[package][build.arch_tag]["buildstate"] = "success"

            cur.execute("SELECT status FROM kubuntu_buildstatus WHERE build_link = %s", (build.self_link,))
            row = cur.fetchone()
            if row:
                result[package][build.arch_tag]["symbols"] = row[0]
            else:
                symbols_status = parse_buildlog(build.build_log_url)
                cur.execute("DELETE FROM kubuntu_buildstatus WHERE package = %s AND arch = %s", (package, build.arch_tag))
                cur.execute("INSERT INTO kubuntu_buildstatus (build_link, package, arch, status) VALUES (%s, %s, %s, %s)", (build.self_link, package, build.arch_tag, symbols_status))
                result[package][build.arch_tag]["symbols"] = symbols_status
        elif build.buildstate == "Needs building" or build.buildstate == "Dependency wait" or build.buildstate == "Currently building":
            result[package][build.arch_tag]["buildstate"] = "waiting"
        else:
            result[package][build.arch_tag]["buildstate"] = "failed"

        result[package][build.arch_tag]["buildstate_long"] = build.buildstate
        result[package][build.arch_tag]["link"] = build.web_link
        result[package][build.arch_tag]["log"] = build.build_log_url

cur.execute("SELECT package, status, status_verbose, upstream_version, upstream_url FROM kubuntu_dehs")
for record in cur:
    package = record[0]
    result[package]["watch"]["status"] = record[1]
    result[package]["watch"]["status_verbose"] = record[2]
    result[package]["watch"]["upstream_version"] = record[3]
    result[package]["watch"]["upstream_url"] = record[4]

print """
<html>

<head>
  <title>Kubuntu build status</title>
  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
  <link rel="stylesheet" type="text/css" href="kubuntu-buildstatus.css" />
</head>

<body>

<h1 id="top">Kubuntu build status</h1>

<table class="grid">

<thead><tr>
  <th>Package</th>
  <th>Version</th>
"""

for arch in archs:
    print "<th>%s</th>" % (arch,)

print """
  <th>watch</th>
</tr></thead>

<tbody>
"""

i = 0

for package in packages:
    if not package in result:
        continue
    
    if (i % 2) == 0:
        trclass = "even"
    else:
        trclass = "odd"
    i = i + 1

    print '<tr class="%s" style="text-align: center;">\n' % (trclass,)

    print '<td><a href="https://launchpad.net/ubuntu/+source/%s">%s</a></td>\n' % (package, package)
    print '<td><a href="https://launchpad.net/ubuntu/+source/%s/%s">%s</a></td>\n' % (package, result[package]["version"], result[package]["version"])

    for arch in archs:
        if not "buildstate" in result[package][arch]:
            print '<td>&nbsp;</td>\n'
            continue
        if result[package][arch]["buildstate"] == "waiting":
            tdclass = "BUILDWAITING"
            state = result[package][arch]["buildstate_long"]
        elif result[package][arch]["buildstate"] == "failed":
            tdclass = "BUILDFAILED"
            state = result[package][arch]["buildstate_long"]
        else:
            if result[package][arch]["symbols"] == "symbols_missing":
                state = "Missing symbols"
                tdclass = "BUILDSYMBOLSMISSING"
            elif result[package][arch]["symbols"] == "symbols_new":
                state = "New symbols"
                tdclass = "BUILDSYMBOLSNEW"
            else:
                tdclass = "BUILDSUCCESS"
                state = "Successful"

        print '<td class="%s"><a href="%s">%s</a></td>\n' % (tdclass, result[package][arch]["link"], state)

    tdclass = ""
    tdtext = "-"
    if "watch" in result[package]:
        status = result[package]["watch"]["status"]
        if status == "outdated":
            tdclass = "BUILDSYMBOLSMISSING"
            tdtext = "<a href=\"%s\">%s</a>" % (result[package]["watch"]["upstream_url"], result[package]["watch"]["upstream_version"])
        elif (status == "up_to_date") or (status == "newer"):
            tdtext = result[package]["watch"]["upstream_version"]
        statusVerbose = result[package]["watch"]["status_verbose"]
    else:
        statusVerbose = "not checked"
    print '<td class="%s" title="%s">%s</td>\n' % (tdclass, statusVerbose, tdtext)

    print '</tr>\n'

print """
</tbody>

</table>
"""

print "<br/><div>Last updated on %s</div>\n" % datetime.datetime.now().strftime("%Y-%m-%d %H:%M")

print """
</body>
</html>
"""

# kate: space-indent on; indent-width 4; replace-tabs on; indent-mode python; remove-trailing-space on;