* ubuntutools/lp/lpapiwrapper.py: Rewrite some functions from functions.py in a

OO-way and add caching
* ubuntutools/lp/functions.py: Use the lpapiwrapper.py where applicable and
  mark the rewritten functions as deprecated
* ubuntutools/lp/udtexceptions.py: Add PocketDoesNotExistException
* buildd: Make use of LpApiWrapper
This commit is contained in:
Michael Bienia 2009-06-11 20:23:30 +02:00
parent 39211b67e0
commit 40f749c91b
4 changed files with 144 additions and 41 deletions

11
buildd
View File

@ -25,6 +25,8 @@
import sys import sys
from optparse import OptionGroup from optparse import OptionGroup
from optparse import OptionParser from optparse import OptionParser
import ubuntutools.lp.udtexceptions
from ubuntutools.lp.lpapiwrapper import LpApiWrapper
# Usage. # Usage.
usage = "%prog <srcpackage> <release> <operation>\n\n" usage = "%prog <srcpackage> <release> <operation>\n\n"
@ -96,7 +98,6 @@ else:
# ubuntu-dev-tools modules # ubuntu-dev-tools modules
# Import here to improve speed perception parsing options for user. # Import here to improve speed perception parsing options for user.
import ubuntutools.lp.functions as lp_functions import ubuntutools.lp.functions as lp_functions
import ubuntutools.lp.udtexceptions
# split release and pocket # split release and pocket
if '-' in release: if '-' in release:
@ -109,16 +110,18 @@ if pocket not in ('Release', 'Security', 'Updates', 'Proposed', 'Backports'):
sys.exit(1) sys.exit(1)
# Initialize ubuntu distribution collection. # Initialize ubuntu distribution collection.
ubuntuDist = lp_functions.getUbuntuDistribution() lpapiwrapper = LpApiWrapper()
ubuntuDist = lpapiwrapper.getUbuntuDistribution()
# Get main Ubuntu archive. # Get main Ubuntu archive.
archive = ubuntuDist.main_archive archive = lpapiwrapper.getUbuntuArchive()
# Check the release exists. # Check the release exists.
try: try:
release_series = lp_functions.doesUbuntuReleaseExist(release) release_series = lpapiwrapper.getUbuntuSeries(release)
except ubuntutools.lp.udtexceptions.SeriesNotFoundException, e: except ubuntutools.lp.udtexceptions.SeriesNotFoundException, e:
print e print e
sys.exit(1) sys.exit(1)
# Get list of published sources for package in question. # Get list of published sources for package in question.
#sources = lpapiwrapper.getUbuntuSourcePackage(package, release, pocket)
sources = lp_functions._ubuntuSourcePackage(package, release, pocket) sources = lp_functions._ubuntuSourcePackage(package, release, pocket)
# Get list of builds for that package. # Get list of builds for that package.
builds = sources.getBuilds() builds = sources.getBuilds()

View File

