kumquat-buildroot/support/scripts/xorg-release
Thomas Petazzoni d7dde090f4 xorg-release: ignore some X.org packages
Following Gustavo's removal of two X.org drivers for old hardware
unlikely to be used in embedded contexts, the xorg-release script now
reports those two X.org packages as "to be added": they exist in
X.org, but not in Buildroot.

So, we add a small list, XORG_EXCEPTIONS, in our xorg-release script,
to list the X.org packages we don't want to hear about. Of course,
packages that exist in X.org, and that are not part of this exception
list, and are not packaged in Buildroot are still listed as "to be
added".

Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Signed-off-by: Peter Korsgaard <jacmet@sunsite.dk>
2013-01-05 22:51:30 +01:00

177 lines
6.1 KiB
Python
Executable File

#!/usr/bin/python
# This script generates a report on the packaging status of X.org
# releases in Buildroot. It does so by downloading the list of
# tarballs that are part of a given X.org release, and compare that
# with the packages that are available in Buildroot.
import BeautifulSoup
import re
import os
import urllib
# This can be customized
XORG_VERSION = "X11R7.7"
# Key names in dictionaries
XORG_VERSION_KEY = "xorg-version"
BR_VERSION_KEY = "br-version"
BR_NAME_KEY = "br-name"
# Packages part of X.org releases that we do not want to package in
# Buildroot (old drivers for hardware unlikely to be used in embedded
# contexts).
XORG_EXCEPTIONS = [
'xf86-video-suncg6',
'xf86-video-sunffb',
]
# Get the list of tarballs of a X.org release, parse it, and return a
# dictionary of dictionaries, of the form:
#
# { <name_of_package> : { XORG_VERSION_KEY: <version_of_package> },
# <name_of_package2> : { XORG_VERSION_KEY: <version_of_package2> }}
#
def get_xorg_release_pkgs():
u = urllib.URLopener().open("http://www.x.org/releases/%s/src/everything/" % XORG_VERSION)
b = BeautifulSoup.BeautifulSoup()
b.feed(u.read())
links = b.findAll("a")
packages = {}
r = re.compile("(.*)-([0-9\.]*).tar.bz2")
# We now have a list of all links.
for link in links:
href = link.get("href")
# Skip everything but tarballs
if not href.endswith(".tar.bz2"):
continue
# Separate the name and the version
groups = r.match(href)
if not groups:
continue
name = groups.group(1)
version = groups.group(2)
# Skip packages we don't want to hear about
if name in XORG_EXCEPTIONS:
continue
packages[name] = { XORG_VERSION_KEY : version }
return packages
# Files and directories in package/x11r7/ that should be ignored in
# our processing.
BUILDROOT_EXCEPTIONS = [
"mcookie", # Code is directly in package directory
"x11r7.mk",
"Config.in",
"xdriver_xf86-input-tslib", # From Pengutronix, not part of X.org releases
]
# Prefixes of directories in package/x11r7/ that must be stripped
# before trying to match Buildroot package names with X.org tarball
# names.
BUILDROOT_PREFIXES = [
"xapp",
"xdriver",
"xfont",
"xlib",
"xserver",
"xutil",
"xproto",
]
# From a Buildroot package name, try to see if a prefix should be
# stripped from it. For example, passing "xapp_xlsfonts" as argument
# to this function will return "xlsfonts".
def buildroot_strip_prefix(dirname):
for prefix in BUILDROOT_PREFIXES:
if dirname.startswith(prefix + "_"):
return dirname[len(prefix) + 1:]
return dirname
# From a Buildroot package name, parse its .mk file to find the
# Buildroot version of the package by looking at the <foo>_VERSION
# line.
def buildroot_get_version(dirname):
f = open(os.path.join("package", "x11r7", dirname, dirname + ".mk"))
r = re.compile("^([A-Z0-9_]*)_VERSION = ([0-9\.]*)$")
for l in f.readlines():
m = r.match(l)
if m:
return m.group(2)
return None
# Augment the informations of the X.org list of packages (given as
# argument) by details about their packaging in Buildroot. Those
# details are found by looking at the contents of package/x11r7/.
def get_buildroot_pkgs(packages):
dirs = os.listdir(os.path.join(os.getcwd(), "package", "x11r7"))
for d in dirs:
# Skip exceptions
if d in BUILDROOT_EXCEPTIONS:
continue
pkgname = buildroot_strip_prefix(d)
version = buildroot_get_version(d)
if packages.has_key(pkgname):
# There is a X.org package of the same name, so we just
# add informations to the existing dict entry.
packages[pkgname]['br-version'] = version
packages[pkgname]['br-name'] = d
else:
# There is no X.org package with this name, so we add a
# new dict entry.
packages[pkgname] = { BR_VERSION_KEY: version,
BR_NAME_KEY : d }
return packages
def show_summary(packages):
FORMAT_STRING = "%40s | %15s | %15s | %-30s"
print FORMAT_STRING % ("Package name", "Vers in BR", "Vers in X.org", "Action")
print FORMAT_STRING % ("-" * 40, "-" * 15, "-" * 15, "-" * 30)
pkgs = packages.keys()
pkgs.sort()
total_pkgs = 0
upgrade_pkgs = 0
add_pkgs = 0
remove_pkgs = 0
nothing_todo_pkgs = 0
for pkgname in pkgs:
pkg = packages[pkgname]
total_pkgs += 1
if pkg.has_key(XORG_VERSION_KEY) and not pkg.has_key(BR_VERSION_KEY):
xorg_version = pkg[XORG_VERSION_KEY]
br_version = "N/A"
action = "Add to Buildroot"
add_pkgs += 1
elif not pkg.has_key(XORG_VERSION_KEY) and pkg.has_key(BR_VERSION_KEY):
br_version = pkg[BR_VERSION_KEY]
xorg_version = "N/A"
action = "Remove from Buildroot"
remove_pkgs += 1
# For now, we assume that if a package version is different,
# it's because an upgrade is needed.
elif pkg[XORG_VERSION_KEY] != pkg[BR_VERSION_KEY]:
br_version = pkg[BR_VERSION_KEY]
xorg_version = pkg[XORG_VERSION_KEY]
action = "Upgrade"
upgrade_pkgs += 1
else:
br_version = pkg[BR_VERSION_KEY]
xorg_version = pkg[XORG_VERSION_KEY]
action = "-"
nothing_todo_pkgs += 1
print FORMAT_STRING % (pkgname, br_version.center(15), xorg_version.center(15), action)
print FORMAT_STRING % ("-" * 40, "-" * 15, "-" * 15, "-" * 30)
STAT_FORMAT_STRING = "%40s : %3d"
print STAT_FORMAT_STRING % ("Total number of packages", total_pkgs)
print STAT_FORMAT_STRING % ("Packages to upgrade", upgrade_pkgs)
print STAT_FORMAT_STRING % ("Packages to add", add_pkgs)
print STAT_FORMAT_STRING % ("Packages to remove", remove_pkgs)
print STAT_FORMAT_STRING % ("Packages with nothing to do", nothing_todo_pkgs)
packages = get_xorg_release_pkgs()
packages = get_buildroot_pkgs(packages)
# print packages
show_summary(packages)