################################################################################
import os
+from os.path import normpath
import re
import psycopg2
import traceback
from datetime import datetime, timedelta
from errno import ENOENT
from tempfile import mkstemp, mkdtemp
+from subprocess import Popen, PIPE
+from tarfile import TarFile
from inspect import getargspec
import sqlalchemy
-from sqlalchemy import create_engine, Table, MetaData, Column, Integer
+from sqlalchemy import create_engine, Table, MetaData, Column, Integer, desc, \
+ Text, ForeignKey
from sqlalchemy.orm import sessionmaker, mapper, relation, object_session, \
- backref, MapperExtension, EXT_CONTINUE
+ backref, MapperExtension, EXT_CONTINUE, object_mapper, clear_mappers
from sqlalchemy import types as sqltypes
+from sqlalchemy.orm.collections import attribute_mapped_collection
+from sqlalchemy.ext.associationproxy import association_proxy
# Don't remove this, we re-export the exceptions to scripts which import us
from sqlalchemy.exc import *
warnings.filterwarnings('ignore', \
"The SQLAlchemy PostgreSQL dialect has been renamed from 'postgres' to 'postgresql'.*", \
SADeprecationWarning)
-# TODO: sqlalchemy needs some extra configuration to correctly reflect
-# the ind_deb_contents_* indexes - we ignore the warnings at the moment
-warnings.filterwarnings("ignore", 'Predicate of partial index', SAWarning)
################################################################################
# list
value = len(value)
elif hasattr(value, 'count'):
- # query
+ # query (but not during validation)
+ if self.in_validation:
+ continue
value = value.count()
else:
raise KeyError('Do not understand property %s.' % property)
validation_message = \
"Validation failed because property '%s' must not be empty in object\n%s"
+ in_validation = False
+
def validate(self):
'''
This function validates the not NULL constraints as returned by
getattr(self, property + '_id') is not None:
continue
if not hasattr(self, property) or getattr(self, property) is None:
- raise DBUpdateError(self.validation_message % \
- (property, str(self)))
+ # str() might lead to races due to a 2nd flush
+ self.in_validation = True
+ message = self.validation_message % (property, str(self))
+ self.in_validation = False
+ raise DBUpdateError(message)
@classmethod
@session_wrapper
'''
return session.query(cls).get(primary_key)
+ def session(self, replace = False):
+ '''
+ Returns the current session that is associated with the object. May
+ return None is object is in detached state.
+ '''
+
+ return object_session(self)
+
+ def clone(self, session = None):
+ '''
+ Clones the current object in a new session and returns the new clone. A
+ fresh session is created if the optional session parameter is not
+ provided. The function will fail if a session is provided and has
+ unflushed changes.
+
+ RATIONALE: SQLAlchemy's session is not thread safe. This method clones
+ an existing object to allow several threads to work with their own
+ instances of an ORMObject.
+
+ WARNING: Only persistent (committed) objects can be cloned. Changes
+ made to the original object that are not committed yet will get lost.
+ The session of the new object will always be rolled back to avoid
+ ressource leaks.
+ '''
+
+ if self.session() is None:
+ raise RuntimeError( \
+ 'Method clone() failed for detached object:\n%s' % self)
+ self.session().flush()
+ mapper = object_mapper(self)
+ primary_key = mapper.primary_key_from_instance(self)
+ object_class = self.__class__
+ if session is None:
+ session = DBConn().session()
+ elif len(session.new) + len(session.dirty) + len(session.deleted) > 0:
+ raise RuntimeError( \
+ 'Method clone() failed due to unflushed changes in session.')
+ new_object = session.query(object_class).get(primary_key)
+ session.rollback()
+ if new_object is None:
+ raise RuntimeError( \
+ 'Method clone() failed for non-persistent object:\n%s' % self)
+ return new_object
+
__all__.append('ORMObject')
################################################################################
################################################################################
-class BinContents(object):
- def __init__(self, *args, **kwargs):
- pass
+class BinContents(ORMObject):
+ def __init__(self, file = None, binary = None):
+ self.file = file
+ self.binary = binary
- def __repr__(self):
- return '<BinContents (%s, %s)>' % (self.binary, self.filename)
+ def properties(self):
+ return ['file', 'binary']
__all__.append('BinContents')
self.poolfile = poolfile
self.binarytype = binarytype
+ @property
+ def pkid(self):
+ return self.binary_id
+
def properties(self):
return ['package', 'version', 'maintainer', 'source', 'architecture', \
'poolfile', 'binarytype', 'fingerprint', 'install_date', \
- 'suites_count', 'binary_id']
+ 'suites_count', 'binary_id', 'contents_count', 'extra_sources']
def not_null_constraints(self):
return ['package', 'version', 'maintainer', 'source', 'poolfile', \
'binarytype']
+ metadata = association_proxy('key', 'value')
+
+ def get_component_name(self):
+ return self.poolfile.location.component.component_name
+
+ def scan_contents(self):
+ '''
+ Yields the contents of the package. Only regular files are yielded and
+ the path names are normalized after converting them from either utf-8
+ or iso8859-1 encoding. It yields the string ' <EMPTY PACKAGE>' if the
+ package does not contain any regular file.
+ '''
+ fullpath = self.poolfile.fullpath
+ dpkg = Popen(['dpkg-deb', '--fsys-tarfile', fullpath], stdout = PIPE)
+ tar = TarFile.open(fileobj = dpkg.stdout, mode = 'r|')
+ for member in tar.getmembers():
+ if not member.isdir():
+ name = normpath(member.name)
+ # enforce proper utf-8 encoding
+ try:
+ name.decode('utf-8')
+ except UnicodeDecodeError:
+ name = name.decode('iso8859-1').encode('utf-8')
+ yield name
+ tar.close()
+ dpkg.stdout.close()
+ dpkg.wait()
+
+ def read_control(self):
+ '''
+ Reads the control information from a binary.
+
+ @rtype: text
+ @return: stanza text of the control section.
+ '''
+ import apt_inst
+ fullpath = self.poolfile.fullpath
+ deb_file = open(fullpath, 'r')
+ stanza = apt_inst.debExtractControl(deb_file)
+ deb_file.close()
+
+ return stanza
+
+ def read_control_fields(self):
+ '''
+ Reads the control information from a binary and return
+ as a dictionary.
+
+ @rtype: dict
+ @return: fields of the control section as a dictionary.
+ '''
+ import apt_pkg
+ stanza = self.read_control()
+ return apt_pkg.TagSection(stanza)
+
__all__.append('DBBinary')
@session_wrapper
__all__.append('get_suites_binary_in')
@session_wrapper
-def get_binary_from_name_suite(package, suitename, session=None):
- ### For dak examine-package
- ### XXX: Doesn't use object API yet
-
- sql = """SELECT DISTINCT(b.package), b.version, c.name, su.suite_name
- FROM binaries b, files fi, location l, component c, bin_associations ba, suite su
- WHERE b.package='%(package)s'
- AND b.file = fi.id
- AND fi.location = l.id
- AND l.component = c.id
- AND ba.bin=b.id
- AND ba.suite = su.id
- AND su.suite_name %(suitename)s
- ORDER BY b.version DESC"""
+def get_component_by_package_suite(package, suite_list, arch_list=[], session=None):
+ '''
+ Returns the component name of the newest binary package in suite_list or
+ None if no package is found. The result can be optionally filtered by a list
+ of architecture names.
- return session.execute(sql % {'package': package, 'suitename': suitename})
+ @type package: str
+ @param package: DBBinary package name to search for
-__all__.append('get_binary_from_name_suite')
+ @type suite_list: list of str
+ @param suite_list: list of suite_name items
-@session_wrapper
-def get_binary_components(package, suitename, arch, session=None):
- # Check for packages that have moved from one component to another
- query = """SELECT c.name FROM binaries b, bin_associations ba, suite s, location l, component c, architecture a, files f
- WHERE b.package=:package AND s.suite_name=:suitename
- AND (a.arch_string = :arch OR a.arch_string = 'all')
- AND ba.bin = b.id AND ba.suite = s.id AND b.architecture = a.id
- AND f.location = l.id
- AND l.component = c.id
- AND b.file = f.id"""
+ @type arch_list: list of str
+ @param arch_list: optional list of arch_string items that defaults to []
- vals = {'package': package, 'suitename': suitename, 'arch': arch}
+ @rtype: str or NoneType
+ @return: name of component or None
+ '''
- return session.execute(query, vals)
+ q = session.query(DBBinary).filter_by(package = package). \
+ join(DBBinary.suites).filter(Suite.suite_name.in_(suite_list))
+ if len(arch_list) > 0:
+ q = q.join(DBBinary.architecture). \
+ filter(Architecture.arch_string.in_(arch_list))
+ binary = q.order_by(desc(DBBinary.version)).first()
+ if binary is None:
+ return None
+ else:
+ return binary.get_component_name()
-__all__.append('get_binary_components')
+__all__.append('get_component_by_package_suite')
################################################################################
return NotImplemented
def properties(self):
- return ['component_name', 'component_id', 'description', 'location', \
- 'meets_dfsg']
+ return ['component_name', 'component_id', 'description', \
+ 'location_count', 'meets_dfsg', 'overrides_count']
def not_null_constraints(self):
return ['component_name']
def fullpath(self):
return os.path.join(self.location.path, self.filename)
- def is_valid(self, filesize = -1, md5sum = None):\
- return self.filesize == filesize and self.md5sum == md5sum
+ def is_valid(self, filesize = -1, md5sum = None):
+ return self.filesize == long(filesize) and self.md5sum == md5sum
def properties(self):
return ['filename', 'file_id', 'filesize', 'md5sum', 'sha1sum', \
################################################################################
-# TODO: Why do we have a separate Location class? Can't it be fully integrated
-# into class Component?
class Location(ORMObject):
def __init__(self, path = None, component = None):
self.path = path
self.archive_type = 'pool'
def properties(self):
- return ['path', 'archive_type', 'component', 'files_count']
+ return ['path', 'location_id', 'archive_type', 'component', \
+ 'files_count']
def not_null_constraints(self):
return ['path', 'archive_type']
################################################################################
-class Override(object):
- def __init__(self, *args, **kwargs):
- pass
+class Override(ORMObject):
+ def __init__(self, package = None, suite = None, component = None, overridetype = None, \
+ section = None, priority = None):
+ self.package = package
+ self.suite = suite
+ self.component = component
+ self.overridetype = overridetype
+ self.section = section
+ self.priority = priority
- def __repr__(self):
- return '<Override %s (%s)>' % (self.package, self.suite_id)
+ def properties(self):
+ return ['package', 'suite', 'component', 'overridetype', 'section', \
+ 'priority']
+
+ def not_null_constraints(self):
+ return ['package', 'suite', 'component', 'overridetype', 'section']
__all__.append('Override')
################################################################################
-class OverrideType(object):
- def __init__(self, *args, **kwargs):
- pass
+class OverrideType(ORMObject):
+ def __init__(self, overridetype = None):
+ self.overridetype = overridetype
- def __repr__(self):
- return '<OverrideType %s>' % self.overridetype
+ def properties(self):
+ return ['overridetype', 'overridetype_id', 'overrides_count']
+
+ def not_null_constraints(self):
+ return ['overridetype']
__all__.append('OverrideType')
################################################################################
-class DebContents(object):
- def __init__(self, *args, **kwargs):
- pass
-
- def __repr__(self):
- return '<DebConetnts %s: %s>' % (self.package.package,self.file)
-
-__all__.append('DebContents')
-
-
-class UdebContents(object):
- def __init__(self, *args, **kwargs):
- pass
-
- def __repr__(self):
- return '<UdebConetnts %s: %s>' % (self.package.package,self.file)
-
-__all__.append('UdebContents')
-
-class PendingBinContents(object):
- def __init__(self, *args, **kwargs):
- pass
-
- def __repr__(self):
- return '<PendingBinContents %s>' % self.contents_id
-
-__all__.append('PendingBinContents')
-
-def insert_pending_content_paths(package,
- is_udeb,
- fullpaths,
- session=None):
- """
- Make sure given paths are temporarily associated with given
- package
-
- @type package: dict
- @param package: the package to associate with should have been read in from the binary control file
- @type fullpaths: list
- @param fullpaths: the list of paths of the file being associated with the binary
- @type session: SQLAlchemy session
- @param session: Optional SQLAlchemy session. If this is passed, the caller
- is responsible for ensuring a transaction has begun and committing the
- results or rolling back based on the result code. If not passed, a commit
- will be performed at the end of the function
-
- @return: True upon success, False if there is a problem
- """
-
- privatetrans = False
-
- if session is None:
- session = DBConn().session()
- privatetrans = True
-
- try:
- arch = get_architecture(package['Architecture'], session)
- arch_id = arch.arch_id
-
- # Remove any already existing recorded files for this package
- q = session.query(PendingBinContents)
- q = q.filter_by(package=package['Package'])
- q = q.filter_by(version=package['Version'])
- q = q.filter_by(architecture=arch_id)
- q.delete()
-
- for fullpath in fullpaths:
-
- if fullpath.startswith( "./" ):
- fullpath = fullpath[2:]
-
- pca = PendingBinContents()
- pca.package = package['Package']
- pca.version = package['Version']
- pca.file = fullpath
- pca.architecture = arch_id
-
- if isudeb:
- pca.type = 8 # gross
- else:
- pca.type = 7 # also gross
- session.add(pca)
-
- # Only commit if we set up the session ourself
- if privatetrans:
- session.commit()
- session.close()
- else:
- session.flush()
-
- return True
- except Exception, e:
- traceback.print_exc()
-
- # Only rollback if we set up the session ourself
- if privatetrans:
- session.rollback()
- session.close()
-
- return False
-
-__all__.append('insert_pending_content_paths')
-
-################################################################################
-
class PolicyQueue(object):
def __init__(self, *args, **kwargs):
pass
################################################################################
-class Priority(object):
- def __init__(self, *args, **kwargs):
- pass
+class Priority(ORMObject):
+ def __init__(self, priority = None, level = None):
+ self.priority = priority
+ self.level = level
+
+ def properties(self):
+ return ['priority', 'priority_id', 'level', 'overrides_count']
+
+ def not_null_constraints(self):
+ return ['priority', 'level']
def __eq__(self, val):
if isinstance(val, str):
# This signals to use the normal comparison operator
return NotImplemented
- def __repr__(self):
- return '<Priority %s (%s)>' % (self.priority, self.priority_id)
-
__all__.append('Priority')
@session_wrapper
################################################################################
-class Section(object):
- def __init__(self, *args, **kwargs):
- pass
+class Section(ORMObject):
+ def __init__(self, section = None):
+ self.section = section
+
+ def properties(self):
+ return ['section', 'section_id', 'overrides_count']
+
+ def not_null_constraints(self):
+ return ['section']
def __eq__(self, val):
if isinstance(val, str):
# This signals to use the normal comparison operator
return NotImplemented
- def __repr__(self):
- return '<Section %s>' % self.section
-
__all__.append('Section')
@session_wrapper
################################################################################
+class SrcContents(ORMObject):
+ def __init__(self, file = None, source = None):
+ self.file = file
+ self.source = source
+
+ def properties(self):
+ return ['file', 'source']
+
+__all__.append('SrcContents')
+
+################################################################################
+
+from debian.debfile import Deb822
+
+# Temporary Deb822 subclass to fix bugs with : handling; see #597249
+class Dak822(Deb822):
+ def _internal_parser(self, sequence, fields=None):
+ # The key is non-whitespace, non-colon characters before any colon.
+ key_part = r"^(?P<key>[^: \t\n\r\f\v]+)\s*:\s*"
+ single = re.compile(key_part + r"(?P<data>\S.*?)\s*$")
+ multi = re.compile(key_part + r"$")
+ multidata = re.compile(r"^\s(?P<data>.+?)\s*$")
+
+ wanted_field = lambda f: fields is None or f in fields
+
+ if isinstance(sequence, basestring):
+ sequence = sequence.splitlines()
+
+ curkey = None
+ content = ""
+ for line in self.gpg_stripped_paragraph(sequence):
+ m = single.match(line)
+ if m:
+ if curkey:
+ self[curkey] = content
+
+ if not wanted_field(m.group('key')):
+ curkey = None
+ continue
+
+ curkey = m.group('key')
+ content = m.group('data')
+ continue
+
+ m = multi.match(line)
+ if m:
+ if curkey:
+ self[curkey] = content
+
+ if not wanted_field(m.group('key')):
+ curkey = None
+ continue
+
+ curkey = m.group('key')
+ content = ""
+ continue
+
+ m = multidata.match(line)
+ if m:
+ content += '\n' + line # XXX not m.group('data')?
+ continue
+
+ if curkey:
+ self[curkey] = content
+
+
class DBSource(ORMObject):
def __init__(self, source = None, version = None, maintainer = None, \
changedby = None, poolfile = None, install_date = None):
self.poolfile = poolfile
self.install_date = install_date
+ @property
+ def pkid(self):
+ return self.source_id
+
def properties(self):
return ['source', 'source_id', 'maintainer', 'changedby', \
'fingerprint', 'poolfile', 'version', 'suites_count', \
return ['source', 'version', 'install_date', 'maintainer', \
'changedby', 'poolfile', 'install_date']
+ def read_control_fields(self):
+ '''
+ Reads the control information from a dsc
+
+ @rtype: tuple
+ @return: fields is the dsc information in a dictionary form
+ '''
+ fullpath = self.poolfile.fullpath
+ fields = Dak822(open(self.poolfile.fullpath, 'r'))
+ return fields
+
+ metadata = association_proxy('key', 'value')
+
+ def scan_contents(self):
+ '''
+ Returns a set of names for non directories. The path names are
+ normalized after converting them from either utf-8 or iso8859-1
+ encoding.
+ '''
+ fullpath = self.poolfile.fullpath
+ from daklib.contents import UnpackedSource
+ unpacked = UnpackedSource(fullpath)
+ fileset = set()
+ for name in unpacked.get_all_filenames():
+ # enforce proper utf-8 encoding
+ try:
+ name.decode('utf-8')
+ except UnicodeDecodeError:
+ name = name.decode('iso8859-1').encode('utf-8')
+ fileset.add(name)
+ return fileset
+
__all__.append('DBSource')
@session_wrapper
maps = [ (x[1], x[2]) for x in maps
if x[0] == "map" or x[0] == "silent-map" ]
s = [suite]
- for x in maps:
- if x[1] in s and x[0] not in s:
- s.append(x[0])
+ for (from_, to) in maps:
+ if from_ in s and to not in s:
+ s.append(to)
q = q.filter(DBSource.suites.any(Suite.suite_name.in_(s)))
__all__.append('get_source_in_suite')
+@session_wrapper
+def import_metadata_into_db(obj, session=None):
+ """
+ This routine works on either DBBinary or DBSource objects and imports
+ their metadata into the database
+ """
+ fields = obj.read_control_fields()
+ for k in fields.keys():
+ try:
+ # Try raw ASCII
+ val = str(fields[k])
+ except UnicodeEncodeError:
+ # Fall back to UTF-8
+ try:
+ val = fields[k].encode('utf-8')
+ except UnicodeEncodeError:
+ # Finally try iso8859-1
+ val = fields[k].encode('iso8859-1')
+ # Otherwise we allow the exception to percolate up and we cause
+ # a reject as someone is playing silly buggers
+
+ obj.metadata[get_or_set_metadatakey(k, session)] = val
+
+ session.commit_or_flush()
+
+__all__.append('import_metadata_into_db')
+
+
################################################################################
@session_wrapper
bin.source_id = bin_sources[0].source_id
+ if entry.has_key("built-using"):
+ for srcname, version in entry["built-using"]:
+ exsources = get_sources_from_name(srcname, version, session=session)
+ if len(exsources) != 1:
+ raise NoSourceFieldError, "Unable to find source package (%s = %s) in Built-Using for %s (%s), %s, file %s, type %s, signed by %s" % \
+ (srcname, version, bin.package, bin.version, entry["architecture"],
+ filename, bin.binarytype, u.pkg.changes["fingerprint"])
+
+ bin.extra_sources.append(exsources[0])
+
# Add and flush object so it has an ID
session.add(bin)
# session.rollback()
# raise MissingContents, "No contents stored for package %s, and couldn't determine contents of %s" % (bin.package, filename)
- return poolfile
+ return bin, poolfile
__all__.append('add_deb_to_db')
self.version = version
def properties(self):
- return ['suite_name', 'version', 'sources_count', 'binaries_count']
+ return ['suite_name', 'version', 'sources_count', 'binaries_count', \
+ 'overrides_count']
def not_null_constraints(self):
- return ['suite_name', 'version']
+ return ['suite_name']
def __eq__(self, val):
if isinstance(val, str):
################################################################################
+class MetadataKey(ORMObject):
+ def __init__(self, key = None):
+ self.key = key
+
+ def properties(self):
+ return ['key']
+
+ def not_null_constraints(self):
+ return ['key']
+
+__all__.append('MetadataKey')
+
+@session_wrapper
+def get_or_set_metadatakey(keyname, session=None):
+ """
+ Returns MetadataKey object for given uidname.
+
+ If no matching keyname is found, a row is inserted.
+
+ @type uidname: string
+ @param uidname: The keyname to add
+
+ @type session: SQLAlchemy
+ @param session: Optional SQL session object (a temporary one will be
+ generated if not supplied). If not passed, a commit will be performed at
+ the end of the function, otherwise the caller is responsible for commiting.
+
+ @rtype: MetadataKey
+ @return: the metadatakey object for the given keyname
+ """
+
+ q = session.query(MetadataKey).filter_by(key=keyname)
+
+ try:
+ ret = q.one()
+ except NoResultFound:
+ ret = MetadataKey(keyname)
+ session.add(ret)
+ session.commit_or_flush()
+
+ return ret
+
+__all__.append('get_or_set_metadatakey')
+
+################################################################################
+
+class BinaryMetadata(ORMObject):
+ def __init__(self, key = None, value = None, binary = None):
+ self.key = key
+ self.value = value
+ self.binary = binary
+
+ def properties(self):
+ return ['binary', 'key', 'value']
+
+ def not_null_constraints(self):
+ return ['value']
+
+__all__.append('BinaryMetadata')
+
+################################################################################
+
+class SourceMetadata(ORMObject):
+ def __init__(self, key = None, value = None, source = None):
+ self.key = key
+ self.value = value
+ self.source = source
+
+ def properties(self):
+ return ['source', 'key', 'value']
+
+ def not_null_constraints(self):
+ return ['value']
+
+__all__.append('SourceMetadata')
+
+################################################################################
+
class DBConn(object):
"""
database module init.
self.__createconn()
def __setuptables(self):
- tables_with_primary = (
+ tables = (
'architecture',
'archive',
'bin_associations',
+ 'bin_contents',
'binaries',
+ 'binaries_metadata',
'binary_acl',
'binary_acl_map',
'build_queue',
+ 'build_queue_files',
'changelogs_text',
+ 'changes',
'component',
'config',
'changes_pending_binaries',
'changes_pending_files',
'changes_pending_source',
+ 'changes_pending_files_map',
+ 'changes_pending_source_files',
+ 'changes_pool_files',
'dsc_files',
+ 'extra_src_references',
'files',
'fingerprint',
'keyrings',
'keyring_acl_map',
'location',
'maintainer',
+ 'metadata_keys',
'new_comments',
+ # TODO: the maintainer column in table override should be removed.
+ 'override',
'override_type',
- 'pending_bin_contents',
'policy_queue',
'priority',
'section',
'source',
'source_acl',
+ 'source_metadata',
'src_associations',
+ 'src_contents',
'src_format',
'src_uploaders',
'suite',
- 'uid',
- 'upload_blocks',
- # The following tables have primary keys but sqlalchemy
- # version 0.5 fails to reflect them correctly with database
- # versions before upgrade #41.
- #'changes',
- #'build_queue_files',
- )
-
- tables_no_primary = (
- 'bin_contents',
- 'changes_pending_files_map',
- 'changes_pending_source_files',
- 'changes_pool_files',
- 'deb_contents',
- 'override',
'suite_architectures',
- 'suite_src_formats',
'suite_build_queue_copy',
- 'udeb_contents',
- # see the comment above
- 'changes',
- 'build_queue_files',
+ 'suite_src_formats',
+ 'uid',
+ 'upload_blocks',
)
views = (
'suite_arch_by_name',
)
- # Sqlalchemy version 0.5 fails to reflect the SERIAL type
- # correctly and that is why we have to use a workaround. It can
- # be removed as soon as we switch to version 0.6.
- for table_name in tables_with_primary:
+ for table_name in tables:
table = Table(table_name, self.db_meta, \
- Column('id', Integer, primary_key = True), \
autoload=True, useexisting=True)
setattr(self, 'tbl_%s' % table_name, table)
- for table_name in tables_no_primary:
- table = Table(table_name, self.db_meta, autoload=True)
- setattr(self, 'tbl_%s' % table_name, table)
-
for view_name in views:
view = Table(view_name, self.db_meta, autoload=True)
setattr(self, 'view_%s' % view_name, view)
properties = dict(archive_id = self.tbl_archive.c.id,
archive_name = self.tbl_archive.c.name))
- mapper(PendingBinContents, self.tbl_pending_bin_contents,
- properties = dict(contents_id =self.tbl_pending_bin_contents.c.id,
- filename = self.tbl_pending_bin_contents.c.filename,
- package = self.tbl_pending_bin_contents.c.package,
- version = self.tbl_pending_bin_contents.c.version,
- arch = self.tbl_pending_bin_contents.c.arch,
- otype = self.tbl_pending_bin_contents.c.type))
-
- mapper(DebContents, self.tbl_deb_contents,
- properties = dict(binary_id=self.tbl_deb_contents.c.binary_id,
- package=self.tbl_deb_contents.c.package,
- suite=self.tbl_deb_contents.c.suite,
- arch=self.tbl_deb_contents.c.arch,
- section=self.tbl_deb_contents.c.section,
- filename=self.tbl_deb_contents.c.filename))
-
- mapper(UdebContents, self.tbl_udeb_contents,
- properties = dict(binary_id=self.tbl_udeb_contents.c.binary_id,
- package=self.tbl_udeb_contents.c.package,
- suite=self.tbl_udeb_contents.c.suite,
- arch=self.tbl_udeb_contents.c.arch,
- section=self.tbl_udeb_contents.c.section,
- filename=self.tbl_udeb_contents.c.filename))
-
mapper(BuildQueue, self.tbl_build_queue,
properties = dict(queue_id = self.tbl_build_queue.c.id))
fingerprint = relation(Fingerprint),
install_date = self.tbl_binaries.c.install_date,
suites = relation(Suite, secondary=self.tbl_bin_associations,
- backref=backref('binaries', lazy='dynamic'))),
+ backref=backref('binaries', lazy='dynamic')),
+ extra_sources = relation(DBSource, secondary=self.tbl_extra_src_references,
+ backref=backref('extra_binary_references', lazy='dynamic')),
+ key = relation(BinaryMetadata, cascade='all',
+ collection_class=attribute_mapped_collection('key'))),
extension = validator)
mapper(BinaryACL, self.tbl_binary_acl,
mapper(Location, self.tbl_location,
properties = dict(location_id = self.tbl_location.c.id,
component_id = self.tbl_location.c.component,
- component = relation(Component, \
- backref=backref('location', uselist = False)),
+ component = relation(Component, backref='location'),
archive_id = self.tbl_location.c.archive,
archive = relation(Archive),
# FIXME: the 'type' column is old cruft and
mapper(Override, self.tbl_override,
properties = dict(suite_id = self.tbl_override.c.suite,
- suite = relation(Suite),
+ suite = relation(Suite, \
+ backref=backref('overrides', lazy='dynamic')),
package = self.tbl_override.c.package,
component_id = self.tbl_override.c.component,
- component = relation(Component),
+ component = relation(Component, \
+ backref=backref('overrides', lazy='dynamic')),
priority_id = self.tbl_override.c.priority,
- priority = relation(Priority),
+ priority = relation(Priority, \
+ backref=backref('overrides', lazy='dynamic')),
section_id = self.tbl_override.c.section,
- section = relation(Section),
+ section = relation(Section, \
+ backref=backref('overrides', lazy='dynamic')),
overridetype_id = self.tbl_override.c.type,
- overridetype = relation(OverrideType)))
+ overridetype = relation(OverrideType, \
+ backref=backref('overrides', lazy='dynamic'))))
mapper(OverrideType, self.tbl_override_type,
properties = dict(overridetype = self.tbl_override_type.c.type,
primaryjoin=(self.tbl_source.c.id==self.tbl_dsc_files.c.source)),
suites = relation(Suite, secondary=self.tbl_src_associations,
backref=backref('sources', lazy='dynamic')),
- srcuploaders = relation(SrcUploader)),
+ srcuploaders = relation(SrcUploader),
+ key = relation(SourceMetadata, cascade='all',
+ collection_class=attribute_mapped_collection('key'))),
extension = validator)
mapper(SourceACL, self.tbl_source_acl,
fingerprint = relation(Fingerprint, backref="uploadblocks"),
uid = relation(Uid, backref="uploadblocks")))
+ mapper(BinContents, self.tbl_bin_contents,
+ properties = dict(
+ binary = relation(DBBinary,
+ backref=backref('contents', lazy='dynamic', cascade='all')),
+ file = self.tbl_bin_contents.c.file))
+
+ mapper(SrcContents, self.tbl_src_contents,
+ properties = dict(
+ source = relation(DBSource,
+ backref=backref('contents', lazy='dynamic', cascade='all')),
+ file = self.tbl_src_contents.c.file))
+
+ mapper(MetadataKey, self.tbl_metadata_keys,
+ properties = dict(
+ key_id = self.tbl_metadata_keys.c.key_id,
+ key = self.tbl_metadata_keys.c.key))
+
+ mapper(BinaryMetadata, self.tbl_binaries_metadata,
+ properties = dict(
+ binary_id = self.tbl_binaries_metadata.c.bin_id,
+ binary = relation(DBBinary),
+ key_id = self.tbl_binaries_metadata.c.key_id,
+ key = relation(MetadataKey),
+ value = self.tbl_binaries_metadata.c.value))
+
+ mapper(SourceMetadata, self.tbl_source_metadata,
+ properties = dict(
+ source_id = self.tbl_source_metadata.c.src_id,
+ source = relation(DBSource),
+ key_id = self.tbl_source_metadata.c.key_id,
+ key = relation(MetadataKey),
+ value = self.tbl_source_metadata.c.value))
+
## Connection functions
def __createconn(self):
from config import Config
cnf = Config()
- if cnf["DB::Host"]:
+ if cnf.has_key("DB::Service"):
+ connstr = "postgresql://service=%s" % cnf["DB::Service"]
+ elif cnf.has_key("DB::Host"):
# TCP/IP
- connstr = "postgres://%s" % cnf["DB::Host"]
- if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
+ connstr = "postgresql://%s" % cnf["DB::Host"]
+ if cnf.has_key("DB::Port") and cnf["DB::Port"] != "-1":
connstr += ":%s" % cnf["DB::Port"]
connstr += "/%s" % cnf["DB::Name"]
else:
# Unix Socket
- connstr = "postgres:///%s" % cnf["DB::Name"]
- if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
+ connstr = "postgresql:///%s" % cnf["DB::Name"]
+ if cnf.has_key("DB::Port") and cnf["DB::Port"] != "-1":
connstr += "?port=%s" % cnf["DB::Port"]
- self.db_pg = create_engine(connstr, echo=self.debug)
+ engine_args = { 'echo': self.debug }
+ if cnf.has_key('DB::PoolSize'):
+ engine_args['pool_size'] = int(cnf['DB::PoolSize'])
+ if cnf.has_key('DB::MaxOverflow'):
+ engine_args['max_overflow'] = int(cnf['DB::MaxOverflow'])
+ if sa_major_version == '0.6' and cnf.has_key('DB::Unicode') and \
+ cnf['DB::Unicode'] == 'false':
+ engine_args['use_native_unicode'] = False
+
+ # Monkey patch a new dialect in in order to support service= syntax
+ import sqlalchemy.dialects.postgresql
+ from sqlalchemy.dialects.postgresql.psycopg2 import PGDialect_psycopg2
+ class PGDialect_psycopg2_dak(PGDialect_psycopg2):
+ def create_connect_args(self, url):
+ if str(url).startswith('postgresql://service='):
+ # Eww
+ servicename = str(url)[21:]
+ return (['service=%s' % servicename], {})
+ else:
+ return PGDialect_psycopg2.create_connect_args(self, url)
+
+ sqlalchemy.dialects.postgresql.base.dialect = PGDialect_psycopg2_dak
+
+ self.db_pg = create_engine(connstr, **engine_args)
self.db_meta = MetaData()
self.db_meta.bind = self.db_pg
self.db_smaker = sessionmaker(bind=self.db_pg,
self.__setuptables()
self.__setupmappers()
+ self.pid = os.getpid()
def session(self):
+ # reinitialize DBConn in new processes
+ if self.pid != os.getpid():
+ clear_mappers()
+ self.__createconn()
return self.db_smaker()
__all__.append('DBConn')