@ -21,23 +21,36 @@
import urllib2 import urllib2
import sys import sys
from udtexceptions import PackageNotFoundException, SeriesNotFoundException from udtexceptions import PackageNotFoundException, SeriesNotFoundException
from lpapiwrapper import Launchpad from lpapiwrapper import Launchpad, LpApiWrapper
import launchpadlib import launchpadlib
from re import findall from re import findall
import warnings
# http://wiki.python.org/moin/PythonDecoratorLibrary#GeneratingDeprecationWarnings
def deprecated(func):
"""This is a decorator which can be used to mark functions
as deprecated. It will result in a warning being emitted
when the function is used."""
def new_func(*args, **kwargs):
warnings.warn("Call to deprecated function %s." % func.__name__, DeprecationWarning, 2)
return func(*args, **kwargs)
new_func.__name__ = func.__name__
new_func.__doc__ = func.__doc__
new_func.__dict__.update(func.__dict__)
return new_func
# Singleton to access LP API # Singleton to access LP API
launchpad = Launchpad launchpad = Launchpad
@deprecated
def getUbuntuDistribution(): def getUbuntuDistribution():
ubuntu = launchpad.distributions['ubuntu'] return LpApiWrapper.getUbuntuDistribution()
return ubuntu
@deprecated
def ubuntuDevelopmentSeries(): def ubuntuDevelopmentSeries():
""" Get the string repr of the current Ubuntu development series """ """ Get the string repr of the current Ubuntu development series """
return LpApiWrapper.getUbuntuDevelopmentSeries().name
ubuntu = getUbuntuDistribution()
return ubuntu.current_series.name
def doesUbuntuReleaseExist(name): def doesUbuntuReleaseExist(name):
""" Prettier name to use for _ubuntuSeries() """ """ Prettier name to use for _ubuntuSeries() """
@ -49,15 +62,7 @@ def _ubuntuSeries(name):
returns the LP API repr of a series passed by name (e.g. 'karmic') returns the LP API repr of a series passed by name (e.g. 'karmic')
If the series is not found: raise SeriesNotFoundException If the series is not found: raise SeriesNotFoundException
""" """
return LpApiWrapper.getUbuntuSeries(name)
ubuntu = getUbuntuDistribution()
try:
return ubuntu.getSeries(name_or_version=name)
except launchpadlib.errors.HTTPError:
raise SeriesNotFoundException("Error: Unknown Ubuntu release: '%s'." % name)
def _ubuntuSourcePackage(package, series, pocket = 'Release'): def _ubuntuSourcePackage(package, series, pocket = 'Release'):
""" Finds an Ubuntu source package on LP """ Finds an Ubuntu source package on LP
@ -65,23 +70,8 @@ def _ubuntuSourcePackage(package, series, pocket = 'Release'):
returns LP API repr of the source package returns LP API repr of the source package
If the package does not exist: raise PackageNotFoundException If the package does not exist: raise PackageNotFoundException
""" """
lpapiwrapper = LpApiWrapper()
try: return lpapiwrapper.getUbuntuSourcePackage(package, series, pocket)
lpseries = _ubuntuSeries(series)
ubuntu = launchpad.distributions['ubuntu']
u_archive = ubuntu.main_archive
component = u_archive.getPublishedSources(source_name=package, status="Published",
exact_match=True, distro_series=lpseries, pocket = pocket)[0]
return component
except IndexError:
raise PackageNotFoundException("The package %s does not exist in the Ubuntu main archive" %
package)
def packageVersion(package, series=ubuntuDevelopmentSeries()): def packageVersion(package, series=ubuntuDevelopmentSeries()):
""" Retrieves the version of a given source package in the current """ Retrieves the version of a given source package in the current
@ -112,8 +102,7 @@ def canUploadPackage(package, series=ubuntuDevelopmentSeries()):
If the package does not exist: raise PackageNotFoundException If the package does not exist: raise PackageNotFoundException
""" """
ubuntu = launchpad.distributions['ubuntu'] u_archive = LpApiWrapper.getUbuntuArchive()
u_archive = ubuntu.main_archive
uploaders = u_archive.getUploadersForComponent(component_name=packageComponent(package, series)) uploaders = u_archive.getUploadersForComponent(component_name=packageComponent(package, series))
@ -153,7 +142,7 @@ def isPerPackageUploader(package):
# Checks if the user has upload privileges for a certain package. # Checks if the user has upload privileges for a certain package.
me = findall('~(\S+)', '%s' % launchpad.me)[0] me = findall('~(\S+)', '%s' % launchpad.me)[0]
main_archive = launchpad.distributions["ubuntu"].main_archive main_archive = LpApiWrapper.getUbuntuArchive()
try: try:
perms = main_archive.getUploadersForPackage(source_package_name=package) perms = main_archive.getUploadersForPackage(source_package_name=package)
except launchpadlib.errors.HTTPError: except launchpadlib.errors.HTTPError:

View File

