5 @contact: Debian FTPMaster <ftpmaster@debian.org>
6 @copyright: 2000, 2001, 2002, 2003, 2004, 2006 James Troup <james@nocrew.org>
7 @copyright: 2008-2009 Mark Hymers <mhy@debian.org>
8 @copyright: 2009, 2010 Joerg Jaspert <joerg@debian.org>
9 @copyright: 2009 Mike O'Connor <stew@debian.org>
10 @license: GNU General Public License version 2 or later
13 # This program is free software; you can redistribute it and/or modify
14 # it under the terms of the GNU General Public License as published by
15 # the Free Software Foundation; either version 2 of the License, or
16 # (at your option) any later version.
18 # This program is distributed in the hope that it will be useful,
19 # but WITHOUT ANY WARRANTY; without even the implied warranty of
20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 # GNU General Public License for more details.
23 # You should have received a copy of the GNU General Public License
24 # along with this program; if not, write to the Free Software
25 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 ################################################################################
29 # < mhy> I need a funny comment
30 # < sgran> two peanuts were walking down a dark street
31 # < sgran> one was a-salted
32 # * mhy looks up the definition of "funny"
34 ################################################################################
41 from datetime import datetime, timedelta
42 from errno import ENOENT
43 from tempfile import mkstemp, mkdtemp
45 from inspect import getargspec
48 from sqlalchemy import create_engine, Table, MetaData
49 from sqlalchemy.orm import sessionmaker, mapper, relation
50 from sqlalchemy import types as sqltypes
52 # Don't remove this, we re-export the exceptions to scripts which import us
53 from sqlalchemy.exc import *
54 from sqlalchemy.orm.exc import NoResultFound
56 # Only import Config until Queue stuff is changed to store its config
58 from config import Config
59 from textutils import fix_maintainer
61 ################################################################################
63 # Patch in support for the debversion field type so that it works during
66 class DebVersion(sqltypes.Text):
68 Support the debversion type
71 def get_col_spec(self):
74 sa_major_version = sqlalchemy.__version__[0:3]
75 if sa_major_version in ["0.5", "0.6"]:
76 from sqlalchemy.databases import postgres
77 postgres.ischema_names['debversion'] = DebVersion
79 raise Exception("dak only ported to SQLA versions 0.5 and 0.6. See daklib/dbconn.py")
81 ################################################################################
83 __all__ = ['IntegrityError', 'SQLAlchemyError']
85 ################################################################################
87 def session_wrapper(fn):
89 Wrapper around common ".., session=None):" handling. If the wrapped
90 function is called without passing 'session', we create a local one
91 and destroy it when the function ends.
93 Also attaches a commit_or_flush method to the session; if we created a
94 local session, this is a synonym for session.commit(), otherwise it is a
95 synonym for session.flush().
98 def wrapped(*args, **kwargs):
99 private_transaction = False
101 # Find the session object
102 session = kwargs.get('session')
105 if len(args) <= len(getargspec(fn)[0]) - 1:
106 # No session specified as last argument or in kwargs
107 private_transaction = True
108 session = kwargs['session'] = DBConn().session()
110 # Session is last argument in args
114 session = args[-1] = DBConn().session()
115 private_transaction = True
117 if private_transaction:
118 session.commit_or_flush = session.commit
120 session.commit_or_flush = session.flush
123 return fn(*args, **kwargs)
125 if private_transaction:
126 # We created a session; close it.
129 wrapped.__doc__ = fn.__doc__
130 wrapped.func_name = fn.func_name
134 __all__.append('session_wrapper')
136 ################################################################################
138 class Architecture(object):
139 def __init__(self, *args, **kwargs):
142 def __eq__(self, val):
143 if isinstance(val, str):
144 return (self.arch_string== val)
145 # This signals to use the normal comparison operator
146 return NotImplemented
148 def __ne__(self, val):
149 if isinstance(val, str):
150 return (self.arch_string != val)
151 # This signals to use the normal comparison operator
152 return NotImplemented
155 return '<Architecture %s>' % self.arch_string
157 __all__.append('Architecture')
160 def get_architecture(architecture, session=None):
162 Returns database id for given C{architecture}.
164 @type architecture: string
165 @param architecture: The name of the architecture
167 @type session: Session
168 @param session: Optional SQLA session object (a temporary one will be
169 generated if not supplied)
172 @return: Architecture object for the given arch (None if not present)
175 q = session.query(Architecture).filter_by(arch_string=architecture)
179 except NoResultFound:
182 __all__.append('get_architecture')
185 def get_architecture_suites(architecture, session=None):
187 Returns list of Suite objects for given C{architecture} name
189 @type architecture: str
190 @param architecture: Architecture name to search for
192 @type session: Session
193 @param session: Optional SQL session object (a temporary one will be
194 generated if not supplied)
197 @return: list of Suite objects for the given name (may be empty)
200 q = session.query(Suite)
201 q = q.join(SuiteArchitecture)
202 q = q.join(Architecture).filter_by(arch_string=architecture).order_by('suite_name')
208 __all__.append('get_architecture_suites')
210 ################################################################################
212 class Archive(object):
213 def __init__(self, *args, **kwargs):
217 return '<Archive %s>' % self.archive_name
219 __all__.append('Archive')
222 def get_archive(archive, session=None):
224 returns database id for given C{archive}.
226 @type archive: string
227 @param archive: the name of the arhive
229 @type session: Session
230 @param session: Optional SQLA session object (a temporary one will be
231 generated if not supplied)
234 @return: Archive object for the given name (None if not present)
237 archive = archive.lower()
239 q = session.query(Archive).filter_by(archive_name=archive)
243 except NoResultFound:
246 __all__.append('get_archive')
248 ################################################################################
250 class BinAssociation(object):
251 def __init__(self, *args, **kwargs):
255 return '<BinAssociation %s (%s, %s)>' % (self.ba_id, self.binary, self.suite)
257 __all__.append('BinAssociation')
259 ################################################################################
261 class BinContents(object):
262 def __init__(self, *args, **kwargs):
266 return '<BinContents (%s, %s)>' % (self.binary, self.filename)
268 __all__.append('BinContents')
270 ################################################################################
272 class DBBinary(object):
273 def __init__(self, *args, **kwargs):
277 return '<DBBinary %s (%s, %s)>' % (self.package, self.version, self.architecture)
279 __all__.append('DBBinary')
282 def get_suites_binary_in(package, session=None):
284 Returns list of Suite objects which given C{package} name is in
287 @param package: DBBinary package name to search for
290 @return: list of Suite objects for the given package
293 return session.query(Suite).join(BinAssociation).join(DBBinary).filter_by(package=package).all()
295 __all__.append('get_suites_binary_in')
298 def get_binary_from_id(binary_id, session=None):
300 Returns DBBinary object for given C{id}
303 @param binary_id: Id of the required binary
305 @type session: Session
306 @param session: Optional SQLA session object (a temporary one will be
307 generated if not supplied)
310 @return: DBBinary object for the given binary (None if not present)
313 q = session.query(DBBinary).filter_by(binary_id=binary_id)
317 except NoResultFound:
320 __all__.append('get_binary_from_id')
323 def get_binaries_from_name(package, version=None, architecture=None, session=None):
325 Returns list of DBBinary objects for given C{package} name
328 @param package: DBBinary package name to search for
330 @type version: str or None
331 @param version: Version to search for (or None)
333 @type architecture: str, list or None
334 @param architecture: Architectures to limit to (or None if no limit)
336 @type session: Session
337 @param session: Optional SQL session object (a temporary one will be
338 generated if not supplied)
341 @return: list of DBBinary objects for the given name (may be empty)
344 q = session.query(DBBinary).filter_by(package=package)
346 if version is not None:
347 q = q.filter_by(version=version)
349 if architecture is not None:
350 if not isinstance(architecture, list):
351 architecture = [architecture]
352 q = q.join(Architecture).filter(Architecture.arch_string.in_(architecture))
358 __all__.append('get_binaries_from_name')
361 def get_binaries_from_source_id(source_id, session=None):
363 Returns list of DBBinary objects for given C{source_id}
366 @param source_id: source_id to search for
368 @type session: Session
369 @param session: Optional SQL session object (a temporary one will be
370 generated if not supplied)
373 @return: list of DBBinary objects for the given name (may be empty)
376 return session.query(DBBinary).filter_by(source_id=source_id).all()
378 __all__.append('get_binaries_from_source_id')
381 def get_binary_from_name_suite(package, suitename, session=None):
382 ### For dak examine-package
383 ### XXX: Doesn't use object API yet
385 sql = """SELECT DISTINCT(b.package), b.version, c.name, su.suite_name
386 FROM binaries b, files fi, location l, component c, bin_associations ba, suite su
387 WHERE b.package='%(package)s'
389 AND fi.location = l.id
390 AND l.component = c.id
393 AND su.suite_name %(suitename)s
394 ORDER BY b.version DESC"""
396 return session.execute(sql % {'package': package, 'suitename': suitename})
398 __all__.append('get_binary_from_name_suite')
401 def get_binary_components(package, suitename, arch, session=None):
402 # Check for packages that have moved from one component to another
403 query = """SELECT c.name FROM binaries b, bin_associations ba, suite s, location l, component c, architecture a, files f
404 WHERE b.package=:package AND s.suite_name=:suitename
405 AND (a.arch_string = :arch OR a.arch_string = 'all')
406 AND ba.bin = b.id AND ba.suite = s.id AND b.architecture = a.id
407 AND f.location = l.id
408 AND l.component = c.id
411 vals = {'package': package, 'suitename': suitename, 'arch': arch}
413 return session.execute(query, vals)
415 __all__.append('get_binary_components')
417 ################################################################################
419 class BinaryACL(object):
420 def __init__(self, *args, **kwargs):
424 return '<BinaryACL %s>' % self.binary_acl_id
426 __all__.append('BinaryACL')
428 ################################################################################
430 class BinaryACLMap(object):
431 def __init__(self, *args, **kwargs):
435 return '<BinaryACLMap %s>' % self.binary_acl_map_id
437 __all__.append('BinaryACLMap')
439 ################################################################################
444 ArchiveDir "%(archivepath)s";
445 OverrideDir "%(overridedir)s";
446 CacheDir "%(cachedir)s";
451 Packages::Compress ". bzip2 gzip";
452 Sources::Compress ". bzip2 gzip";
457 bindirectory "incoming"
462 BinOverride "override.sid.all3";
463 BinCacheDB "packages-accepted.db";
465 FileList "%(filelist)s";
468 Packages::Extensions ".deb .udeb";
471 bindirectory "incoming/"
474 BinOverride "override.sid.all3";
475 SrcOverride "override.sid.all3.src";
476 FileList "%(filelist)s";
480 class BuildQueue(object):
481 def __init__(self, *args, **kwargs):
485 return '<BuildQueue %s>' % self.queue_name
487 def write_metadata(self, starttime, force=False):
488 # Do we write out metafiles?
489 if not (force or self.generate_metadata):
492 session = DBConn().session().object_session(self)
494 fl_fd = fl_name = ac_fd = ac_name = None
496 arches = " ".join([ a.arch_string for a in session.query(Architecture).all() if a.arch_string != 'source' ])
497 startdir = os.getcwd()
500 # Grab files we want to include
501 newer = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter(BuildQueueFile.lastused + timedelta(seconds=self.stay_of_execution) > starttime).all()
502 # Write file list with newer files
503 (fl_fd, fl_name) = mkstemp()
505 os.write(fl_fd, '%s\n' % n.fullpath)
510 # Write minimal apt.conf
511 # TODO: Remove hardcoding from template
512 (ac_fd, ac_name) = mkstemp()
513 os.write(ac_fd, MINIMAL_APT_CONF % {'archivepath': self.path,
515 'cachedir': cnf["Dir::Cache"],
516 'overridedir': cnf["Dir::Override"],
520 # Run apt-ftparchive generate
521 os.chdir(os.path.dirname(ac_name))
522 os.system('apt-ftparchive -qq -o APT::FTPArchive::Contents=off generate %s' % os.path.basename(ac_name))
524 # Run apt-ftparchive release
525 # TODO: Eww - fix this
526 bname = os.path.basename(self.path)
530 # We have to remove the Release file otherwise it'll be included in the
533 os.unlink(os.path.join(bname, 'Release'))
537 os.system("""apt-ftparchive -qq -o APT::FTPArchive::Release::Origin="%s" -o APT::FTPArchive::Release::Label="%s" -o APT::FTPArchive::Release::Description="%s" -o APT::FTPArchive::Release::Architectures="%s" release %s > Release""" % (self.origin, self.label, self.releasedescription, arches, bname))
539 # Crude hack with open and append, but this whole section is and should be redone.
540 if self.notautomatic:
541 release=open("Release", "a")
542 release.write("NotAutomatic: yes")
547 keyring = "--secret-keyring \"%s\"" % cnf["Dinstall::SigningKeyring"]
548 if cnf.has_key("Dinstall::SigningPubKeyring"):
549 keyring += " --keyring \"%s\"" % cnf["Dinstall::SigningPubKeyring"]
551 os.system("gpg %s --no-options --batch --no-tty --armour --default-key %s --detach-sign -o Release.gpg Release""" % (keyring, self.signingkey))
553 # Move the files if we got this far
554 os.rename('Release', os.path.join(bname, 'Release'))
556 os.rename('Release.gpg', os.path.join(bname, 'Release.gpg'))
558 # Clean up any left behind files
585 def clean_and_update(self, starttime, Logger, dryrun=False):
586 """WARNING: This routine commits for you"""
587 session = DBConn().session().object_session(self)
589 if self.generate_metadata and not dryrun:
590 self.write_metadata(starttime)
592 # Grab files older than our execution time
593 older = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter(BuildQueueFile.lastused + timedelta(seconds=self.stay_of_execution) <= starttime).all()
599 Logger.log(["I: Would have removed %s from the queue" % o.fullpath])
601 Logger.log(["I: Removing %s from the queue" % o.fullpath])
602 os.unlink(o.fullpath)
605 # If it wasn't there, don't worry
606 if e.errno == ENOENT:
609 # TODO: Replace with proper logging call
610 Logger.log(["E: Could not remove %s" % o.fullpath])
617 for f in os.listdir(self.path):
618 if f.startswith('Packages') or f.startswith('Source') or f.startswith('Release') or f.startswith('advisory'):
622 r = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter_by(filename = f).one()
623 except NoResultFound:
624 fp = os.path.join(self.path, f)
626 Logger.log(["I: Would remove unused link %s" % fp])
628 Logger.log(["I: Removing unused link %s" % fp])
632 Logger.log(["E: Failed to unlink unreferenced file %s" % r.fullpath])
634 def add_file_from_pool(self, poolfile):
635 """Copies a file into the pool. Assumes that the PoolFile object is
636 attached to the same SQLAlchemy session as the Queue object is.
638 The caller is responsible for committing after calling this function."""
639 poolfile_basename = poolfile.filename[poolfile.filename.rindex(os.sep)+1:]
641 # Check if we have a file of this name or this ID already
642 for f in self.queuefiles:
643 if f.fileid is not None and f.fileid == poolfile.file_id or \
644 f.poolfile.filename == poolfile_basename:
645 # In this case, update the BuildQueueFile entry so we
646 # don't remove it too early
647 f.lastused = datetime.now()
648 DBConn().session().object_session(poolfile).add(f)
651 # Prepare BuildQueueFile object
652 qf = BuildQueueFile()
653 qf.build_queue_id = self.queue_id
654 qf.lastused = datetime.now()
655 qf.filename = poolfile_basename
657 targetpath = poolfile.fullpath
658 queuepath = os.path.join(self.path, poolfile_basename)
662 # We need to copy instead of symlink
664 utils.copy(targetpath, queuepath)
665 # NULL in the fileid field implies a copy
668 os.symlink(targetpath, queuepath)
669 qf.fileid = poolfile.file_id
673 # Get the same session as the PoolFile is using and add the qf to it
674 DBConn().session().object_session(poolfile).add(qf)
679 __all__.append('BuildQueue')
682 def get_build_queue(queuename, session=None):
684 Returns BuildQueue object for given C{queue name}, creating it if it does not
687 @type queuename: string
688 @param queuename: The name of the queue
690 @type session: Session
691 @param session: Optional SQLA session object (a temporary one will be
692 generated if not supplied)
695 @return: BuildQueue object for the given queue
698 q = session.query(BuildQueue).filter_by(queue_name=queuename)
702 except NoResultFound:
705 __all__.append('get_build_queue')
707 ################################################################################
709 class BuildQueueFile(object):
710 def __init__(self, *args, **kwargs):
714 return '<BuildQueueFile %s (%s)>' % (self.filename, self.build_queue_id)
718 return os.path.join(self.buildqueue.path, self.filename)
721 __all__.append('BuildQueueFile')
723 ################################################################################
725 class ChangePendingBinary(object):
726 def __init__(self, *args, **kwargs):
730 return '<ChangePendingBinary %s>' % self.change_pending_binary_id
732 __all__.append('ChangePendingBinary')
734 ################################################################################
736 class ChangePendingFile(object):
737 def __init__(self, *args, **kwargs):
741 return '<ChangePendingFile %s>' % self.change_pending_file_id
743 __all__.append('ChangePendingFile')
745 ################################################################################
747 class ChangePendingSource(object):
748 def __init__(self, *args, **kwargs):
752 return '<ChangePendingSource %s>' % self.change_pending_source_id
754 __all__.append('ChangePendingSource')
756 ################################################################################
758 class Component(object):
759 def __init__(self, *args, **kwargs):
762 def __eq__(self, val):
763 if isinstance(val, str):
764 return (self.component_name == val)
765 # This signals to use the normal comparison operator
766 return NotImplemented
768 def __ne__(self, val):
769 if isinstance(val, str):
770 return (self.component_name != val)
771 # This signals to use the normal comparison operator
772 return NotImplemented
775 return '<Component %s>' % self.component_name
778 __all__.append('Component')
781 def get_component(component, session=None):
783 Returns database id for given C{component}.
785 @type component: string
786 @param component: The name of the override type
789 @return: the database id for the given component
792 component = component.lower()
794 q = session.query(Component).filter_by(component_name=component)
798 except NoResultFound:
801 __all__.append('get_component')
803 ################################################################################
805 class DBConfig(object):
806 def __init__(self, *args, **kwargs):
810 return '<DBConfig %s>' % self.name
812 __all__.append('DBConfig')
814 ################################################################################
817 def get_or_set_contents_file_id(filename, session=None):
819 Returns database id for given filename.
821 If no matching file is found, a row is inserted.
823 @type filename: string
824 @param filename: The filename
825 @type session: SQLAlchemy
826 @param session: Optional SQL session object (a temporary one will be
827 generated if not supplied). If not passed, a commit will be performed at
828 the end of the function, otherwise the caller is responsible for commiting.
831 @return: the database id for the given component
834 q = session.query(ContentFilename).filter_by(filename=filename)
837 ret = q.one().cafilename_id
838 except NoResultFound:
839 cf = ContentFilename()
840 cf.filename = filename
842 session.commit_or_flush()
843 ret = cf.cafilename_id
847 __all__.append('get_or_set_contents_file_id')
850 def get_contents(suite, overridetype, section=None, session=None):
852 Returns contents for a suite / overridetype combination, limiting
853 to a section if not None.
856 @param suite: Suite object
858 @type overridetype: OverrideType
859 @param overridetype: OverrideType object
861 @type section: Section
862 @param section: Optional section object to limit results to
864 @type session: SQLAlchemy
865 @param session: Optional SQL session object (a temporary one will be
866 generated if not supplied)
869 @return: ResultsProxy object set up to return tuples of (filename, section,
873 # find me all of the contents for a given suite
874 contents_q = """SELECT (p.path||'/'||n.file) AS fn,
878 FROM content_associations c join content_file_paths p ON (c.filepath=p.id)
879 JOIN content_file_names n ON (c.filename=n.id)
880 JOIN binaries b ON (b.id=c.binary_pkg)
881 JOIN override o ON (o.package=b.package)
882 JOIN section s ON (s.id=o.section)
883 WHERE o.suite = :suiteid AND o.type = :overridetypeid
884 AND b.type=:overridetypename"""
886 vals = {'suiteid': suite.suite_id,
887 'overridetypeid': overridetype.overridetype_id,
888 'overridetypename': overridetype.overridetype}
890 if section is not None:
891 contents_q += " AND s.id = :sectionid"
892 vals['sectionid'] = section.section_id
894 contents_q += " ORDER BY fn"
896 return session.execute(contents_q, vals)
898 __all__.append('get_contents')
900 ################################################################################
902 class ContentFilepath(object):
903 def __init__(self, *args, **kwargs):
907 return '<ContentFilepath %s>' % self.filepath
909 __all__.append('ContentFilepath')
912 def get_or_set_contents_path_id(filepath, session=None):
914 Returns database id for given path.
916 If no matching file is found, a row is inserted.
918 @type filepath: string
919 @param filepath: The filepath
921 @type session: SQLAlchemy
922 @param session: Optional SQL session object (a temporary one will be
923 generated if not supplied). If not passed, a commit will be performed at
924 the end of the function, otherwise the caller is responsible for commiting.
927 @return: the database id for the given path
930 q = session.query(ContentFilepath).filter_by(filepath=filepath)
933 ret = q.one().cafilepath_id
934 except NoResultFound:
935 cf = ContentFilepath()
936 cf.filepath = filepath
938 session.commit_or_flush()
939 ret = cf.cafilepath_id
943 __all__.append('get_or_set_contents_path_id')
945 ################################################################################
947 class ContentAssociation(object):
948 def __init__(self, *args, **kwargs):
952 return '<ContentAssociation %s>' % self.ca_id
954 __all__.append('ContentAssociation')
956 def insert_content_paths(binary_id, fullpaths, session=None):
958 Make sure given path is associated with given binary id
961 @param binary_id: the id of the binary
962 @type fullpaths: list
963 @param fullpaths: the list of paths of the file being associated with the binary
964 @type session: SQLAlchemy session
965 @param session: Optional SQLAlchemy session. If this is passed, the caller
966 is responsible for ensuring a transaction has begun and committing the
967 results or rolling back based on the result code. If not passed, a commit
968 will be performed at the end of the function, otherwise the caller is
969 responsible for commiting.
971 @return: True upon success
976 session = DBConn().session()
981 def generate_path_dicts():
982 for fullpath in fullpaths:
983 if fullpath.startswith( './' ):
984 fullpath = fullpath[2:]
986 yield {'filename':fullpath, 'id': binary_id }
988 for d in generate_path_dicts():
989 session.execute( "INSERT INTO bin_contents ( file, binary_id ) VALUES ( :filename, :id )",
998 traceback.print_exc()
1000 # Only rollback if we set up the session ourself
1007 __all__.append('insert_content_paths')
1009 ################################################################################
1011 class DSCFile(object):
1012 def __init__(self, *args, **kwargs):
1016 return '<DSCFile %s>' % self.dscfile_id
1018 __all__.append('DSCFile')
1021 def get_dscfiles(dscfile_id=None, source_id=None, poolfile_id=None, session=None):
1023 Returns a list of DSCFiles which may be empty
1025 @type dscfile_id: int (optional)
1026 @param dscfile_id: the dscfile_id of the DSCFiles to find
1028 @type source_id: int (optional)
1029 @param source_id: the source id related to the DSCFiles to find
1031 @type poolfile_id: int (optional)
1032 @param poolfile_id: the poolfile id related to the DSCFiles to find
1035 @return: Possibly empty list of DSCFiles
1038 q = session.query(DSCFile)
1040 if dscfile_id is not None:
1041 q = q.filter_by(dscfile_id=dscfile_id)
1043 if source_id is not None:
1044 q = q.filter_by(source_id=source_id)
1046 if poolfile_id is not None:
1047 q = q.filter_by(poolfile_id=poolfile_id)
1051 __all__.append('get_dscfiles')
1053 ################################################################################
1055 class PoolFile(object):
1056 def __init__(self, *args, **kwargs):
1060 return '<PoolFile %s>' % self.filename
1064 return os.path.join(self.location.path, self.filename)
1066 __all__.append('PoolFile')
1069 def check_poolfile(filename, filesize, md5sum, location_id, session=None):
1072 (ValidFileFound [boolean or None], PoolFile object or None)
1074 @type filename: string
1075 @param filename: the filename of the file to check against the DB
1078 @param filesize: the size of the file to check against the DB
1080 @type md5sum: string
1081 @param md5sum: the md5sum of the file to check against the DB
1083 @type location_id: int
1084 @param location_id: the id of the location to look in
1087 @return: Tuple of length 2.
1088 - If more than one file found with that name: (C{None}, C{None})
1089 - If valid pool file found: (C{True}, C{PoolFile object})
1090 - If valid pool file not found:
1091 - (C{False}, C{None}) if no file found
1092 - (C{False}, C{PoolFile object}) if file found with size/md5sum mismatch
1095 q = session.query(PoolFile).filter_by(filename=filename)
1096 q = q.join(Location).filter_by(location_id=location_id)
1106 if obj.md5sum != md5sum or obj.filesize != int(filesize):
1114 __all__.append('check_poolfile')
1117 def get_poolfile_by_id(file_id, session=None):
1119 Returns a PoolFile objects or None for the given id
1122 @param file_id: the id of the file to look for
1124 @rtype: PoolFile or None
1125 @return: either the PoolFile object or None
1128 q = session.query(PoolFile).filter_by(file_id=file_id)
1132 except NoResultFound:
1135 __all__.append('get_poolfile_by_id')
1139 def get_poolfile_by_name(filename, location_id=None, session=None):
1141 Returns an array of PoolFile objects for the given filename and
1142 (optionally) location_id
1144 @type filename: string
1145 @param filename: the filename of the file to check against the DB
1147 @type location_id: int
1148 @param location_id: the id of the location to look in (optional)
1151 @return: array of PoolFile objects
1154 q = session.query(PoolFile).filter_by(filename=filename)
1156 if location_id is not None:
1157 q = q.join(Location).filter_by(location_id=location_id)
1161 __all__.append('get_poolfile_by_name')
1164 def get_poolfile_like_name(filename, session=None):
1166 Returns an array of PoolFile objects which are like the given name
1168 @type filename: string
1169 @param filename: the filename of the file to check against the DB
1172 @return: array of PoolFile objects
1175 # TODO: There must be a way of properly using bind parameters with %FOO%
1176 q = session.query(PoolFile).filter(PoolFile.filename.like('%%/%s' % filename))
1180 __all__.append('get_poolfile_like_name')
1183 def add_poolfile(filename, datadict, location_id, session=None):
1185 Add a new file to the pool
1187 @type filename: string
1188 @param filename: filename
1190 @type datadict: dict
1191 @param datadict: dict with needed data
1193 @type location_id: int
1194 @param location_id: database id of the location
1197 @return: the PoolFile object created
1199 poolfile = PoolFile()
1200 poolfile.filename = filename
1201 poolfile.filesize = datadict["size"]
1202 poolfile.md5sum = datadict["md5sum"]
1203 poolfile.sha1sum = datadict["sha1sum"]
1204 poolfile.sha256sum = datadict["sha256sum"]
1205 poolfile.location_id = location_id
1207 session.add(poolfile)
1208 # Flush to get a file id (NB: This is not a commit)
1213 __all__.append('add_poolfile')
1215 ################################################################################
1217 class Fingerprint(object):
1218 def __init__(self, *args, **kwargs):
1222 return '<Fingerprint %s>' % self.fingerprint
1224 __all__.append('Fingerprint')
1227 def get_fingerprint(fpr, session=None):
1229 Returns Fingerprint object for given fpr.
1232 @param fpr: The fpr to find / add
1234 @type session: SQLAlchemy
1235 @param session: Optional SQL session object (a temporary one will be
1236 generated if not supplied).
1239 @return: the Fingerprint object for the given fpr or None
1242 q = session.query(Fingerprint).filter_by(fingerprint=fpr)
1246 except NoResultFound:
1251 __all__.append('get_fingerprint')
1254 def get_or_set_fingerprint(fpr, session=None):
1256 Returns Fingerprint object for given fpr.
1258 If no matching fpr is found, a row is inserted.
1261 @param fpr: The fpr to find / add
1263 @type session: SQLAlchemy
1264 @param session: Optional SQL session object (a temporary one will be
1265 generated if not supplied). If not passed, a commit will be performed at
1266 the end of the function, otherwise the caller is responsible for commiting.
1267 A flush will be performed either way.
1270 @return: the Fingerprint object for the given fpr
1273 q = session.query(Fingerprint).filter_by(fingerprint=fpr)
1277 except NoResultFound:
1278 fingerprint = Fingerprint()
1279 fingerprint.fingerprint = fpr
1280 session.add(fingerprint)
1281 session.commit_or_flush()
1286 __all__.append('get_or_set_fingerprint')
1288 ################################################################################
1290 # Helper routine for Keyring class
1291 def get_ldap_name(entry):
1293 for k in ["cn", "mn", "sn"]:
1295 if ret and ret[0] != "" and ret[0] != "-":
1297 return " ".join(name)
1299 ################################################################################
1301 class Keyring(object):
1302 gpg_invocation = "gpg --no-default-keyring --keyring %s" +\
1303 " --with-colons --fingerprint --fingerprint"
1308 def __init__(self, *args, **kwargs):
1312 return '<Keyring %s>' % self.keyring_name
1314 def de_escape_gpg_str(self, txt):
1315 esclist = re.split(r'(\\x..)', txt)
1316 for x in range(1,len(esclist),2):
1317 esclist[x] = "%c" % (int(esclist[x][2:],16))
1318 return "".join(esclist)
1320 def load_keys(self, keyring):
1323 if not self.keyring_id:
1324 raise Exception('Must be initialized with database information')
1326 k = os.popen(self.gpg_invocation % keyring, "r")
1330 for line in k.xreadlines():
1331 field = line.split(":")
1332 if field[0] == "pub":
1334 (name, addr) = email.Utils.parseaddr(field[9])
1335 name = re.sub(r"\s*[(].*[)]", "", name)
1336 if name == "" or addr == "" or "@" not in addr:
1338 addr = "invalid-uid"
1339 name = self.de_escape_gpg_str(name)
1340 self.keys[key] = {"email": addr}
1342 self.keys[key]["name"] = name
1343 self.keys[key]["fingerprints"] = []
1345 elif key and field[0] == "sub" and len(field) >= 12:
1346 signingkey = ("s" in field[11])
1347 elif key and field[0] == "uid":
1348 (name, addr) = email.Utils.parseaddr(field[9])
1349 elif signingkey and field[0] == "fpr":
1350 self.keys[key]["fingerprints"].append(field[9])
1351 self.fpr_lookup[field[9]] = key
1353 def import_users_from_ldap(self, session):
1357 LDAPDn = cnf["Import-LDAP-Fingerprints::LDAPDn"]
1358 LDAPServer = cnf["Import-LDAP-Fingerprints::LDAPServer"]
1360 l = ldap.open(LDAPServer)
1361 l.simple_bind_s("","")
1362 Attrs = l.search_s(LDAPDn, ldap.SCOPE_ONELEVEL,
1363 "(&(keyfingerprint=*)(gidnumber=%s))" % (cnf["Import-Users-From-Passwd::ValidGID"]),
1364 ["uid", "keyfingerprint", "cn", "mn", "sn"])
1366 ldap_fin_uid_id = {}
1373 uid = entry["uid"][0]
1374 name = get_ldap_name(entry)
1375 fingerprints = entry["keyFingerPrint"]
1377 for f in fingerprints:
1378 key = self.fpr_lookup.get(f, None)
1379 if key not in self.keys:
1381 self.keys[key]["uid"] = uid
1385 keyid = get_or_set_uid(uid, session).uid_id
1386 byuid[keyid] = (uid, name)
1387 byname[uid] = (keyid, name)
1389 return (byname, byuid)
1391 def generate_users_from_keyring(self, format, session):
1395 for x in self.keys.keys():
1396 if self.keys[x]["email"] == "invalid-uid":
1398 self.keys[x]["uid"] = format % "invalid-uid"
1400 uid = format % self.keys[x]["email"]
1401 keyid = get_or_set_uid(uid, session).uid_id
1402 byuid[keyid] = (uid, self.keys[x]["name"])
1403 byname[uid] = (keyid, self.keys[x]["name"])
1404 self.keys[x]["uid"] = uid
1407 uid = format % "invalid-uid"
1408 keyid = get_or_set_uid(uid, session).uid_id
1409 byuid[keyid] = (uid, "ungeneratable user id")
1410 byname[uid] = (keyid, "ungeneratable user id")
1412 return (byname, byuid)
1414 __all__.append('Keyring')
1417 def get_keyring(keyring, session=None):
1419 If C{keyring} does not have an entry in the C{keyrings} table yet, return None
1420 If C{keyring} already has an entry, simply return the existing Keyring
1422 @type keyring: string
1423 @param keyring: the keyring name
1426 @return: the Keyring object for this keyring
1429 q = session.query(Keyring).filter_by(keyring_name=keyring)
1433 except NoResultFound:
1436 __all__.append('get_keyring')
1438 ################################################################################
1440 class KeyringACLMap(object):
1441 def __init__(self, *args, **kwargs):
1445 return '<KeyringACLMap %s>' % self.keyring_acl_map_id
1447 __all__.append('KeyringACLMap')
1449 ################################################################################
1451 class DBChange(object):
1452 def __init__(self, *args, **kwargs):
1456 return '<DBChange %s>' % self.changesname
1458 def clean_from_queue(self):
1459 session = DBConn().session().object_session(self)
1461 # Remove changes_pool_files entries
1464 # Remove changes_pending_files references
1467 # Clear out of queue
1468 self.in_queue = None
1469 self.approved_for_id = None
1471 __all__.append('DBChange')
1474 def get_dbchange(filename, session=None):
1476 returns DBChange object for given C{filename}.
1478 @type filename: string
1479 @param filename: the name of the file
1481 @type session: Session
1482 @param session: Optional SQLA session object (a temporary one will be
1483 generated if not supplied)
1486 @return: DBChange object for the given filename (C{None} if not present)
1489 q = session.query(DBChange).filter_by(changesname=filename)
1493 except NoResultFound:
1496 __all__.append('get_dbchange')
1498 ################################################################################
1500 class Location(object):
1501 def __init__(self, *args, **kwargs):
1505 return '<Location %s (%s)>' % (self.path, self.location_id)
1507 __all__.append('Location')
1510 def get_location(location, component=None, archive=None, session=None):
1512 Returns Location object for the given combination of location, component
1515 @type location: string
1516 @param location: the path of the location, e.g. I{/srv/ftp-master.debian.org/ftp/pool/}
1518 @type component: string
1519 @param component: the component name (if None, no restriction applied)
1521 @type archive: string
1522 @param archive: the archive name (if None, no restriction applied)
1524 @rtype: Location / None
1525 @return: Either a Location object or None if one can't be found
1528 q = session.query(Location).filter_by(path=location)
1530 if archive is not None:
1531 q = q.join(Archive).filter_by(archive_name=archive)
1533 if component is not None:
1534 q = q.join(Component).filter_by(component_name=component)
1538 except NoResultFound:
1541 __all__.append('get_location')
1543 ################################################################################
1545 class Maintainer(object):
1546 def __init__(self, *args, **kwargs):
1550 return '''<Maintainer '%s' (%s)>''' % (self.name, self.maintainer_id)
1552 def get_split_maintainer(self):
1553 if not hasattr(self, 'name') or self.name is None:
1554 return ('', '', '', '')
1556 return fix_maintainer(self.name.strip())
1558 __all__.append('Maintainer')
1561 def get_or_set_maintainer(name, session=None):
1563 Returns Maintainer object for given maintainer name.
1565 If no matching maintainer name is found, a row is inserted.
1568 @param name: The maintainer name to add
1570 @type session: SQLAlchemy
1571 @param session: Optional SQL session object (a temporary one will be
1572 generated if not supplied). If not passed, a commit will be performed at
1573 the end of the function, otherwise the caller is responsible for commiting.
1574 A flush will be performed either way.
1577 @return: the Maintainer object for the given maintainer
1580 q = session.query(Maintainer).filter_by(name=name)
1583 except NoResultFound:
1584 maintainer = Maintainer()
1585 maintainer.name = name
1586 session.add(maintainer)
1587 session.commit_or_flush()
1592 __all__.append('get_or_set_maintainer')
1595 def get_maintainer(maintainer_id, session=None):
1597 Return the name of the maintainer behind C{maintainer_id} or None if that
1598 maintainer_id is invalid.
1600 @type maintainer_id: int
1601 @param maintainer_id: the id of the maintainer
1604 @return: the Maintainer with this C{maintainer_id}
1607 return session.query(Maintainer).get(maintainer_id)
1609 __all__.append('get_maintainer')
1611 ################################################################################
1613 class NewComment(object):
1614 def __init__(self, *args, **kwargs):
1618 return '''<NewComment for '%s %s' (%s)>''' % (self.package, self.version, self.comment_id)
1620 __all__.append('NewComment')
1623 def has_new_comment(package, version, session=None):
1625 Returns true if the given combination of C{package}, C{version} has a comment.
1627 @type package: string
1628 @param package: name of the package
1630 @type version: string
1631 @param version: package version
1633 @type session: Session
1634 @param session: Optional SQLA session object (a temporary one will be
1635 generated if not supplied)
1641 q = session.query(NewComment)
1642 q = q.filter_by(package=package)
1643 q = q.filter_by(version=version)
1645 return bool(q.count() > 0)
1647 __all__.append('has_new_comment')
1650 def get_new_comments(package=None, version=None, comment_id=None, session=None):
1652 Returns (possibly empty) list of NewComment objects for the given
1655 @type package: string (optional)
1656 @param package: name of the package
1658 @type version: string (optional)
1659 @param version: package version
1661 @type comment_id: int (optional)
1662 @param comment_id: An id of a comment
1664 @type session: Session
1665 @param session: Optional SQLA session object (a temporary one will be
1666 generated if not supplied)
1669 @return: A (possibly empty) list of NewComment objects will be returned
1672 q = session.query(NewComment)
1673 if package is not None: q = q.filter_by(package=package)
1674 if version is not None: q = q.filter_by(version=version)
1675 if comment_id is not None: q = q.filter_by(comment_id=comment_id)
1679 __all__.append('get_new_comments')
1681 ################################################################################
1683 class Override(object):
1684 def __init__(self, *args, **kwargs):
1688 return '<Override %s (%s)>' % (self.package, self.suite_id)
1690 __all__.append('Override')
1693 def get_override(package, suite=None, component=None, overridetype=None, session=None):
1695 Returns Override object for the given parameters
1697 @type package: string
1698 @param package: The name of the package
1700 @type suite: string, list or None
1701 @param suite: The name of the suite (or suites if a list) to limit to. If
1702 None, don't limit. Defaults to None.
1704 @type component: string, list or None
1705 @param component: The name of the component (or components if a list) to
1706 limit to. If None, don't limit. Defaults to None.
1708 @type overridetype: string, list or None
1709 @param overridetype: The name of the overridetype (or overridetypes if a list) to
1710 limit to. If None, don't limit. Defaults to None.
1712 @type session: Session
1713 @param session: Optional SQLA session object (a temporary one will be
1714 generated if not supplied)
1717 @return: A (possibly empty) list of Override objects will be returned
1720 q = session.query(Override)
1721 q = q.filter_by(package=package)
1723 if suite is not None:
1724 if not isinstance(suite, list): suite = [suite]
1725 q = q.join(Suite).filter(Suite.suite_name.in_(suite))
1727 if component is not None:
1728 if not isinstance(component, list): component = [component]
1729 q = q.join(Component).filter(Component.component_name.in_(component))
1731 if overridetype is not None:
1732 if not isinstance(overridetype, list): overridetype = [overridetype]
1733 q = q.join(OverrideType).filter(OverrideType.overridetype.in_(overridetype))
1737 __all__.append('get_override')
1740 ################################################################################
1742 class OverrideType(object):
1743 def __init__(self, *args, **kwargs):
1747 return '<OverrideType %s>' % self.overridetype
1749 __all__.append('OverrideType')
1752 def get_override_type(override_type, session=None):
1754 Returns OverrideType object for given C{override type}.
1756 @type override_type: string
1757 @param override_type: The name of the override type
1759 @type session: Session
1760 @param session: Optional SQLA session object (a temporary one will be
1761 generated if not supplied)
1764 @return: the database id for the given override type
1767 q = session.query(OverrideType).filter_by(overridetype=override_type)
1771 except NoResultFound:
1774 __all__.append('get_override_type')
1776 ################################################################################
1778 class DebContents(object):
1779 def __init__(self, *args, **kwargs):
1783 return '<DebConetnts %s: %s>' % (self.package.package,self.file)
1785 __all__.append('DebContents')
1788 class UdebContents(object):
1789 def __init__(self, *args, **kwargs):
1793 return '<UdebConetnts %s: %s>' % (self.package.package,self.file)
1795 __all__.append('UdebContents')
1797 class PendingBinContents(object):
1798 def __init__(self, *args, **kwargs):
1802 return '<PendingBinContents %s>' % self.contents_id
1804 __all__.append('PendingBinContents')
1806 def insert_pending_content_paths(package,
1811 Make sure given paths are temporarily associated with given
1815 @param package: the package to associate with should have been read in from the binary control file
1816 @type fullpaths: list
1817 @param fullpaths: the list of paths of the file being associated with the binary
1818 @type session: SQLAlchemy session
1819 @param session: Optional SQLAlchemy session. If this is passed, the caller
1820 is responsible for ensuring a transaction has begun and committing the
1821 results or rolling back based on the result code. If not passed, a commit
1822 will be performed at the end of the function
1824 @return: True upon success, False if there is a problem
1827 privatetrans = False
1830 session = DBConn().session()
1834 arch = get_architecture(package['Architecture'], session)
1835 arch_id = arch.arch_id
1837 # Remove any already existing recorded files for this package
1838 q = session.query(PendingBinContents)
1839 q = q.filter_by(package=package['Package'])
1840 q = q.filter_by(version=package['Version'])
1841 q = q.filter_by(architecture=arch_id)
1844 for fullpath in fullpaths:
1846 if fullpath.startswith( "./" ):
1847 fullpath = fullpath[2:]
1849 pca = PendingBinContents()
1850 pca.package = package['Package']
1851 pca.version = package['Version']
1853 pca.architecture = arch_id
1856 pca.type = 8 # gross
1858 pca.type = 7 # also gross
1861 # Only commit if we set up the session ourself
1869 except Exception, e:
1870 traceback.print_exc()
1872 # Only rollback if we set up the session ourself
1879 __all__.append('insert_pending_content_paths')
1881 ################################################################################
1883 class PolicyQueue(object):
1884 def __init__(self, *args, **kwargs):
1888 return '<PolicyQueue %s>' % self.queue_name
1890 __all__.append('PolicyQueue')
1893 def get_policy_queue(queuename, session=None):
1895 Returns PolicyQueue object for given C{queue name}
1897 @type queuename: string
1898 @param queuename: The name of the queue
1900 @type session: Session
1901 @param session: Optional SQLA session object (a temporary one will be
1902 generated if not supplied)
1905 @return: PolicyQueue object for the given queue
1908 q = session.query(PolicyQueue).filter_by(queue_name=queuename)
1912 except NoResultFound:
1915 __all__.append('get_policy_queue')
1918 def get_policy_queue_from_path(pathname, session=None):
1920 Returns PolicyQueue object for given C{path name}
1922 @type queuename: string
1923 @param queuename: The path
1925 @type session: Session
1926 @param session: Optional SQLA session object (a temporary one will be
1927 generated if not supplied)
1930 @return: PolicyQueue object for the given queue
1933 q = session.query(PolicyQueue).filter_by(path=pathname)
1937 except NoResultFound:
1940 __all__.append('get_policy_queue_from_path')
1942 ################################################################################
1944 class Priority(object):
1945 def __init__(self, *args, **kwargs):
1948 def __eq__(self, val):
1949 if isinstance(val, str):
1950 return (self.priority == val)
1951 # This signals to use the normal comparison operator
1952 return NotImplemented
1954 def __ne__(self, val):
1955 if isinstance(val, str):
1956 return (self.priority != val)
1957 # This signals to use the normal comparison operator
1958 return NotImplemented
1961 return '<Priority %s (%s)>' % (self.priority, self.priority_id)
1963 __all__.append('Priority')
1966 def get_priority(priority, session=None):
1968 Returns Priority object for given C{priority name}.
1970 @type priority: string
1971 @param priority: The name of the priority
1973 @type session: Session
1974 @param session: Optional SQLA session object (a temporary one will be
1975 generated if not supplied)
1978 @return: Priority object for the given priority
1981 q = session.query(Priority).filter_by(priority=priority)
1985 except NoResultFound:
1988 __all__.append('get_priority')
1991 def get_priorities(session=None):
1993 Returns dictionary of priority names -> id mappings
1995 @type session: Session
1996 @param session: Optional SQL session object (a temporary one will be
1997 generated if not supplied)
2000 @return: dictionary of priority names -> id mappings
2004 q = session.query(Priority)
2006 ret[x.priority] = x.priority_id
2010 __all__.append('get_priorities')
2012 ################################################################################
2014 class Section(object):
2015 def __init__(self, *args, **kwargs):
2018 def __eq__(self, val):
2019 if isinstance(val, str):
2020 return (self.section == val)
2021 # This signals to use the normal comparison operator
2022 return NotImplemented
2024 def __ne__(self, val):
2025 if isinstance(val, str):
2026 return (self.section != val)
2027 # This signals to use the normal comparison operator
2028 return NotImplemented
2031 return '<Section %s>' % self.section
2033 __all__.append('Section')
2036 def get_section(section, session=None):
2038 Returns Section object for given C{section name}.
2040 @type section: string
2041 @param section: The name of the section
2043 @type session: Session
2044 @param session: Optional SQLA session object (a temporary one will be
2045 generated if not supplied)
2048 @return: Section object for the given section name
2051 q = session.query(Section).filter_by(section=section)
2055 except NoResultFound:
2058 __all__.append('get_section')
2061 def get_sections(session=None):
2063 Returns dictionary of section names -> id mappings
2065 @type session: Session
2066 @param session: Optional SQL session object (a temporary one will be
2067 generated if not supplied)
2070 @return: dictionary of section names -> id mappings
2074 q = session.query(Section)
2076 ret[x.section] = x.section_id
2080 __all__.append('get_sections')
2082 ################################################################################
2084 class DBSource(object):
2085 def __init__(self, *args, **kwargs):
2089 return '<DBSource %s (%s)>' % (self.source, self.version)
2091 __all__.append('DBSource')
2094 def source_exists(source, source_version, suites = ["any"], session=None):
2096 Ensure that source exists somewhere in the archive for the binary
2097 upload being processed.
2098 1. exact match => 1.0-3
2099 2. bin-only NMU => 1.0-3+b1 , 1.0-3.1+b1
2101 @type source: string
2102 @param source: source name
2104 @type source_version: string
2105 @param source_version: expected source version
2108 @param suites: list of suites to check in, default I{any}
2110 @type session: Session
2111 @param session: Optional SQLA session object (a temporary one will be
2112 generated if not supplied)
2115 @return: returns 1 if a source with expected version is found, otherwise 0
2122 for suite in suites:
2123 q = session.query(DBSource).filter_by(source=source)
2125 # source must exist in suite X, or in some other suite that's
2126 # mapped to X, recursively... silent-maps are counted too,
2127 # unreleased-maps aren't.
2128 maps = cnf.ValueList("SuiteMappings")[:]
2130 maps = [ m.split() for m in maps ]
2131 maps = [ (x[1], x[2]) for x in maps
2132 if x[0] == "map" or x[0] == "silent-map" ]
2135 if x[1] in s and x[0] not in s:
2138 q = q.join(SrcAssociation).join(Suite)
2139 q = q.filter(Suite.suite_name.in_(s))
2141 # Reduce the query results to a list of version numbers
2142 ql = [ j.version for j in q.all() ]
2145 if source_version in ql:
2149 from daklib.regexes import re_bin_only_nmu
2150 orig_source_version = re_bin_only_nmu.sub('', source_version)
2151 if orig_source_version in ql:
2154 # No source found so return not ok
2159 __all__.append('source_exists')
2162 def get_suites_source_in(source, session=None):
2164 Returns list of Suite objects which given C{source} name is in
2167 @param source: DBSource package name to search for
2170 @return: list of Suite objects for the given source
2173 return session.query(Suite).join(SrcAssociation).join(DBSource).filter_by(source=source).all()
2175 __all__.append('get_suites_source_in')
2178 def get_sources_from_name(source, version=None, dm_upload_allowed=None, session=None):
2180 Returns list of DBSource objects for given C{source} name and other parameters
2183 @param source: DBSource package name to search for
2185 @type version: str or None
2186 @param version: DBSource version name to search for or None if not applicable
2188 @type dm_upload_allowed: bool
2189 @param dm_upload_allowed: If None, no effect. If True or False, only
2190 return packages with that dm_upload_allowed setting
2192 @type session: Session
2193 @param session: Optional SQL session object (a temporary one will be
2194 generated if not supplied)
2197 @return: list of DBSource objects for the given name (may be empty)
2200 q = session.query(DBSource).filter_by(source=source)
2202 if version is not None:
2203 q = q.filter_by(version=version)
2205 if dm_upload_allowed is not None:
2206 q = q.filter_by(dm_upload_allowed=dm_upload_allowed)
2210 __all__.append('get_sources_from_name')
2213 def get_source_in_suite(source, suite, session=None):
2215 Returns list of DBSource objects for a combination of C{source} and C{suite}.
2217 - B{source} - source package name, eg. I{mailfilter}, I{bbdb}, I{glibc}
2218 - B{suite} - a suite name, eg. I{unstable}
2220 @type source: string
2221 @param source: source package name
2224 @param suite: the suite name
2227 @return: the version for I{source} in I{suite}
2231 q = session.query(SrcAssociation)
2232 q = q.join('source').filter_by(source=source)
2233 q = q.join('suite').filter_by(suite_name=suite)
2236 return q.one().source
2237 except NoResultFound:
2240 __all__.append('get_source_in_suite')
2242 ################################################################################
2245 def add_dsc_to_db(u, filename, session=None):
2246 entry = u.pkg.files[filename]
2250 source.source = u.pkg.dsc["source"]
2251 source.version = u.pkg.dsc["version"] # NB: not files[file]["version"], that has no epoch
2252 source.maintainer_id = get_or_set_maintainer(u.pkg.dsc["maintainer"], session).maintainer_id
2253 source.changedby_id = get_or_set_maintainer(u.pkg.changes["changed-by"], session).maintainer_id
2254 source.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
2255 source.install_date = datetime.now().date()
2257 dsc_component = entry["component"]
2258 dsc_location_id = entry["location id"]
2260 source.dm_upload_allowed = (u.pkg.dsc.get("dm-upload-allowed", '') == "yes")
2262 # Set up a new poolfile if necessary
2263 if not entry.has_key("files id") or not entry["files id"]:
2264 filename = entry["pool name"] + filename
2265 poolfile = add_poolfile(filename, entry, dsc_location_id, session)
2267 pfs.append(poolfile)
2268 entry["files id"] = poolfile.file_id
2270 source.poolfile_id = entry["files id"]
2274 for suite_name in u.pkg.changes["distribution"].keys():
2275 sa = SrcAssociation()
2276 sa.source_id = source.source_id
2277 sa.suite_id = get_suite(suite_name).suite_id
2282 # Add the source files to the DB (files and dsc_files)
2284 dscfile.source_id = source.source_id
2285 dscfile.poolfile_id = entry["files id"]
2286 session.add(dscfile)
2288 for dsc_file, dentry in u.pkg.dsc_files.items():
2290 df.source_id = source.source_id
2292 # If the .orig tarball is already in the pool, it's
2293 # files id is stored in dsc_files by check_dsc().
2294 files_id = dentry.get("files id", None)
2296 # Find the entry in the files hash
2297 # TODO: Bail out here properly
2299 for f, e in u.pkg.files.items():
2304 if files_id is None:
2305 filename = dfentry["pool name"] + dsc_file
2307 (found, obj) = check_poolfile(filename, dentry["size"], dentry["md5sum"], dsc_location_id)
2308 # FIXME: needs to check for -1/-2 and or handle exception
2309 if found and obj is not None:
2310 files_id = obj.file_id
2313 # If still not found, add it
2314 if files_id is None:
2315 # HACK: Force sha1sum etc into dentry
2316 dentry["sha1sum"] = dfentry["sha1sum"]
2317 dentry["sha256sum"] = dfentry["sha256sum"]
2318 poolfile = add_poolfile(filename, dentry, dsc_location_id, session)
2319 pfs.append(poolfile)
2320 files_id = poolfile.file_id
2322 poolfile = get_poolfile_by_id(files_id, session)
2323 if poolfile is None:
2324 utils.fubar("INTERNAL ERROR. Found no poolfile with id %d" % files_id)
2325 pfs.append(poolfile)
2327 df.poolfile_id = files_id
2332 # Add the src_uploaders to the DB
2333 uploader_ids = [source.maintainer_id]
2334 if u.pkg.dsc.has_key("uploaders"):
2335 for up in u.pkg.dsc["uploaders"].replace(">, ", ">\t").split("\t"):
2337 uploader_ids.append(get_or_set_maintainer(up, session).maintainer_id)
2340 for up_id in uploader_ids:
2341 if added_ids.has_key(up_id):
2343 utils.warn("Already saw uploader %s for source %s" % (up_id, source.source))
2349 su.maintainer_id = up_id
2350 su.source_id = source.source_id
2355 return source, dsc_component, dsc_location_id, pfs
2357 __all__.append('add_dsc_to_db')
2360 def add_deb_to_db(u, filename, session=None):
2362 Contrary to what you might expect, this routine deals with both
2363 debs and udebs. That info is in 'dbtype', whilst 'type' is
2364 'deb' for both of them
2367 entry = u.pkg.files[filename]
2370 bin.package = entry["package"]
2371 bin.version = entry["version"]
2372 bin.maintainer_id = get_or_set_maintainer(entry["maintainer"], session).maintainer_id
2373 bin.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
2374 bin.arch_id = get_architecture(entry["architecture"], session).arch_id
2375 bin.binarytype = entry["dbtype"]
2378 filename = entry["pool name"] + filename
2379 fullpath = os.path.join(cnf["Dir::Pool"], filename)
2380 if not entry.get("location id", None):
2381 entry["location id"] = get_location(cnf["Dir::Pool"], entry["component"], session=session).location_id
2383 if entry.get("files id", None):
2384 poolfile = get_poolfile_by_id(bin.poolfile_id)
2385 bin.poolfile_id = entry["files id"]
2387 poolfile = add_poolfile(filename, entry, entry["location id"], session)
2388 bin.poolfile_id = entry["files id"] = poolfile.file_id
2391 bin_sources = get_sources_from_name(entry["source package"], entry["source version"], session=session)
2392 if len(bin_sources) != 1:
2393 raise NoSourceFieldError, "Unable to find a unique source id for %s (%s), %s, file %s, type %s, signed by %s" % \
2394 (bin.package, bin.version, bin.architecture.arch_string,
2395 filename, bin.binarytype, u.pkg.changes["fingerprint"])
2397 bin.source_id = bin_sources[0].source_id
2399 # Add and flush object so it has an ID
2403 # Add BinAssociations
2404 for suite_name in u.pkg.changes["distribution"].keys():
2405 ba = BinAssociation()
2406 ba.binary_id = bin.binary_id
2407 ba.suite_id = get_suite(suite_name).suite_id
2412 # Deal with contents - disabled for now
2413 #contents = copy_temporary_contents(bin.package, bin.version, bin.architecture.arch_string, os.path.basename(filename), None, session)
2415 # print "REJECT\nCould not determine contents of package %s" % bin.package
2416 # session.rollback()
2417 # raise MissingContents, "No contents stored for package %s, and couldn't determine contents of %s" % (bin.package, filename)
2421 __all__.append('add_deb_to_db')
2423 ################################################################################
2425 class SourceACL(object):
2426 def __init__(self, *args, **kwargs):
2430 return '<SourceACL %s>' % self.source_acl_id
2432 __all__.append('SourceACL')
2434 ################################################################################
2436 class SrcAssociation(object):
2437 def __init__(self, *args, **kwargs):
2441 return '<SrcAssociation %s (%s, %s)>' % (self.sa_id, self.source, self.suite)
2443 __all__.append('SrcAssociation')
2445 ################################################################################
2447 class SrcFormat(object):
2448 def __init__(self, *args, **kwargs):
2452 return '<SrcFormat %s>' % (self.format_name)
2454 __all__.append('SrcFormat')
2456 ################################################################################
2458 class SrcUploader(object):
2459 def __init__(self, *args, **kwargs):
2463 return '<SrcUploader %s>' % self.uploader_id
2465 __all__.append('SrcUploader')
2467 ################################################################################
2469 SUITE_FIELDS = [ ('SuiteName', 'suite_name'),
2470 ('SuiteID', 'suite_id'),
2471 ('Version', 'version'),
2472 ('Origin', 'origin'),
2474 ('Description', 'description'),
2475 ('Untouchable', 'untouchable'),
2476 ('Announce', 'announce'),
2477 ('Codename', 'codename'),
2478 ('OverrideCodename', 'overridecodename'),
2479 ('ValidTime', 'validtime'),
2480 ('Priority', 'priority'),
2481 ('NotAutomatic', 'notautomatic'),
2482 ('CopyChanges', 'copychanges'),
2483 ('OverrideSuite', 'overridesuite')]
2485 class Suite(object):
2486 def __init__(self, *args, **kwargs):
2490 return '<Suite %s>' % self.suite_name
2492 def __eq__(self, val):
2493 if isinstance(val, str):
2494 return (self.suite_name == val)
2495 # This signals to use the normal comparison operator
2496 return NotImplemented
2498 def __ne__(self, val):
2499 if isinstance(val, str):
2500 return (self.suite_name != val)
2501 # This signals to use the normal comparison operator
2502 return NotImplemented
2506 for disp, field in SUITE_FIELDS:
2507 val = getattr(self, field, None)
2509 ret.append("%s: %s" % (disp, val))
2511 return "\n".join(ret)
2513 __all__.append('Suite')
2516 def get_suite_architecture(suite, architecture, session=None):
2518 Returns a SuiteArchitecture object given C{suite} and ${arch} or None if it
2522 @param suite: Suite name to search for
2524 @type architecture: str
2525 @param architecture: Architecture name to search for
2527 @type session: Session
2528 @param session: Optional SQL session object (a temporary one will be
2529 generated if not supplied)
2531 @rtype: SuiteArchitecture
2532 @return: the SuiteArchitecture object or None
2535 q = session.query(SuiteArchitecture)
2536 q = q.join(Architecture).filter_by(arch_string=architecture)
2537 q = q.join(Suite).filter_by(suite_name=suite)
2541 except NoResultFound:
2544 __all__.append('get_suite_architecture')
2547 def get_suite(suite, session=None):
2549 Returns Suite object for given C{suite name}.
2552 @param suite: The name of the suite
2554 @type session: Session
2555 @param session: Optional SQLA session object (a temporary one will be
2556 generated if not supplied)
2559 @return: Suite object for the requested suite name (None if not present)
2562 q = session.query(Suite).filter_by(suite_name=suite)
2566 except NoResultFound:
2569 __all__.append('get_suite')
2571 ################################################################################
2573 class SuiteArchitecture(object):
2574 def __init__(self, *args, **kwargs):
2578 return '<SuiteArchitecture (%s, %s)>' % (self.suite_id, self.arch_id)
2580 __all__.append('SuiteArchitecture')
2583 def get_suite_architectures(suite, skipsrc=False, skipall=False, session=None):
2585 Returns list of Architecture objects for given C{suite} name
2588 @param suite: Suite name to search for
2590 @type skipsrc: boolean
2591 @param skipsrc: Whether to skip returning the 'source' architecture entry
2594 @type skipall: boolean
2595 @param skipall: Whether to skip returning the 'all' architecture entry
2598 @type session: Session
2599 @param session: Optional SQL session object (a temporary one will be
2600 generated if not supplied)
2603 @return: list of Architecture objects for the given name (may be empty)
2606 q = session.query(Architecture)
2607 q = q.join(SuiteArchitecture)
2608 q = q.join(Suite).filter_by(suite_name=suite)
2611 q = q.filter(Architecture.arch_string != 'source')
2614 q = q.filter(Architecture.arch_string != 'all')
2616 q = q.order_by('arch_string')
2620 __all__.append('get_suite_architectures')
2622 ################################################################################
2624 class SuiteSrcFormat(object):
2625 def __init__(self, *args, **kwargs):
2629 return '<SuiteSrcFormat (%s, %s)>' % (self.suite_id, self.src_format_id)
2631 __all__.append('SuiteSrcFormat')
2634 def get_suite_src_formats(suite, session=None):
2636 Returns list of allowed SrcFormat for C{suite}.
2639 @param suite: Suite name to search for
2641 @type session: Session
2642 @param session: Optional SQL session object (a temporary one will be
2643 generated if not supplied)
2646 @return: the list of allowed source formats for I{suite}
2649 q = session.query(SrcFormat)
2650 q = q.join(SuiteSrcFormat)
2651 q = q.join(Suite).filter_by(suite_name=suite)
2652 q = q.order_by('format_name')
2656 __all__.append('get_suite_src_formats')
2658 ################################################################################
2661 def __init__(self, *args, **kwargs):
2664 def __eq__(self, val):
2665 if isinstance(val, str):
2666 return (self.uid == val)
2667 # This signals to use the normal comparison operator
2668 return NotImplemented
2670 def __ne__(self, val):
2671 if isinstance(val, str):
2672 return (self.uid != val)
2673 # This signals to use the normal comparison operator
2674 return NotImplemented
2677 return '<Uid %s (%s)>' % (self.uid, self.name)
2679 __all__.append('Uid')
2682 def get_or_set_uid(uidname, session=None):
2684 Returns uid object for given uidname.
2686 If no matching uidname is found, a row is inserted.
2688 @type uidname: string
2689 @param uidname: The uid to add
2691 @type session: SQLAlchemy
2692 @param session: Optional SQL session object (a temporary one will be
2693 generated if not supplied). If not passed, a commit will be performed at
2694 the end of the function, otherwise the caller is responsible for commiting.
2697 @return: the uid object for the given uidname
2700 q = session.query(Uid).filter_by(uid=uidname)
2704 except NoResultFound:
2708 session.commit_or_flush()
2713 __all__.append('get_or_set_uid')
2716 def get_uid_from_fingerprint(fpr, session=None):
2717 q = session.query(Uid)
2718 q = q.join(Fingerprint).filter_by(fingerprint=fpr)
2722 except NoResultFound:
2725 __all__.append('get_uid_from_fingerprint')
2727 ################################################################################
2729 class UploadBlock(object):
2730 def __init__(self, *args, **kwargs):
2734 return '<UploadBlock %s (%s)>' % (self.source, self.upload_block_id)
2736 __all__.append('UploadBlock')
2738 ################################################################################
2740 class DBConn(object):
2742 database module init.
2746 def __init__(self, *args, **kwargs):
2747 self.__dict__ = self.__shared_state
2749 if not getattr(self, 'initialised', False):
2750 self.initialised = True
2751 self.debug = kwargs.has_key('debug')
2754 def __setuptables(self):
2764 'build_queue_files',
2767 'changes_pending_binaries',
2768 'changes_pending_files',
2769 'changes_pending_files_map',
2770 'changes_pending_source',
2771 'changes_pending_source_files',
2772 'changes_pool_files',
2785 'pending_bin_contents',
2795 'suite_architectures',
2796 'suite_src_formats',
2797 'suite_build_queue_copy',
2803 for table_name in tables:
2804 table = Table(table_name, self.db_meta, autoload=True)
2805 setattr(self, 'tbl_%s' % table_name, table)
2807 def __setupmappers(self):
2808 mapper(Architecture, self.tbl_architecture,
2809 properties = dict(arch_id = self.tbl_architecture.c.id))
2811 mapper(Archive, self.tbl_archive,
2812 properties = dict(archive_id = self.tbl_archive.c.id,
2813 archive_name = self.tbl_archive.c.name))
2815 mapper(BinAssociation, self.tbl_bin_associations,
2816 properties = dict(ba_id = self.tbl_bin_associations.c.id,
2817 suite_id = self.tbl_bin_associations.c.suite,
2818 suite = relation(Suite),
2819 binary_id = self.tbl_bin_associations.c.bin,
2820 binary = relation(DBBinary)))
2822 mapper(PendingBinContents, self.tbl_pending_bin_contents,
2823 properties = dict(contents_id =self.tbl_pending_bin_contents.c.id,
2824 filename = self.tbl_pending_bin_contents.c.filename,
2825 package = self.tbl_pending_bin_contents.c.package,
2826 version = self.tbl_pending_bin_contents.c.version,
2827 arch = self.tbl_pending_bin_contents.c.arch,
2828 otype = self.tbl_pending_bin_contents.c.type))
2830 mapper(DebContents, self.tbl_deb_contents,
2831 properties = dict(binary_id=self.tbl_deb_contents.c.binary_id,
2832 package=self.tbl_deb_contents.c.package,
2833 suite=self.tbl_deb_contents.c.suite,
2834 arch=self.tbl_deb_contents.c.arch,
2835 section=self.tbl_deb_contents.c.section,
2836 filename=self.tbl_deb_contents.c.filename))
2838 mapper(UdebContents, self.tbl_udeb_contents,
2839 properties = dict(binary_id=self.tbl_udeb_contents.c.binary_id,
2840 package=self.tbl_udeb_contents.c.package,
2841 suite=self.tbl_udeb_contents.c.suite,
2842 arch=self.tbl_udeb_contents.c.arch,
2843 section=self.tbl_udeb_contents.c.section,
2844 filename=self.tbl_udeb_contents.c.filename))
2846 mapper(BuildQueue, self.tbl_build_queue,
2847 properties = dict(queue_id = self.tbl_build_queue.c.id))
2849 mapper(BuildQueueFile, self.tbl_build_queue_files,
2850 properties = dict(buildqueue = relation(BuildQueue, backref='queuefiles'),
2851 poolfile = relation(PoolFile, backref='buildqueueinstances')))
2853 mapper(DBBinary, self.tbl_binaries,
2854 properties = dict(binary_id = self.tbl_binaries.c.id,
2855 package = self.tbl_binaries.c.package,
2856 version = self.tbl_binaries.c.version,
2857 maintainer_id = self.tbl_binaries.c.maintainer,
2858 maintainer = relation(Maintainer),
2859 source_id = self.tbl_binaries.c.source,
2860 source = relation(DBSource),
2861 arch_id = self.tbl_binaries.c.architecture,
2862 architecture = relation(Architecture),
2863 poolfile_id = self.tbl_binaries.c.file,
2864 poolfile = relation(PoolFile),
2865 binarytype = self.tbl_binaries.c.type,
2866 fingerprint_id = self.tbl_binaries.c.sig_fpr,
2867 fingerprint = relation(Fingerprint),
2868 install_date = self.tbl_binaries.c.install_date,
2869 binassociations = relation(BinAssociation,
2870 primaryjoin=(self.tbl_binaries.c.id==self.tbl_bin_associations.c.bin))))
2872 mapper(BinaryACL, self.tbl_binary_acl,
2873 properties = dict(binary_acl_id = self.tbl_binary_acl.c.id))
2875 mapper(BinaryACLMap, self.tbl_binary_acl_map,
2876 properties = dict(binary_acl_map_id = self.tbl_binary_acl_map.c.id,
2877 fingerprint = relation(Fingerprint, backref="binary_acl_map"),
2878 architecture = relation(Architecture)))
2880 mapper(Component, self.tbl_component,
2881 properties = dict(component_id = self.tbl_component.c.id,
2882 component_name = self.tbl_component.c.name))
2884 mapper(DBConfig, self.tbl_config,
2885 properties = dict(config_id = self.tbl_config.c.id))
2887 mapper(DSCFile, self.tbl_dsc_files,
2888 properties = dict(dscfile_id = self.tbl_dsc_files.c.id,
2889 source_id = self.tbl_dsc_files.c.source,
2890 source = relation(DBSource),
2891 poolfile_id = self.tbl_dsc_files.c.file,
2892 poolfile = relation(PoolFile)))
2894 mapper(PoolFile, self.tbl_files,
2895 properties = dict(file_id = self.tbl_files.c.id,
2896 filesize = self.tbl_files.c.size,
2897 location_id = self.tbl_files.c.location,
2898 location = relation(Location)))
2900 mapper(Fingerprint, self.tbl_fingerprint,
2901 properties = dict(fingerprint_id = self.tbl_fingerprint.c.id,
2902 uid_id = self.tbl_fingerprint.c.uid,
2903 uid = relation(Uid),
2904 keyring_id = self.tbl_fingerprint.c.keyring,
2905 keyring = relation(Keyring),
2906 source_acl = relation(SourceACL),
2907 binary_acl = relation(BinaryACL)))
2909 mapper(Keyring, self.tbl_keyrings,
2910 properties = dict(keyring_name = self.tbl_keyrings.c.name,
2911 keyring_id = self.tbl_keyrings.c.id))
2913 mapper(DBChange, self.tbl_changes,
2914 properties = dict(change_id = self.tbl_changes.c.id,
2915 poolfiles = relation(PoolFile,
2916 secondary=self.tbl_changes_pool_files,
2917 backref="changeslinks"),
2918 seen = self.tbl_changes.c.seen,
2919 source = self.tbl_changes.c.source,
2920 binaries = self.tbl_changes.c.binaries,
2921 architecture = self.tbl_changes.c.architecture,
2922 distribution = self.tbl_changes.c.distribution,
2923 urgency = self.tbl_changes.c.urgency,
2924 maintainer = self.tbl_changes.c.maintainer,
2925 changedby = self.tbl_changes.c.changedby,
2926 date = self.tbl_changes.c.date,
2927 version = self.tbl_changes.c.version,
2928 files = relation(ChangePendingFile,
2929 secondary=self.tbl_changes_pending_files_map,
2930 backref="changesfile"),
2931 in_queue_id = self.tbl_changes.c.in_queue,
2932 in_queue = relation(PolicyQueue,
2933 primaryjoin=(self.tbl_changes.c.in_queue==self.tbl_policy_queue.c.id)),
2934 approved_for_id = self.tbl_changes.c.approved_for))
2936 mapper(ChangePendingBinary, self.tbl_changes_pending_binaries,
2937 properties = dict(change_pending_binary_id = self.tbl_changes_pending_binaries.c.id))
2939 mapper(ChangePendingFile, self.tbl_changes_pending_files,
2940 properties = dict(change_pending_file_id = self.tbl_changes_pending_files.c.id,
2941 filename = self.tbl_changes_pending_files.c.filename,
2942 size = self.tbl_changes_pending_files.c.size,
2943 md5sum = self.tbl_changes_pending_files.c.md5sum,
2944 sha1sum = self.tbl_changes_pending_files.c.sha1sum,
2945 sha256sum = self.tbl_changes_pending_files.c.sha256sum))
2947 mapper(ChangePendingSource, self.tbl_changes_pending_source,
2948 properties = dict(change_pending_source_id = self.tbl_changes_pending_source.c.id,
2949 change = relation(DBChange),
2950 maintainer = relation(Maintainer,
2951 primaryjoin=(self.tbl_changes_pending_source.c.maintainer_id==self.tbl_maintainer.c.id)),
2952 changedby = relation(Maintainer,
2953 primaryjoin=(self.tbl_changes_pending_source.c.changedby_id==self.tbl_maintainer.c.id)),
2954 fingerprint = relation(Fingerprint),
2955 source_files = relation(ChangePendingFile,
2956 secondary=self.tbl_changes_pending_source_files,
2957 backref="pending_sources")))
2960 mapper(KeyringACLMap, self.tbl_keyring_acl_map,
2961 properties = dict(keyring_acl_map_id = self.tbl_keyring_acl_map.c.id,
2962 keyring = relation(Keyring, backref="keyring_acl_map"),
2963 architecture = relation(Architecture)))
2965 mapper(Location, self.tbl_location,
2966 properties = dict(location_id = self.tbl_location.c.id,
2967 component_id = self.tbl_location.c.component,
2968 component = relation(Component),
2969 archive_id = self.tbl_location.c.archive,
2970 archive = relation(Archive),
2971 archive_type = self.tbl_location.c.type))
2973 mapper(Maintainer, self.tbl_maintainer,
2974 properties = dict(maintainer_id = self.tbl_maintainer.c.id))
2976 mapper(NewComment, self.tbl_new_comments,
2977 properties = dict(comment_id = self.tbl_new_comments.c.id))
2979 mapper(Override, self.tbl_override,
2980 properties = dict(suite_id = self.tbl_override.c.suite,
2981 suite = relation(Suite),
2982 package = self.tbl_override.c.package,
2983 component_id = self.tbl_override.c.component,
2984 component = relation(Component),
2985 priority_id = self.tbl_override.c.priority,
2986 priority = relation(Priority),
2987 section_id = self.tbl_override.c.section,
2988 section = relation(Section),
2989 overridetype_id = self.tbl_override.c.type,
2990 overridetype = relation(OverrideType)))
2992 mapper(OverrideType, self.tbl_override_type,
2993 properties = dict(overridetype = self.tbl_override_type.c.type,
2994 overridetype_id = self.tbl_override_type.c.id))
2996 mapper(PolicyQueue, self.tbl_policy_queue,
2997 properties = dict(policy_queue_id = self.tbl_policy_queue.c.id))
2999 mapper(Priority, self.tbl_priority,
3000 properties = dict(priority_id = self.tbl_priority.c.id))
3002 mapper(Section, self.tbl_section,
3003 properties = dict(section_id = self.tbl_section.c.id,
3004 section=self.tbl_section.c.section))
3006 mapper(DBSource, self.tbl_source,
3007 properties = dict(source_id = self.tbl_source.c.id,
3008 version = self.tbl_source.c.version,
3009 maintainer_id = self.tbl_source.c.maintainer,
3010 maintainer = relation(Maintainer,
3011 primaryjoin=(self.tbl_source.c.maintainer==self.tbl_maintainer.c.id)),
3012 poolfile_id = self.tbl_source.c.file,
3013 poolfile = relation(PoolFile),
3014 fingerprint_id = self.tbl_source.c.sig_fpr,
3015 fingerprint = relation(Fingerprint),
3016 changedby_id = self.tbl_source.c.changedby,
3017 changedby = relation(Maintainer,
3018 primaryjoin=(self.tbl_source.c.changedby==self.tbl_maintainer.c.id)),
3019 srcfiles = relation(DSCFile,
3020 primaryjoin=(self.tbl_source.c.id==self.tbl_dsc_files.c.source)),
3021 srcassociations = relation(SrcAssociation,
3022 primaryjoin=(self.tbl_source.c.id==self.tbl_src_associations.c.source)),
3023 srcuploaders = relation(SrcUploader)))
3025 mapper(SourceACL, self.tbl_source_acl,
3026 properties = dict(source_acl_id = self.tbl_source_acl.c.id))
3028 mapper(SrcAssociation, self.tbl_src_associations,
3029 properties = dict(sa_id = self.tbl_src_associations.c.id,
3030 suite_id = self.tbl_src_associations.c.suite,
3031 suite = relation(Suite),
3032 source_id = self.tbl_src_associations.c.source,
3033 source = relation(DBSource)))
3035 mapper(SrcFormat, self.tbl_src_format,
3036 properties = dict(src_format_id = self.tbl_src_format.c.id,
3037 format_name = self.tbl_src_format.c.format_name))
3039 mapper(SrcUploader, self.tbl_src_uploaders,
3040 properties = dict(uploader_id = self.tbl_src_uploaders.c.id,
3041 source_id = self.tbl_src_uploaders.c.source,
3042 source = relation(DBSource,
3043 primaryjoin=(self.tbl_src_uploaders.c.source==self.tbl_source.c.id)),
3044 maintainer_id = self.tbl_src_uploaders.c.maintainer,
3045 maintainer = relation(Maintainer,
3046 primaryjoin=(self.tbl_src_uploaders.c.maintainer==self.tbl_maintainer.c.id))))
3048 mapper(Suite, self.tbl_suite,
3049 properties = dict(suite_id = self.tbl_suite.c.id,
3050 policy_queue = relation(PolicyQueue),
3051 copy_queues = relation(BuildQueue, secondary=self.tbl_suite_build_queue_copy)))
3053 mapper(SuiteArchitecture, self.tbl_suite_architectures,
3054 properties = dict(suite_id = self.tbl_suite_architectures.c.suite,
3055 suite = relation(Suite, backref='suitearchitectures'),
3056 arch_id = self.tbl_suite_architectures.c.architecture,
3057 architecture = relation(Architecture)))
3059 mapper(SuiteSrcFormat, self.tbl_suite_src_formats,
3060 properties = dict(suite_id = self.tbl_suite_src_formats.c.suite,
3061 suite = relation(Suite, backref='suitesrcformats'),
3062 src_format_id = self.tbl_suite_src_formats.c.src_format,
3063 src_format = relation(SrcFormat)))
3065 mapper(Uid, self.tbl_uid,
3066 properties = dict(uid_id = self.tbl_uid.c.id,
3067 fingerprint = relation(Fingerprint)))
3069 mapper(UploadBlock, self.tbl_upload_blocks,
3070 properties = dict(upload_block_id = self.tbl_upload_blocks.c.id,
3071 fingerprint = relation(Fingerprint, backref="uploadblocks"),
3072 uid = relation(Uid, backref="uploadblocks")))
3074 ## Connection functions
3075 def __createconn(self):
3076 from config import Config
3080 connstr = "postgres://%s" % cnf["DB::Host"]
3081 if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
3082 connstr += ":%s" % cnf["DB::Port"]
3083 connstr += "/%s" % cnf["DB::Name"]
3086 connstr = "postgres:///%s" % cnf["DB::Name"]
3087 if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
3088 connstr += "?port=%s" % cnf["DB::Port"]
3090 self.db_pg = create_engine(connstr, echo=self.debug)
3091 self.db_meta = MetaData()
3092 self.db_meta.bind = self.db_pg
3093 self.db_smaker = sessionmaker(bind=self.db_pg,
3097 self.__setuptables()
3098 self.__setupmappers()
3101 return self.db_smaker()
3103 __all__.append('DBConn')