@ -25,9 +25,12 @@
#httplib2.debuglevel = 1 #httplib2.debuglevel = 1
import libsupport import libsupport
from launchpadlib.errors import HTTPError
from launchpadlib.resource import Entry
from udtexceptions import PackageNotFoundException, SeriesNotFoundException, PocketDoesNotExist
# Singleton for Launchpad API access
class Launchpad(object): class Launchpad(object):
''' Singleton for LP API access. '''
__lp = None __lp = None
def __getattr__(self, attr): def __getattr__(self, attr):
@ -38,3 +41,107 @@ class Launchpad(object):
def __call__(self): def __call__(self):
return self return self
Launchpad = Launchpad() Launchpad = Launchpad()
class LpApiWrapper(object):
'''
Wrapper around some common used LP API functions used in
ubuntu-dev-tools.
It also caches LP API objects either as class variables or as
instance variables depending on the expected change of its value.
'''
_ubuntu = None
_archive = None
_series = dict()
_devel_series = None
def __init__(self):
self._src_pkg = dict()
@classmethod
def getUbuntuDistribution(cls):
'''
Returns the LP representation for Ubuntu.
'''
if not cls._ubuntu:
cls._ubuntu = Launchpad.distributions['ubuntu']
return cls._ubuntu
@classmethod
def getUbuntuArchive(cls):
'''
Returns the LP representation for the Ubuntu main archive.
'''
if not cls._archive:
cls._archive = cls.getUbuntuDistribution().main_archive
return cls._archive
@classmethod
def getUbuntuSeries(cls, name_or_version):
'''
Returns the LP representation of a series passed by name (e.g.
'karmic') or version (e.g. '9.10').
If the series is not found: raise SeriesNotFoundException
'''
name_or_version = str(name_or_version)
if name_or_version not in cls._series:
try:
series = cls.getUbuntuDistribution().getSeries(name_or_version = name_or_version)
# Cache with name and version
cls._series[series.name] = series
cls._series[series.version] = series
except HTTPError:
raise SeriesNotFoundException("Error: Unknown Ubuntu release: '%s'." % name)
return cls._series[name_or_version]
@classmethod
def getUbuntuDevelopmentSeries(cls):
'''
Returns the LP representation of the current development series of
Ubuntu.
'''
if not cls._devel_series:
dev = cls.getUbuntuDistribution().current_series
cls._devel_series = dev
# Cache it in _series if not already done
if dev.name not in cls._series:
cls._series[dev.name] = dev
cls._series[dev.version] = dev
return cls._devel_series
def getUbuntuSourcePackage(self, name, series, pocket = 'Release'):
'''
Finds an Ubuntu source package on LP.
Returns LP representation of the source package.
If the package does not exist: raise PackageNotFoundException
'''
# Check if pocket has a valid value
if pocket not in ('Release', 'Security', 'Updates', 'Proposed', 'Backports'):
raise PocketDoesNotExist("Pocket '%s' does not exist." % pocket)
# Check if we have already a LP representation of an Ubuntu series or not
if not isinstance(series, Entry):
series = self.getUbuntuSeries(str(series))
if (name, series, pocket) not in self._src_pkg:
try:
srcpkg = self.getUbuntuArchive().getPublishedSources(
source_name = name, distro_series = series, pocket = pocket,
status = 'Published', exact_match = True)[0]
self._src_pkg[(name, series, pocket)] = srcpkg
except IndexError:
if pocket == 'Release':
msg = "The package '%s' does not exist in the Ubuntu main archive in '%s'" % \
(name, series.name)
else:
msg = "The package '%s' does not exist in the Ubuntu main archive in '%s-%s'" % \
(name, series.name, pocket.lower())
raise PackageNotFoundException(msg)
return self._src_pkg[(name, series, pocket)]

View File

@ -5,3 +5,7 @@ class PackageNotFoundException(BaseException):
class SeriesNotFoundException(BaseException): class SeriesNotFoundException(BaseException):
""" Thrown when a distroseries is not found """ """ Thrown when a distroseries is not found """
pass pass
class PocketDoesNotExist(BaseException):
""" Thrown when a invalid pocket is passed """
pass