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 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 ################################################################################
40 from datetime import datetime, timedelta
41 from errno import ENOENT
42 from tempfile import mkstemp, mkdtemp
44 from inspect import getargspec
47 from sqlalchemy import create_engine, Table, MetaData
48 from sqlalchemy.orm import sessionmaker, mapper, relation
49 from sqlalchemy import types as sqltypes
51 # Don't remove this, we re-export the exceptions to scripts which import us
52 from sqlalchemy.exc import *
53 from sqlalchemy.orm.exc import NoResultFound
55 from config import Config
56 from textutils import fix_maintainer
58 ################################################################################
60 # Patch in support for the debversion field type so that it works during
63 class DebVersion(sqltypes.Text):
64 def get_col_spec(self):
67 sa_major_version = sqlalchemy.__version__[0:3]
68 if sa_major_version == "0.5":
69 from sqlalchemy.databases import postgres
70 postgres.ischema_names['debversion'] = DebVersion
72 raise Exception("dak isn't ported to SQLA versions != 0.5 yet. See daklib/dbconn.py")
74 ################################################################################
76 __all__ = ['IntegrityError', 'SQLAlchemyError']
78 ################################################################################
80 def session_wrapper(fn):
82 Wrapper around common ".., session=None):" handling. If the wrapped
83 function is called without passing 'session', we create a local one
84 and destroy it when the function ends.
86 Also attaches a commit_or_flush method to the session; if we created a
87 local session, this is a synonym for session.commit(), otherwise it is a
88 synonym for session.flush().
91 def wrapped(*args, **kwargs):
92 private_transaction = False
94 # Find the session object
95 session = kwargs.get('session')
98 if len(args) <= len(getargspec(fn)[0]) - 1:
99 # No session specified as last argument or in kwargs
100 private_transaction = True
101 session = kwargs['session'] = DBConn().session()
103 # Session is last argument in args
107 session = args[-1] = DBConn().session()
108 private_transaction = True
110 if private_transaction:
111 session.commit_or_flush = session.commit
113 session.commit_or_flush = session.flush
116 return fn(*args, **kwargs)
118 if private_transaction:
119 # We created a session; close it.
122 wrapped.__doc__ = fn.__doc__
123 wrapped.func_name = fn.func_name
127 __all__.append('session_wrapper')
129 ################################################################################
131 class Architecture(object):
132 def __init__(self, *args, **kwargs):
135 def __eq__(self, val):
136 if isinstance(val, str):
137 return (self.arch_string== val)
138 # This signals to use the normal comparison operator
139 return NotImplemented
141 def __ne__(self, val):
142 if isinstance(val, str):
143 return (self.arch_string != val)
144 # This signals to use the normal comparison operator
145 return NotImplemented
148 return '<Architecture %s>' % self.arch_string
150 __all__.append('Architecture')
153 def get_architecture(architecture, session=None):
155 Returns database id for given C{architecture}.
157 @type architecture: string
158 @param architecture: The name of the architecture
160 @type session: Session
161 @param session: Optional SQLA session object (a temporary one will be
162 generated if not supplied)
165 @return: Architecture object for the given arch (None if not present)
168 q = session.query(Architecture).filter_by(arch_string=architecture)
172 except NoResultFound:
175 __all__.append('get_architecture')
178 def get_architecture_suites(architecture, session=None):
180 Returns list of Suite objects for given C{architecture} name
183 @param source: Architecture name to search for
185 @type session: Session
186 @param session: Optional SQL session object (a temporary one will be
187 generated if not supplied)
190 @return: list of Suite objects for the given name (may be empty)
193 q = session.query(Suite)
194 q = q.join(SuiteArchitecture)
195 q = q.join(Architecture).filter_by(arch_string=architecture).order_by('suite_name')
201 __all__.append('get_architecture_suites')
203 ################################################################################
205 class Archive(object):
206 def __init__(self, *args, **kwargs):
210 return '<Archive %s>' % self.archive_name
212 __all__.append('Archive')
215 def get_archive(archive, session=None):
217 returns database id for given C{archive}.
219 @type archive: string
220 @param archive: the name of the arhive
222 @type session: Session
223 @param session: Optional SQLA session object (a temporary one will be
224 generated if not supplied)
227 @return: Archive object for the given name (None if not present)
230 archive = archive.lower()
232 q = session.query(Archive).filter_by(archive_name=archive)
236 except NoResultFound:
239 __all__.append('get_archive')
241 ################################################################################
243 class BinAssociation(object):
244 def __init__(self, *args, **kwargs):
248 return '<BinAssociation %s (%s, %s)>' % (self.ba_id, self.binary, self.suite)
250 __all__.append('BinAssociation')
252 ################################################################################
254 class BinContents(object):
255 def __init__(self, *args, **kwargs):
259 return '<BinContents (%s, %s)>' % (self.binary, self.filename)
261 __all__.append('BinContents')
263 ################################################################################
265 class DBBinary(object):
266 def __init__(self, *args, **kwargs):
270 return '<DBBinary %s (%s, %s)>' % (self.package, self.version, self.architecture)
272 __all__.append('DBBinary')
275 def get_suites_binary_in(package, session=None):
277 Returns list of Suite objects which given C{package} name is in
280 @param source: DBBinary package name to search for
283 @return: list of Suite objects for the given package
286 return session.query(Suite).join(BinAssociation).join(DBBinary).filter_by(package=package).all()
288 __all__.append('get_suites_binary_in')
291 def get_binary_from_id(binary_id, session=None):
293 Returns DBBinary object for given C{id}
296 @param binary_id: Id of the required binary
298 @type session: Session
299 @param session: Optional SQLA session object (a temporary one will be
300 generated if not supplied)
303 @return: DBBinary object for the given binary (None if not present)
306 q = session.query(DBBinary).filter_by(binary_id=binary_id)
310 except NoResultFound:
313 __all__.append('get_binary_from_id')
316 def get_binaries_from_name(package, version=None, architecture=None, session=None):
318 Returns list of DBBinary objects for given C{package} name
321 @param package: DBBinary package name to search for
323 @type version: str or None
324 @param version: Version to search for (or None)
326 @type package: str, list or None
327 @param package: Architectures to limit to (or None if no limit)
329 @type session: Session
330 @param session: Optional SQL session object (a temporary one will be
331 generated if not supplied)
334 @return: list of DBBinary objects for the given name (may be empty)
337 q = session.query(DBBinary).filter_by(package=package)
339 if version is not None:
340 q = q.filter_by(version=version)
342 if architecture is not None:
343 if not isinstance(architecture, list):
344 architecture = [architecture]
345 q = q.join(Architecture).filter(Architecture.arch_string.in_(architecture))
351 __all__.append('get_binaries_from_name')
354 def get_binaries_from_source_id(source_id, session=None):
356 Returns list of DBBinary objects for given C{source_id}
359 @param source_id: source_id to search for
361 @type session: Session
362 @param session: Optional SQL session object (a temporary one will be
363 generated if not supplied)
366 @return: list of DBBinary objects for the given name (may be empty)
369 return session.query(DBBinary).filter_by(source_id=source_id).all()
371 __all__.append('get_binaries_from_source_id')
374 def get_binary_from_name_suite(package, suitename, session=None):
375 ### For dak examine-package
376 ### XXX: Doesn't use object API yet
378 sql = """SELECT DISTINCT(b.package), b.version, c.name, su.suite_name
379 FROM binaries b, files fi, location l, component c, bin_associations ba, suite su
380 WHERE b.package='%(package)s'
382 AND fi.location = l.id
383 AND l.component = c.id
386 AND su.suite_name %(suitename)s
387 ORDER BY b.version DESC"""
389 return session.execute(sql % {'package': package, 'suitename': suitename})
391 __all__.append('get_binary_from_name_suite')
394 def get_binary_components(package, suitename, arch, session=None):
395 # Check for packages that have moved from one component to another
396 query = """SELECT c.name FROM binaries b, bin_associations ba, suite s, location l, component c, architecture a, files f
397 WHERE b.package=:package AND s.suite_name=:suitename
398 AND (a.arch_string = :arch OR a.arch_string = 'all')
399 AND ba.bin = b.id AND ba.suite = s.id AND b.architecture = a.id
400 AND f.location = l.id
401 AND l.component = c.id
404 vals = {'package': package, 'suitename': suitename, 'arch': arch}
406 return session.execute(query, vals)
408 __all__.append('get_binary_components')
410 ################################################################################
412 class BinaryACL(object):
413 def __init__(self, *args, **kwargs):
417 return '<BinaryACL %s>' % self.binary_acl_id
419 __all__.append('BinaryACL')
421 ################################################################################
423 class BinaryACLMap(object):
424 def __init__(self, *args, **kwargs):
428 return '<BinaryACLMap %s>' % self.binary_acl_map_id
430 __all__.append('BinaryACLMap')
432 ################################################################################
437 ArchiveDir "%(archivepath)s";
438 OverrideDir "/srv/ftp.debian.org/scripts/override/";
439 CacheDir "/srv/ftp.debian.org/database/";
444 Packages::Compress ". bzip2 gzip";
445 Sources::Compress ". bzip2 gzip";
450 bindirectory "incoming"
455 BinOverride "override.sid.all3";
456 BinCacheDB "packages-accepted.db";
458 FileList "%(filelist)s";
461 Packages::Extensions ".deb .udeb";
464 bindirectory "incoming/"
467 BinOverride "override.sid.all3";
468 SrcOverride "override.sid.all3.src";
469 FileList "%(filelist)s";
473 class BuildQueue(object):
474 def __init__(self, *args, **kwargs):
478 return '<BuildQueue %s>' % self.queue_name
480 def write_metadata(self, starttime, force=False):
481 # Do we write out metafiles?
482 if not (force or self.generate_metadata):
485 session = DBConn().session().object_session(self)
487 fl_fd = fl_name = ac_fd = ac_name = None
489 arches = " ".join([ a.arch_string for a in session.query(Architecture).all() if a.arch_string != 'source' ])
490 startdir = os.getcwd()
493 # Grab files we want to include
494 newer = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter(BuildQueueFile.lastused + timedelta(seconds=self.stay_of_execution) > starttime).all()
495 # Write file list with newer files
496 (fl_fd, fl_name) = mkstemp()
498 os.write(fl_fd, '%s\n' % n.fullpath)
501 # Write minimal apt.conf
502 # TODO: Remove hardcoding from template
503 (ac_fd, ac_name) = mkstemp()
504 os.write(ac_fd, MINIMAL_APT_CONF % {'archivepath': self.path,
505 'filelist': fl_name})
508 # Run apt-ftparchive generate
509 os.chdir(os.path.dirname(ac_name))
510 os.system('apt-ftparchive -qq -o APT::FTPArchive::Contents=off generate %s' % os.path.basename(ac_name))
512 # Run apt-ftparchive release
513 # TODO: Eww - fix this
514 bname = os.path.basename(self.path)
518 # We have to remove the Release file otherwise it'll be included in the
521 os.unlink(os.path.join(bname, 'Release'))
525 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))
530 keyring = "--secret-keyring \"%s\"" % cnf["Dinstall::SigningKeyring"]
531 if cnf.has_key("Dinstall::SigningPubKeyring"):
532 keyring += " --keyring \"%s\"" % cnf["Dinstall::SigningPubKeyring"]
534 os.system("gpg %s --no-options --batch --no-tty --armour --default-key %s --detach-sign -o Release.gpg Release""" % (keyring, self.signingkey))
536 # Move the files if we got this far
537 os.rename('Release', os.path.join(bname, 'Release'))
539 os.rename('Release.gpg', os.path.join(bname, 'Release.gpg'))
541 # Clean up any left behind files
568 def clean_and_update(self, starttime, Logger, dryrun=False):
569 """WARNING: This routine commits for you"""
570 session = DBConn().session().object_session(self)
572 if self.generate_metadata and not dryrun:
573 self.write_metadata(starttime)
575 # Grab files older than our execution time
576 older = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter(BuildQueueFile.lastused + timedelta(seconds=self.stay_of_execution) <= starttime).all()
582 Logger.log(["I: Would have removed %s from the queue" % o.fullpath])
584 Logger.log(["I: Removing %s from the queue" % o.fullpath])
585 os.unlink(o.fullpath)
588 # If it wasn't there, don't worry
589 if e.errno == ENOENT:
592 # TODO: Replace with proper logging call
593 Logger.log(["E: Could not remove %s" % o.fullpath])
600 for f in os.listdir(self.path):
601 if f.startswith('Packages') or f.startswith('Source') or f.startswith('Release'):
605 r = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter_by(filename = f).one()
606 except NoResultFound:
607 fp = os.path.join(self.path, f)
609 Logger.log(["I: Would remove unused link %s" % fp])
611 Logger.log(["I: Removing unused link %s" % fp])
615 Logger.log(["E: Failed to unlink unreferenced file %s" % r.fullpath])
617 def add_file_from_pool(self, poolfile):
618 """Copies a file into the pool. Assumes that the PoolFile object is
619 attached to the same SQLAlchemy session as the Queue object is.
621 The caller is responsible for committing after calling this function."""
622 poolfile_basename = poolfile.filename[poolfile.filename.rindex(os.sep)+1:]
624 # Check if we have a file of this name or this ID already
625 for f in self.queuefiles:
626 if f.fileid is not None and f.fileid == poolfile.file_id or \
627 f.poolfile.filename == poolfile_basename:
628 # In this case, update the BuildQueueFile entry so we
629 # don't remove it too early
630 f.lastused = datetime.now()
631 DBConn().session().object_session(poolfile).add(f)
634 # Prepare BuildQueueFile object
635 qf = BuildQueueFile()
636 qf.build_queue_id = self.queue_id
637 qf.lastused = datetime.now()
638 qf.filename = poolfile_basename
640 targetpath = poolfile.fullpath
641 queuepath = os.path.join(self.path, poolfile_basename)
645 # We need to copy instead of symlink
647 utils.copy(targetpath, queuepath)
648 # NULL in the fileid field implies a copy
651 os.symlink(targetpath, queuepath)
652 qf.fileid = poolfile.file_id
656 # Get the same session as the PoolFile is using and add the qf to it
657 DBConn().session().object_session(poolfile).add(qf)
662 __all__.append('BuildQueue')
665 def get_build_queue(queuename, session=None):
667 Returns BuildQueue object for given C{queue name}, creating it if it does not
670 @type queuename: string
671 @param queuename: The name of the queue
673 @type session: Session
674 @param session: Optional SQLA session object (a temporary one will be
675 generated if not supplied)
678 @return: BuildQueue object for the given queue
681 q = session.query(BuildQueue).filter_by(queue_name=queuename)
685 except NoResultFound:
688 __all__.append('get_build_queue')
690 ################################################################################
692 class BuildQueueFile(object):
693 def __init__(self, *args, **kwargs):
697 return '<BuildQueueFile %s (%s)>' % (self.filename, self.build_queue_id)
701 return os.path.join(self.buildqueue.path, self.filename)
704 __all__.append('BuildQueueFile')
706 ################################################################################
708 class ChangePendingBinary(object):
709 def __init__(self, *args, **kwargs):
713 return '<ChangePendingBinary %s>' % self.change_pending_binary_id
715 __all__.append('ChangePendingBinary')
717 ################################################################################
719 class ChangePendingFile(object):
720 def __init__(self, *args, **kwargs):
724 return '<ChangePendingFile %s>' % self.change_pending_file_id
726 __all__.append('ChangePendingFile')
728 ################################################################################
730 class ChangePendingSource(object):
731 def __init__(self, *args, **kwargs):
735 return '<ChangePendingSource %s>' % self.change_pending_source_id
737 __all__.append('ChangePendingSource')
739 ################################################################################
741 class Component(object):
742 def __init__(self, *args, **kwargs):
745 def __eq__(self, val):
746 if isinstance(val, str):
747 return (self.component_name == val)
748 # This signals to use the normal comparison operator
749 return NotImplemented
751 def __ne__(self, val):
752 if isinstance(val, str):
753 return (self.component_name != val)
754 # This signals to use the normal comparison operator
755 return NotImplemented
758 return '<Component %s>' % self.component_name
761 __all__.append('Component')
764 def get_component(component, session=None):
766 Returns database id for given C{component}.
768 @type component: string
769 @param component: The name of the override type
772 @return: the database id for the given component
775 component = component.lower()
777 q = session.query(Component).filter_by(component_name=component)
781 except NoResultFound:
784 __all__.append('get_component')
786 ################################################################################
788 class DBConfig(object):
789 def __init__(self, *args, **kwargs):
793 return '<DBConfig %s>' % self.name
795 __all__.append('DBConfig')
797 ################################################################################
800 def get_or_set_contents_file_id(filename, session=None):
802 Returns database id for given filename.
804 If no matching file is found, a row is inserted.
806 @type filename: string
807 @param filename: The filename
808 @type session: SQLAlchemy
809 @param session: Optional SQL session object (a temporary one will be
810 generated if not supplied). If not passed, a commit will be performed at
811 the end of the function, otherwise the caller is responsible for commiting.
814 @return: the database id for the given component
817 q = session.query(ContentFilename).filter_by(filename=filename)
820 ret = q.one().cafilename_id
821 except NoResultFound:
822 cf = ContentFilename()
823 cf.filename = filename
825 session.commit_or_flush()
826 ret = cf.cafilename_id
830 __all__.append('get_or_set_contents_file_id')
833 def get_contents(suite, overridetype, section=None, session=None):
835 Returns contents for a suite / overridetype combination, limiting
836 to a section if not None.
839 @param suite: Suite object
841 @type overridetype: OverrideType
842 @param overridetype: OverrideType object
844 @type section: Section
845 @param section: Optional section object to limit results to
847 @type session: SQLAlchemy
848 @param session: Optional SQL session object (a temporary one will be
849 generated if not supplied)
852 @return: ResultsProxy object set up to return tuples of (filename, section,
856 # find me all of the contents for a given suite
857 contents_q = """SELECT (p.path||'/'||n.file) AS fn,
861 FROM content_associations c join content_file_paths p ON (c.filepath=p.id)
862 JOIN content_file_names n ON (c.filename=n.id)
863 JOIN binaries b ON (b.id=c.binary_pkg)
864 JOIN override o ON (o.package=b.package)
865 JOIN section s ON (s.id=o.section)
866 WHERE o.suite = :suiteid AND o.type = :overridetypeid
867 AND b.type=:overridetypename"""
869 vals = {'suiteid': suite.suite_id,
870 'overridetypeid': overridetype.overridetype_id,
871 'overridetypename': overridetype.overridetype}
873 if section is not None:
874 contents_q += " AND s.id = :sectionid"
875 vals['sectionid'] = section.section_id
877 contents_q += " ORDER BY fn"
879 return session.execute(contents_q, vals)
881 __all__.append('get_contents')
883 ################################################################################
885 class ContentFilepath(object):
886 def __init__(self, *args, **kwargs):
890 return '<ContentFilepath %s>' % self.filepath
892 __all__.append('ContentFilepath')
895 def get_or_set_contents_path_id(filepath, session=None):
897 Returns database id for given path.
899 If no matching file is found, a row is inserted.
901 @type filename: string
902 @param filename: The filepath
903 @type session: SQLAlchemy
904 @param session: Optional SQL session object (a temporary one will be
905 generated if not supplied). If not passed, a commit will be performed at
906 the end of the function, otherwise the caller is responsible for commiting.
909 @return: the database id for the given path
912 q = session.query(ContentFilepath).filter_by(filepath=filepath)
915 ret = q.one().cafilepath_id
916 except NoResultFound:
917 cf = ContentFilepath()
918 cf.filepath = filepath
920 session.commit_or_flush()
921 ret = cf.cafilepath_id
925 __all__.append('get_or_set_contents_path_id')
927 ################################################################################
929 class ContentAssociation(object):
930 def __init__(self, *args, **kwargs):
934 return '<ContentAssociation %s>' % self.ca_id
936 __all__.append('ContentAssociation')
938 def insert_content_paths(binary_id, fullpaths, session=None):
940 Make sure given path is associated with given binary id
943 @param binary_id: the id of the binary
944 @type fullpaths: list
945 @param fullpaths: the list of paths of the file being associated with the binary
946 @type session: SQLAlchemy session
947 @param session: Optional SQLAlchemy session. If this is passed, the caller
948 is responsible for ensuring a transaction has begun and committing the
949 results or rolling back based on the result code. If not passed, a commit
950 will be performed at the end of the function, otherwise the caller is
951 responsible for commiting.
953 @return: True upon success
958 session = DBConn().session()
964 for fullpath in fullpaths:
965 if fullpath.startswith( './' ):
966 fullpath = fullpath[2:]
968 session.execute( "INSERT INTO bin_contents ( file, binary_id ) VALUES ( :filename, :id )", { 'filename': fullpath, 'id': binary_id} )
976 traceback.print_exc()
978 # Only rollback if we set up the session ourself
985 __all__.append('insert_content_paths')
987 ################################################################################
989 class DSCFile(object):
990 def __init__(self, *args, **kwargs):
994 return '<DSCFile %s>' % self.dscfile_id
996 __all__.append('DSCFile')
999 def get_dscfiles(dscfile_id=None, source_id=None, poolfile_id=None, session=None):
1001 Returns a list of DSCFiles which may be empty
1003 @type dscfile_id: int (optional)
1004 @param dscfile_id: the dscfile_id of the DSCFiles to find
1006 @type source_id: int (optional)
1007 @param source_id: the source id related to the DSCFiles to find
1009 @type poolfile_id: int (optional)
1010 @param poolfile_id: the poolfile id related to the DSCFiles to find
1013 @return: Possibly empty list of DSCFiles
1016 q = session.query(DSCFile)
1018 if dscfile_id is not None:
1019 q = q.filter_by(dscfile_id=dscfile_id)
1021 if source_id is not None:
1022 q = q.filter_by(source_id=source_id)
1024 if poolfile_id is not None:
1025 q = q.filter_by(poolfile_id=poolfile_id)
1029 __all__.append('get_dscfiles')
1031 ################################################################################
1033 class PoolFile(object):
1034 def __init__(self, *args, **kwargs):
1038 return '<PoolFile %s>' % self.filename
1042 return os.path.join(self.location.path, self.filename)
1044 __all__.append('PoolFile')
1047 def check_poolfile(filename, filesize, md5sum, location_id, session=None):
1050 (ValidFileFound [boolean or None], PoolFile object or None)
1052 @type filename: string
1053 @param filename: the filename of the file to check against the DB
1056 @param filesize: the size of the file to check against the DB
1058 @type md5sum: string
1059 @param md5sum: the md5sum of the file to check against the DB
1061 @type location_id: int
1062 @param location_id: the id of the location to look in
1065 @return: Tuple of length 2.
1066 If more than one file found with that name:
1068 If valid pool file found: (True, PoolFile object)
1069 If valid pool file not found:
1070 (False, None) if no file found
1071 (False, PoolFile object) if file found with size/md5sum mismatch
1074 q = session.query(PoolFile).filter_by(filename=filename)
1075 q = q.join(Location).filter_by(location_id=location_id)
1085 if obj.md5sum != md5sum or obj.filesize != int(filesize):
1093 __all__.append('check_poolfile')
1096 def get_poolfile_by_id(file_id, session=None):
1098 Returns a PoolFile objects or None for the given id
1101 @param file_id: the id of the file to look for
1103 @rtype: PoolFile or None
1104 @return: either the PoolFile object or None
1107 q = session.query(PoolFile).filter_by(file_id=file_id)
1111 except NoResultFound:
1114 __all__.append('get_poolfile_by_id')
1118 def get_poolfile_by_name(filename, location_id=None, session=None):
1120 Returns an array of PoolFile objects for the given filename and
1121 (optionally) location_id
1123 @type filename: string
1124 @param filename: the filename of the file to check against the DB
1126 @type location_id: int
1127 @param location_id: the id of the location to look in (optional)
1130 @return: array of PoolFile objects
1133 q = session.query(PoolFile).filter_by(filename=filename)
1135 if location_id is not None:
1136 q = q.join(Location).filter_by(location_id=location_id)
1140 __all__.append('get_poolfile_by_name')
1143 def get_poolfile_like_name(filename, session=None):
1145 Returns an array of PoolFile objects which are like the given name
1147 @type filename: string
1148 @param filename: the filename of the file to check against the DB
1151 @return: array of PoolFile objects
1154 # TODO: There must be a way of properly using bind parameters with %FOO%
1155 q = session.query(PoolFile).filter(PoolFile.filename.like('%%/%s' % filename))
1159 __all__.append('get_poolfile_like_name')
1162 def add_poolfile(filename, datadict, location_id, session=None):
1164 Add a new file to the pool
1166 @type filename: string
1167 @param filename: filename
1169 @type datadict: dict
1170 @param datadict: dict with needed data
1172 @type location_id: int
1173 @param location_id: database id of the location
1176 @return: the PoolFile object created
1178 poolfile = PoolFile()
1179 poolfile.filename = filename
1180 poolfile.filesize = datadict["size"]
1181 poolfile.md5sum = datadict["md5sum"]
1182 poolfile.sha1sum = datadict["sha1sum"]
1183 poolfile.sha256sum = datadict["sha256sum"]
1184 poolfile.location_id = location_id
1186 session.add(poolfile)
1187 # Flush to get a file id (NB: This is not a commit)
1192 __all__.append('add_poolfile')
1194 ################################################################################
1196 class Fingerprint(object):
1197 def __init__(self, *args, **kwargs):
1201 return '<Fingerprint %s>' % self.fingerprint
1203 __all__.append('Fingerprint')
1206 def get_fingerprint(fpr, session=None):
1208 Returns Fingerprint object for given fpr.
1211 @param fpr: The fpr to find / add
1213 @type session: SQLAlchemy
1214 @param session: Optional SQL session object (a temporary one will be
1215 generated if not supplied).
1218 @return: the Fingerprint object for the given fpr or None
1221 q = session.query(Fingerprint).filter_by(fingerprint=fpr)
1225 except NoResultFound:
1230 __all__.append('get_fingerprint')
1233 def get_or_set_fingerprint(fpr, session=None):
1235 Returns Fingerprint object for given fpr.
1237 If no matching fpr is found, a row is inserted.
1240 @param fpr: The fpr to find / add
1242 @type session: SQLAlchemy
1243 @param session: Optional SQL session object (a temporary one will be
1244 generated if not supplied). If not passed, a commit will be performed at
1245 the end of the function, otherwise the caller is responsible for commiting.
1246 A flush will be performed either way.
1249 @return: the Fingerprint object for the given fpr
1252 q = session.query(Fingerprint).filter_by(fingerprint=fpr)
1256 except NoResultFound:
1257 fingerprint = Fingerprint()
1258 fingerprint.fingerprint = fpr
1259 session.add(fingerprint)
1260 session.commit_or_flush()
1265 __all__.append('get_or_set_fingerprint')
1267 ################################################################################
1269 # Helper routine for Keyring class
1270 def get_ldap_name(entry):
1272 for k in ["cn", "mn", "sn"]:
1274 if ret and ret[0] != "" and ret[0] != "-":
1276 return " ".join(name)
1278 ################################################################################
1280 class Keyring(object):
1281 gpg_invocation = "gpg --no-default-keyring --keyring %s" +\
1282 " --with-colons --fingerprint --fingerprint"
1287 def __init__(self, *args, **kwargs):
1291 return '<Keyring %s>' % self.keyring_name
1293 def de_escape_gpg_str(self, txt):
1294 esclist = re.split(r'(\\x..)', txt)
1295 for x in range(1,len(esclist),2):
1296 esclist[x] = "%c" % (int(esclist[x][2:],16))
1297 return "".join(esclist)
1299 def load_keys(self, keyring):
1302 if not self.keyring_id:
1303 raise Exception('Must be initialized with database information')
1305 k = os.popen(self.gpg_invocation % keyring, "r")
1309 for line in k.xreadlines():
1310 field = line.split(":")
1311 if field[0] == "pub":
1313 (name, addr) = email.Utils.parseaddr(field[9])
1314 name = re.sub(r"\s*[(].*[)]", "", name)
1315 if name == "" or addr == "" or "@" not in addr:
1317 addr = "invalid-uid"
1318 name = self.de_escape_gpg_str(name)
1319 self.keys[key] = {"email": addr}
1321 self.keys[key]["name"] = name
1322 self.keys[key]["aliases"] = [name]
1323 self.keys[key]["fingerprints"] = []
1325 elif key and field[0] == "sub" and len(field) >= 12:
1326 signingkey = ("s" in field[11])
1327 elif key and field[0] == "uid":
1328 (name, addr) = email.Utils.parseaddr(field[9])
1329 if name and name not in self.keys[key]["aliases"]:
1330 self.keys[key]["aliases"].append(name)
1331 elif signingkey and field[0] == "fpr":
1332 self.keys[key]["fingerprints"].append(field[9])
1333 self.fpr_lookup[field[9]] = key
1335 def import_users_from_ldap(self, session):
1339 LDAPDn = cnf["Import-LDAP-Fingerprints::LDAPDn"]
1340 LDAPServer = cnf["Import-LDAP-Fingerprints::LDAPServer"]
1342 l = ldap.open(LDAPServer)
1343 l.simple_bind_s("","")
1344 Attrs = l.search_s(LDAPDn, ldap.SCOPE_ONELEVEL,
1345 "(&(keyfingerprint=*)(gidnumber=%s))" % (cnf["Import-Users-From-Passwd::ValidGID"]),
1346 ["uid", "keyfingerprint", "cn", "mn", "sn"])
1348 ldap_fin_uid_id = {}
1355 uid = entry["uid"][0]
1356 name = get_ldap_name(entry)
1357 fingerprints = entry["keyFingerPrint"]
1359 for f in fingerprints:
1360 key = self.fpr_lookup.get(f, None)
1361 if key not in self.keys:
1363 self.keys[key]["uid"] = uid
1367 keyid = get_or_set_uid(uid, session).uid_id
1368 byuid[keyid] = (uid, name)
1369 byname[uid] = (keyid, name)
1371 return (byname, byuid)
1373 def generate_users_from_keyring(self, format, session):
1377 for x in self.keys.keys():
1378 if self.keys[x]["email"] == "invalid-uid":
1380 self.keys[x]["uid"] = format % "invalid-uid"
1382 uid = format % self.keys[x]["email"]
1383 keyid = get_or_set_uid(uid, session).uid_id
1384 byuid[keyid] = (uid, self.keys[x]["name"])
1385 byname[uid] = (keyid, self.keys[x]["name"])
1386 self.keys[x]["uid"] = uid
1389 uid = format % "invalid-uid"
1390 keyid = get_or_set_uid(uid, session).uid_id
1391 byuid[keyid] = (uid, "ungeneratable user id")
1392 byname[uid] = (keyid, "ungeneratable user id")
1394 return (byname, byuid)
1396 __all__.append('Keyring')
1399 def get_keyring(keyring, session=None):
1401 If C{keyring} does not have an entry in the C{keyrings} table yet, return None
1402 If C{keyring} already has an entry, simply return the existing Keyring
1404 @type keyring: string
1405 @param keyring: the keyring name
1408 @return: the Keyring object for this keyring
1411 q = session.query(Keyring).filter_by(keyring_name=keyring)
1415 except NoResultFound:
1418 __all__.append('get_keyring')
1420 ################################################################################
1422 class KeyringACLMap(object):
1423 def __init__(self, *args, **kwargs):
1427 return '<KeyringACLMap %s>' % self.keyring_acl_map_id
1429 __all__.append('KeyringACLMap')
1431 ################################################################################
1433 class DBChange(object):
1434 def __init__(self, *args, **kwargs):
1438 return '<DBChange %s>' % self.changesname
1440 def clean_from_queue(self):
1441 session = DBConn().session().object_session(self)
1443 # Remove changes_pool_files entries
1446 # Remove changes_pending_files references
1449 # Clear out of queue
1450 self.in_queue = None
1451 self.approved_for_id = None
1453 __all__.append('DBChange')
1456 def get_dbchange(filename, session=None):
1458 returns DBChange object for given C{filename}.
1460 @type archive: string
1461 @param archive: the name of the arhive
1463 @type session: Session
1464 @param session: Optional SQLA session object (a temporary one will be
1465 generated if not supplied)
1468 @return: Archive object for the given name (None if not present)
1471 q = session.query(DBChange).filter_by(changesname=filename)
1475 except NoResultFound:
1478 __all__.append('get_dbchange')
1480 ################################################################################
1482 class Location(object):
1483 def __init__(self, *args, **kwargs):
1487 return '<Location %s (%s)>' % (self.path, self.location_id)
1489 __all__.append('Location')
1492 def get_location(location, component=None, archive=None, session=None):
1494 Returns Location object for the given combination of location, component
1497 @type location: string
1498 @param location: the path of the location, e.g. I{/srv/ftp.debian.org/ftp/pool/}
1500 @type component: string
1501 @param component: the component name (if None, no restriction applied)
1503 @type archive: string
1504 @param archive_id: the archive name (if None, no restriction applied)
1506 @rtype: Location / None
1507 @return: Either a Location object or None if one can't be found
1510 q = session.query(Location).filter_by(path=location)
1512 if archive is not None:
1513 q = q.join(Archive).filter_by(archive_name=archive)
1515 if component is not None:
1516 q = q.join(Component).filter_by(component_name=component)
1520 except NoResultFound:
1523 __all__.append('get_location')
1525 ################################################################################
1527 class Maintainer(object):
1528 def __init__(self, *args, **kwargs):
1532 return '''<Maintainer '%s' (%s)>''' % (self.name, self.maintainer_id)
1534 def get_split_maintainer(self):
1535 if not hasattr(self, 'name') or self.name is None:
1536 return ('', '', '', '')
1538 return fix_maintainer(self.name.strip())
1540 __all__.append('Maintainer')
1543 def get_or_set_maintainer(name, session=None):
1545 Returns Maintainer object for given maintainer name.
1547 If no matching maintainer name is found, a row is inserted.
1550 @param name: The maintainer name to add
1552 @type session: SQLAlchemy
1553 @param session: Optional SQL session object (a temporary one will be
1554 generated if not supplied). If not passed, a commit will be performed at
1555 the end of the function, otherwise the caller is responsible for commiting.
1556 A flush will be performed either way.
1559 @return: the Maintainer object for the given maintainer
1562 q = session.query(Maintainer).filter_by(name=name)
1565 except NoResultFound:
1566 maintainer = Maintainer()
1567 maintainer.name = name
1568 session.add(maintainer)
1569 session.commit_or_flush()
1574 __all__.append('get_or_set_maintainer')
1577 def get_maintainer(maintainer_id, session=None):
1579 Return the name of the maintainer behind C{maintainer_id} or None if that
1580 maintainer_id is invalid.
1582 @type maintainer_id: int
1583 @param maintainer_id: the id of the maintainer
1586 @return: the Maintainer with this C{maintainer_id}
1589 return session.query(Maintainer).get(maintainer_id)
1591 __all__.append('get_maintainer')
1593 ################################################################################
1595 class NewComment(object):
1596 def __init__(self, *args, **kwargs):
1600 return '''<NewComment for '%s %s' (%s)>''' % (self.package, self.version, self.comment_id)
1602 __all__.append('NewComment')
1605 def has_new_comment(package, version, session=None):
1607 Returns true if the given combination of C{package}, C{version} has a comment.
1609 @type package: string
1610 @param package: name of the package
1612 @type version: string
1613 @param version: package version
1615 @type session: Session
1616 @param session: Optional SQLA session object (a temporary one will be
1617 generated if not supplied)
1623 q = session.query(NewComment)
1624 q = q.filter_by(package=package)
1625 q = q.filter_by(version=version)
1627 return bool(q.count() > 0)
1629 __all__.append('has_new_comment')
1632 def get_new_comments(package=None, version=None, comment_id=None, session=None):
1634 Returns (possibly empty) list of NewComment objects for the given
1637 @type package: string (optional)
1638 @param package: name of the package
1640 @type version: string (optional)
1641 @param version: package version
1643 @type comment_id: int (optional)
1644 @param comment_id: An id of a comment
1646 @type session: Session
1647 @param session: Optional SQLA session object (a temporary one will be
1648 generated if not supplied)
1651 @return: A (possibly empty) list of NewComment objects will be returned
1654 q = session.query(NewComment)
1655 if package is not None: q = q.filter_by(package=package)
1656 if version is not None: q = q.filter_by(version=version)
1657 if comment_id is not None: q = q.filter_by(comment_id=comment_id)
1661 __all__.append('get_new_comments')
1663 ################################################################################
1665 class Override(object):
1666 def __init__(self, *args, **kwargs):
1670 return '<Override %s (%s)>' % (self.package, self.suite_id)
1672 __all__.append('Override')
1675 def get_override(package, suite=None, component=None, overridetype=None, session=None):
1677 Returns Override object for the given parameters
1679 @type package: string
1680 @param package: The name of the package
1682 @type suite: string, list or None
1683 @param suite: The name of the suite (or suites if a list) to limit to. If
1684 None, don't limit. Defaults to None.
1686 @type component: string, list or None
1687 @param component: The name of the component (or components if a list) to
1688 limit to. If None, don't limit. Defaults to None.
1690 @type overridetype: string, list or None
1691 @param overridetype: The name of the overridetype (or overridetypes if a list) to
1692 limit to. If None, don't limit. Defaults to None.
1694 @type session: Session
1695 @param session: Optional SQLA session object (a temporary one will be
1696 generated if not supplied)
1699 @return: A (possibly empty) list of Override objects will be returned
1702 q = session.query(Override)
1703 q = q.filter_by(package=package)
1705 if suite is not None:
1706 if not isinstance(suite, list): suite = [suite]
1707 q = q.join(Suite).filter(Suite.suite_name.in_(suite))
1709 if component is not None:
1710 if not isinstance(component, list): component = [component]
1711 q = q.join(Component).filter(Component.component_name.in_(component))
1713 if overridetype is not None:
1714 if not isinstance(overridetype, list): overridetype = [overridetype]
1715 q = q.join(OverrideType).filter(OverrideType.overridetype.in_(overridetype))
1719 __all__.append('get_override')
1722 ################################################################################
1724 class OverrideType(object):
1725 def __init__(self, *args, **kwargs):
1729 return '<OverrideType %s>' % self.overridetype
1731 __all__.append('OverrideType')
1734 def get_override_type(override_type, session=None):
1736 Returns OverrideType object for given C{override type}.
1738 @type override_type: string
1739 @param override_type: The name of the override type
1741 @type session: Session
1742 @param session: Optional SQLA session object (a temporary one will be
1743 generated if not supplied)
1746 @return: the database id for the given override type
1749 q = session.query(OverrideType).filter_by(overridetype=override_type)
1753 except NoResultFound:
1756 __all__.append('get_override_type')
1758 ################################################################################
1760 class PendingContentAssociation(object):
1761 def __init__(self, *args, **kwargs):
1765 return '<PendingContentAssociation %s>' % self.pca_id
1767 __all__.append('PendingContentAssociation')
1769 def insert_pending_content_paths(package, fullpaths, session=None):
1771 Make sure given paths are temporarily associated with given
1775 @param package: the package to associate with should have been read in from the binary control file
1776 @type fullpaths: list
1777 @param fullpaths: the list of paths of the file being associated with the binary
1778 @type session: SQLAlchemy session
1779 @param session: Optional SQLAlchemy session. If this is passed, the caller
1780 is responsible for ensuring a transaction has begun and committing the
1781 results or rolling back based on the result code. If not passed, a commit
1782 will be performed at the end of the function
1784 @return: True upon success, False if there is a problem
1787 privatetrans = False
1790 session = DBConn().session()
1794 arch = get_architecture(package['Architecture'], session)
1795 arch_id = arch.arch_id
1797 # Remove any already existing recorded files for this package
1798 q = session.query(PendingContentAssociation)
1799 q = q.filter_by(package=package['Package'])
1800 q = q.filter_by(version=package['Version'])
1801 q = q.filter_by(architecture=arch_id)
1806 for fullpath in fullpaths:
1807 (path, filename) = os.path.split(fullpath)
1809 if path.startswith( "./" ):
1812 filepath_id = get_or_set_contents_path_id(path, session)
1813 filename_id = get_or_set_contents_file_id(filename, session)
1815 pathcache[fullpath] = (filepath_id, filename_id)
1817 for fullpath, dat in pathcache.items():
1818 pca = PendingContentAssociation()
1819 pca.package = package['Package']
1820 pca.version = package['Version']
1821 pca.filepath_id = dat[0]
1822 pca.filename_id = dat[1]
1823 pca.architecture = arch_id
1826 # Only commit if we set up the session ourself
1834 except Exception, e:
1835 traceback.print_exc()
1837 # Only rollback if we set up the session ourself
1844 __all__.append('insert_pending_content_paths')
1846 ################################################################################
1848 class PolicyQueue(object):
1849 def __init__(self, *args, **kwargs):
1853 return '<PolicyQueue %s>' % self.queue_name
1855 __all__.append('PolicyQueue')
1858 def get_policy_queue(queuename, session=None):
1860 Returns PolicyQueue object for given C{queue name}
1862 @type queuename: string
1863 @param queuename: The name of the queue
1865 @type session: Session
1866 @param session: Optional SQLA session object (a temporary one will be
1867 generated if not supplied)
1870 @return: PolicyQueue object for the given queue
1873 q = session.query(PolicyQueue).filter_by(queue_name=queuename)
1877 except NoResultFound:
1880 __all__.append('get_policy_queue')
1882 ################################################################################
1884 class Priority(object):
1885 def __init__(self, *args, **kwargs):
1888 def __eq__(self, val):
1889 if isinstance(val, str):
1890 return (self.priority == val)
1891 # This signals to use the normal comparison operator
1892 return NotImplemented
1894 def __ne__(self, val):
1895 if isinstance(val, str):
1896 return (self.priority != val)
1897 # This signals to use the normal comparison operator
1898 return NotImplemented
1901 return '<Priority %s (%s)>' % (self.priority, self.priority_id)
1903 __all__.append('Priority')
1906 def get_priority(priority, session=None):
1908 Returns Priority object for given C{priority name}.
1910 @type priority: string
1911 @param priority: The name of the priority
1913 @type session: Session
1914 @param session: Optional SQLA session object (a temporary one will be
1915 generated if not supplied)
1918 @return: Priority object for the given priority
1921 q = session.query(Priority).filter_by(priority=priority)
1925 except NoResultFound:
1928 __all__.append('get_priority')
1931 def get_priorities(session=None):
1933 Returns dictionary of priority names -> id mappings
1935 @type session: Session
1936 @param session: Optional SQL session object (a temporary one will be
1937 generated if not supplied)
1940 @return: dictionary of priority names -> id mappings
1944 q = session.query(Priority)
1946 ret[x.priority] = x.priority_id
1950 __all__.append('get_priorities')
1952 ################################################################################
1954 class Section(object):
1955 def __init__(self, *args, **kwargs):
1958 def __eq__(self, val):
1959 if isinstance(val, str):
1960 return (self.section == val)
1961 # This signals to use the normal comparison operator
1962 return NotImplemented
1964 def __ne__(self, val):
1965 if isinstance(val, str):
1966 return (self.section != val)
1967 # This signals to use the normal comparison operator
1968 return NotImplemented
1971 return '<Section %s>' % self.section
1973 __all__.append('Section')
1976 def get_section(section, session=None):
1978 Returns Section object for given C{section name}.
1980 @type section: string
1981 @param section: The name of the section
1983 @type session: Session
1984 @param session: Optional SQLA session object (a temporary one will be
1985 generated if not supplied)
1988 @return: Section object for the given section name
1991 q = session.query(Section).filter_by(section=section)
1995 except NoResultFound:
1998 __all__.append('get_section')
2001 def get_sections(session=None):
2003 Returns dictionary of section names -> id mappings
2005 @type session: Session
2006 @param session: Optional SQL session object (a temporary one will be
2007 generated if not supplied)
2010 @return: dictionary of section names -> id mappings
2014 q = session.query(Section)
2016 ret[x.section] = x.section_id
2020 __all__.append('get_sections')
2022 ################################################################################
2024 class DBSource(object):
2025 def __init__(self, *args, **kwargs):
2029 return '<DBSource %s (%s)>' % (self.source, self.version)
2031 __all__.append('DBSource')
2034 def source_exists(source, source_version, suites = ["any"], session=None):
2036 Ensure that source exists somewhere in the archive for the binary
2037 upload being processed.
2038 1. exact match => 1.0-3
2039 2. bin-only NMU => 1.0-3+b1 , 1.0-3.1+b1
2041 @type package: string
2042 @param package: package source name
2044 @type source_version: string
2045 @param source_version: expected source version
2048 @param suites: list of suites to check in, default I{any}
2050 @type session: Session
2051 @param session: Optional SQLA session object (a temporary one will be
2052 generated if not supplied)
2055 @return: returns 1 if a source with expected version is found, otherwise 0
2062 for suite in suites:
2063 q = session.query(DBSource).filter_by(source=source)
2065 # source must exist in suite X, or in some other suite that's
2066 # mapped to X, recursively... silent-maps are counted too,
2067 # unreleased-maps aren't.
2068 maps = cnf.ValueList("SuiteMappings")[:]
2070 maps = [ m.split() for m in maps ]
2071 maps = [ (x[1], x[2]) for x in maps
2072 if x[0] == "map" or x[0] == "silent-map" ]
2075 if x[1] in s and x[0] not in s:
2078 q = q.join(SrcAssociation).join(Suite)
2079 q = q.filter(Suite.suite_name.in_(s))
2081 # Reduce the query results to a list of version numbers
2082 ql = [ j.version for j in q.all() ]
2085 if source_version in ql:
2089 from daklib.regexes import re_bin_only_nmu
2090 orig_source_version = re_bin_only_nmu.sub('', source_version)
2091 if orig_source_version in ql:
2094 # No source found so return not ok
2099 __all__.append('source_exists')
2102 def get_suites_source_in(source, session=None):
2104 Returns list of Suite objects which given C{source} name is in
2107 @param source: DBSource package name to search for
2110 @return: list of Suite objects for the given source
2113 return session.query(Suite).join(SrcAssociation).join(DBSource).filter_by(source=source).all()
2115 __all__.append('get_suites_source_in')
2118 def get_sources_from_name(source, version=None, dm_upload_allowed=None, session=None):
2120 Returns list of DBSource objects for given C{source} name and other parameters
2123 @param source: DBSource package name to search for
2125 @type source: str or None
2126 @param source: DBSource version name to search for or None if not applicable
2128 @type dm_upload_allowed: bool
2129 @param dm_upload_allowed: If None, no effect. If True or False, only
2130 return packages with that dm_upload_allowed setting
2132 @type session: Session
2133 @param session: Optional SQL session object (a temporary one will be
2134 generated if not supplied)
2137 @return: list of DBSource objects for the given name (may be empty)
2140 q = session.query(DBSource).filter_by(source=source)
2142 if version is not None:
2143 q = q.filter_by(version=version)
2145 if dm_upload_allowed is not None:
2146 q = q.filter_by(dm_upload_allowed=dm_upload_allowed)
2150 __all__.append('get_sources_from_name')
2153 def get_source_in_suite(source, suite, session=None):
2155 Returns list of DBSource objects for a combination of C{source} and C{suite}.
2157 - B{source} - source package name, eg. I{mailfilter}, I{bbdb}, I{glibc}
2158 - B{suite} - a suite name, eg. I{unstable}
2160 @type source: string
2161 @param source: source package name
2164 @param suite: the suite name
2167 @return: the version for I{source} in I{suite}
2171 q = session.query(SrcAssociation)
2172 q = q.join('source').filter_by(source=source)
2173 q = q.join('suite').filter_by(suite_name=suite)
2176 return q.one().source
2177 except NoResultFound:
2180 __all__.append('get_source_in_suite')
2182 ################################################################################
2185 def add_dsc_to_db(u, filename, session=None):
2186 entry = u.pkg.files[filename]
2190 source.source = u.pkg.dsc["source"]
2191 source.version = u.pkg.dsc["version"] # NB: not files[file]["version"], that has no epoch
2192 source.maintainer_id = get_or_set_maintainer(u.pkg.dsc["maintainer"], session).maintainer_id
2193 source.changedby_id = get_or_set_maintainer(u.pkg.changes["changed-by"], session).maintainer_id
2194 source.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
2195 source.install_date = datetime.now().date()
2197 dsc_component = entry["component"]
2198 dsc_location_id = entry["location id"]
2200 source.dm_upload_allowed = (u.pkg.dsc.get("dm-upload-allowed", '') == "yes")
2202 # Set up a new poolfile if necessary
2203 if not entry.has_key("files id") or not entry["files id"]:
2204 filename = entry["pool name"] + filename
2205 poolfile = add_poolfile(filename, entry, dsc_location_id, session)
2207 pfs.append(poolfile)
2208 entry["files id"] = poolfile.file_id
2210 source.poolfile_id = entry["files id"]
2214 for suite_name in u.pkg.changes["distribution"].keys():
2215 sa = SrcAssociation()
2216 sa.source_id = source.source_id
2217 sa.suite_id = get_suite(suite_name).suite_id
2222 # Add the source files to the DB (files and dsc_files)
2224 dscfile.source_id = source.source_id
2225 dscfile.poolfile_id = entry["files id"]
2226 session.add(dscfile)
2228 for dsc_file, dentry in u.pkg.dsc_files.items():
2230 df.source_id = source.source_id
2232 # If the .orig tarball is already in the pool, it's
2233 # files id is stored in dsc_files by check_dsc().
2234 files_id = dentry.get("files id", None)
2236 # Find the entry in the files hash
2237 # TODO: Bail out here properly
2239 for f, e in u.pkg.files.items():
2244 if files_id is None:
2245 filename = dfentry["pool name"] + dsc_file
2247 (found, obj) = check_poolfile(filename, dentry["size"], dentry["md5sum"], dsc_location_id)
2248 # FIXME: needs to check for -1/-2 and or handle exception
2249 if found and obj is not None:
2250 files_id = obj.file_id
2253 # If still not found, add it
2254 if files_id is None:
2255 # HACK: Force sha1sum etc into dentry
2256 dentry["sha1sum"] = dfentry["sha1sum"]
2257 dentry["sha256sum"] = dfentry["sha256sum"]
2258 poolfile = add_poolfile(filename, dentry, dsc_location_id, session)
2259 pfs.append(poolfile)
2260 files_id = poolfile.file_id
2262 poolfile = get_poolfile_by_id(files_id, session)
2263 if poolfile is None:
2264 utils.fubar("INTERNAL ERROR. Found no poolfile with id %d" % files_id)
2265 pfs.append(poolfile)
2267 df.poolfile_id = files_id
2272 # Add the src_uploaders to the DB
2273 uploader_ids = [source.maintainer_id]
2274 if u.pkg.dsc.has_key("uploaders"):
2275 for up in u.pkg.dsc["uploaders"].split(","):
2277 uploader_ids.append(get_or_set_maintainer(up, session).maintainer_id)
2280 for up_id in uploader_ids:
2281 if added_ids.has_key(up_id):
2283 utils.warn("Already saw uploader %s for source %s" % (up_id, source.source))
2289 su.maintainer_id = up_id
2290 su.source_id = source.source_id
2295 return source, dsc_component, dsc_location_id, pfs
2297 __all__.append('add_dsc_to_db')
2300 def add_deb_to_db(u, filename, session=None):
2302 Contrary to what you might expect, this routine deals with both
2303 debs and udebs. That info is in 'dbtype', whilst 'type' is
2304 'deb' for both of them
2307 entry = u.pkg.files[filename]
2310 bin.package = entry["package"]
2311 bin.version = entry["version"]
2312 bin.maintainer_id = get_or_set_maintainer(entry["maintainer"], session).maintainer_id
2313 bin.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
2314 bin.arch_id = get_architecture(entry["architecture"], session).arch_id
2315 bin.binarytype = entry["dbtype"]
2318 filename = entry["pool name"] + filename
2319 fullpath = os.path.join(cnf["Dir::Pool"], filename)
2320 if not entry.get("location id", None):
2321 entry["location id"] = get_location(cnf["Dir::Pool"], entry["component"], session=session).location_id
2323 if entry.get("files id", None):
2324 poolfile = get_poolfile_by_id(bin.poolfile_id)
2325 bin.poolfile_id = entry["files id"]
2327 poolfile = add_poolfile(filename, entry, entry["location id"], session)
2328 bin.poolfile_id = entry["files id"] = poolfile.file_id
2331 bin_sources = get_sources_from_name(entry["source package"], entry["source version"], session=session)
2332 if len(bin_sources) != 1:
2333 raise NoSourceFieldError, "Unable to find a unique source id for %s (%s), %s, file %s, type %s, signed by %s" % \
2334 (bin.package, bin.version, bin.architecture.arch_string,
2335 filename, bin.binarytype, u.pkg.changes["fingerprint"])
2337 bin.source_id = bin_sources[0].source_id
2339 # Add and flush object so it has an ID
2343 # Add BinAssociations
2344 for suite_name in u.pkg.changes["distribution"].keys():
2345 ba = BinAssociation()
2346 ba.binary_id = bin.binary_id
2347 ba.suite_id = get_suite(suite_name).suite_id
2352 # Deal with contents - disabled for now
2353 #contents = copy_temporary_contents(bin.package, bin.version, bin.architecture.arch_string, os.path.basename(filename), None, session)
2355 # print "REJECT\nCould not determine contents of package %s" % bin.package
2356 # session.rollback()
2357 # raise MissingContents, "No contents stored for package %s, and couldn't determine contents of %s" % (bin.package, filename)
2361 __all__.append('add_deb_to_db')
2363 ################################################################################
2365 class SourceACL(object):
2366 def __init__(self, *args, **kwargs):
2370 return '<SourceACL %s>' % self.source_acl_id
2372 __all__.append('SourceACL')
2374 ################################################################################
2376 class SrcAssociation(object):
2377 def __init__(self, *args, **kwargs):
2381 return '<SrcAssociation %s (%s, %s)>' % (self.sa_id, self.source, self.suite)
2383 __all__.append('SrcAssociation')
2385 ################################################################################
2387 class SrcFormat(object):
2388 def __init__(self, *args, **kwargs):
2392 return '<SrcFormat %s>' % (self.format_name)
2394 __all__.append('SrcFormat')
2396 ################################################################################
2398 class SrcUploader(object):
2399 def __init__(self, *args, **kwargs):
2403 return '<SrcUploader %s>' % self.uploader_id
2405 __all__.append('SrcUploader')
2407 ################################################################################
2409 SUITE_FIELDS = [ ('SuiteName', 'suite_name'),
2410 ('SuiteID', 'suite_id'),
2411 ('Version', 'version'),
2412 ('Origin', 'origin'),
2414 ('Description', 'description'),
2415 ('Untouchable', 'untouchable'),
2416 ('Announce', 'announce'),
2417 ('Codename', 'codename'),
2418 ('OverrideCodename', 'overridecodename'),
2419 ('ValidTime', 'validtime'),
2420 ('Priority', 'priority'),
2421 ('NotAutomatic', 'notautomatic'),
2422 ('CopyChanges', 'copychanges'),
2423 ('CopyDotDak', 'copydotdak'),
2424 ('CommentsDir', 'commentsdir'),
2425 ('OverrideSuite', 'overridesuite'),
2426 ('ChangelogBase', 'changelogbase')]
2429 class Suite(object):
2430 def __init__(self, *args, **kwargs):
2434 return '<Suite %s>' % self.suite_name
2436 def __eq__(self, val):
2437 if isinstance(val, str):
2438 return (self.suite_name == val)
2439 # This signals to use the normal comparison operator
2440 return NotImplemented
2442 def __ne__(self, val):
2443 if isinstance(val, str):
2444 return (self.suite_name != val)
2445 # This signals to use the normal comparison operator
2446 return NotImplemented
2450 for disp, field in SUITE_FIELDS:
2451 val = getattr(self, field, None)
2453 ret.append("%s: %s" % (disp, val))
2455 return "\n".join(ret)
2457 __all__.append('Suite')
2460 def get_suite_architecture(suite, architecture, session=None):
2462 Returns a SuiteArchitecture object given C{suite} and ${arch} or None if it
2466 @param suite: Suite name to search for
2468 @type architecture: str
2469 @param architecture: Architecture name to search for
2471 @type session: Session
2472 @param session: Optional SQL session object (a temporary one will be
2473 generated if not supplied)
2475 @rtype: SuiteArchitecture
2476 @return: the SuiteArchitecture object or None
2479 q = session.query(SuiteArchitecture)
2480 q = q.join(Architecture).filter_by(arch_string=architecture)
2481 q = q.join(Suite).filter_by(suite_name=suite)
2485 except NoResultFound:
2488 __all__.append('get_suite_architecture')
2491 def get_suite(suite, session=None):
2493 Returns Suite object for given C{suite name}.
2496 @param suite: The name of the suite
2498 @type session: Session
2499 @param session: Optional SQLA session object (a temporary one will be
2500 generated if not supplied)
2503 @return: Suite object for the requested suite name (None if not present)
2506 q = session.query(Suite).filter_by(suite_name=suite)
2510 except NoResultFound:
2513 __all__.append('get_suite')
2515 ################################################################################
2517 class SuiteArchitecture(object):
2518 def __init__(self, *args, **kwargs):
2522 return '<SuiteArchitecture (%s, %s)>' % (self.suite_id, self.arch_id)
2524 __all__.append('SuiteArchitecture')
2527 def get_suite_architectures(suite, skipsrc=False, skipall=False, session=None):
2529 Returns list of Architecture objects for given C{suite} name
2532 @param source: Suite name to search for
2534 @type skipsrc: boolean
2535 @param skipsrc: Whether to skip returning the 'source' architecture entry
2538 @type skipall: boolean
2539 @param skipall: Whether to skip returning the 'all' architecture entry
2542 @type session: Session
2543 @param session: Optional SQL session object (a temporary one will be
2544 generated if not supplied)
2547 @return: list of Architecture objects for the given name (may be empty)
2550 q = session.query(Architecture)
2551 q = q.join(SuiteArchitecture)
2552 q = q.join(Suite).filter_by(suite_name=suite)
2555 q = q.filter(Architecture.arch_string != 'source')
2558 q = q.filter(Architecture.arch_string != 'all')
2560 q = q.order_by('arch_string')
2564 __all__.append('get_suite_architectures')
2566 ################################################################################
2568 class SuiteSrcFormat(object):
2569 def __init__(self, *args, **kwargs):
2573 return '<SuiteSrcFormat (%s, %s)>' % (self.suite_id, self.src_format_id)
2575 __all__.append('SuiteSrcFormat')
2578 def get_suite_src_formats(suite, session=None):
2580 Returns list of allowed SrcFormat for C{suite}.
2583 @param suite: Suite name to search for
2585 @type session: Session
2586 @param session: Optional SQL session object (a temporary one will be
2587 generated if not supplied)
2590 @return: the list of allowed source formats for I{suite}
2593 q = session.query(SrcFormat)
2594 q = q.join(SuiteSrcFormat)
2595 q = q.join(Suite).filter_by(suite_name=suite)
2596 q = q.order_by('format_name')
2600 __all__.append('get_suite_src_formats')
2602 ################################################################################
2605 def __init__(self, *args, **kwargs):
2608 def __eq__(self, val):
2609 if isinstance(val, str):
2610 return (self.uid == val)
2611 # This signals to use the normal comparison operator
2612 return NotImplemented
2614 def __ne__(self, val):
2615 if isinstance(val, str):
2616 return (self.uid != val)
2617 # This signals to use the normal comparison operator
2618 return NotImplemented
2621 return '<Uid %s (%s)>' % (self.uid, self.name)
2623 __all__.append('Uid')
2626 def add_database_user(uidname, session=None):
2628 Adds a database user
2630 @type uidname: string
2631 @param uidname: The uid of the user to add
2633 @type session: SQLAlchemy
2634 @param session: Optional SQL session object (a temporary one will be
2635 generated if not supplied). If not passed, a commit will be performed at
2636 the end of the function, otherwise the caller is responsible for commiting.
2639 @return: the uid object for the given uidname
2642 session.execute("CREATE USER :uid", {'uid': uidname})
2643 session.commit_or_flush()
2645 __all__.append('add_database_user')
2648 def get_or_set_uid(uidname, session=None):
2650 Returns uid object for given uidname.
2652 If no matching uidname is found, a row is inserted.
2654 @type uidname: string
2655 @param uidname: The uid to add
2657 @type session: SQLAlchemy
2658 @param session: Optional SQL session object (a temporary one will be
2659 generated if not supplied). If not passed, a commit will be performed at
2660 the end of the function, otherwise the caller is responsible for commiting.
2663 @return: the uid object for the given uidname
2666 q = session.query(Uid).filter_by(uid=uidname)
2670 except NoResultFound:
2674 session.commit_or_flush()
2679 __all__.append('get_or_set_uid')
2682 def get_uid_from_fingerprint(fpr, session=None):
2683 q = session.query(Uid)
2684 q = q.join(Fingerprint).filter_by(fingerprint=fpr)
2688 except NoResultFound:
2691 __all__.append('get_uid_from_fingerprint')
2693 ################################################################################
2695 class UploadBlock(object):
2696 def __init__(self, *args, **kwargs):
2700 return '<UploadBlock %s (%s)>' % (self.source, self.upload_block_id)
2702 __all__.append('UploadBlock')
2704 ################################################################################
2706 class DBConn(object):
2708 database module init.
2712 def __init__(self, *args, **kwargs):
2713 self.__dict__ = self.__shared_state
2715 if not getattr(self, 'initialised', False):
2716 self.initialised = True
2717 self.debug = kwargs.has_key('debug')
2720 def __setuptables(self):
2729 'build_queue_files',
2732 'content_associations',
2733 'content_file_names',
2734 'content_file_paths',
2735 'changes_pending_binaries',
2736 'changes_pending_files',
2737 'changes_pending_files_map',
2738 'changes_pending_source',
2739 'changes_pending_source_files',
2740 'changes_pool_files',
2752 'pending_content_associations',
2762 'suite_architectures',
2763 'suite_src_formats',
2764 'suite_build_queue_copy',
2769 for table_name in tables:
2770 table = Table(table_name, self.db_meta, autoload=True)
2771 setattr(self, 'tbl_%s' % table_name, table)
2773 def __setupmappers(self):
2774 mapper(Architecture, self.tbl_architecture,
2775 properties = dict(arch_id = self.tbl_architecture.c.id))
2777 mapper(Archive, self.tbl_archive,
2778 properties = dict(archive_id = self.tbl_archive.c.id,
2779 archive_name = self.tbl_archive.c.name))
2781 mapper(BinAssociation, self.tbl_bin_associations,
2782 properties = dict(ba_id = self.tbl_bin_associations.c.id,
2783 suite_id = self.tbl_bin_associations.c.suite,
2784 suite = relation(Suite),
2785 binary_id = self.tbl_bin_associations.c.bin,
2786 binary = relation(DBBinary)))
2788 mapper(BuildQueue, self.tbl_build_queue,
2789 properties = dict(queue_id = self.tbl_build_queue.c.id))
2791 mapper(BuildQueueFile, self.tbl_build_queue_files,
2792 properties = dict(buildqueue = relation(BuildQueue, backref='queuefiles'),
2793 poolfile = relation(PoolFile, backref='buildqueueinstances')))
2795 mapper(DBBinary, self.tbl_binaries,
2796 properties = dict(binary_id = self.tbl_binaries.c.id,
2797 package = self.tbl_binaries.c.package,
2798 version = self.tbl_binaries.c.version,
2799 maintainer_id = self.tbl_binaries.c.maintainer,
2800 maintainer = relation(Maintainer),
2801 source_id = self.tbl_binaries.c.source,
2802 source = relation(DBSource),
2803 arch_id = self.tbl_binaries.c.architecture,
2804 architecture = relation(Architecture),
2805 poolfile_id = self.tbl_binaries.c.file,
2806 poolfile = relation(PoolFile),
2807 binarytype = self.tbl_binaries.c.type,
2808 fingerprint_id = self.tbl_binaries.c.sig_fpr,
2809 fingerprint = relation(Fingerprint),
2810 install_date = self.tbl_binaries.c.install_date,
2811 binassociations = relation(BinAssociation,
2812 primaryjoin=(self.tbl_binaries.c.id==self.tbl_bin_associations.c.bin))))
2814 mapper(BinaryACL, self.tbl_binary_acl,
2815 properties = dict(binary_acl_id = self.tbl_binary_acl.c.id))
2817 mapper(BinaryACLMap, self.tbl_binary_acl_map,
2818 properties = dict(binary_acl_map_id = self.tbl_binary_acl_map.c.id,
2819 fingerprint = relation(Fingerprint, backref="binary_acl_map"),
2820 architecture = relation(Architecture)))
2822 mapper(Component, self.tbl_component,
2823 properties = dict(component_id = self.tbl_component.c.id,
2824 component_name = self.tbl_component.c.name))
2826 mapper(DBConfig, self.tbl_config,
2827 properties = dict(config_id = self.tbl_config.c.id))
2829 mapper(DSCFile, self.tbl_dsc_files,
2830 properties = dict(dscfile_id = self.tbl_dsc_files.c.id,
2831 source_id = self.tbl_dsc_files.c.source,
2832 source = relation(DBSource),
2833 poolfile_id = self.tbl_dsc_files.c.file,
2834 poolfile = relation(PoolFile)))
2836 mapper(PoolFile, self.tbl_files,
2837 properties = dict(file_id = self.tbl_files.c.id,
2838 filesize = self.tbl_files.c.size,
2839 location_id = self.tbl_files.c.location,
2840 location = relation(Location)))
2842 mapper(Fingerprint, self.tbl_fingerprint,
2843 properties = dict(fingerprint_id = self.tbl_fingerprint.c.id,
2844 uid_id = self.tbl_fingerprint.c.uid,
2845 uid = relation(Uid),
2846 keyring_id = self.tbl_fingerprint.c.keyring,
2847 keyring = relation(Keyring),
2848 source_acl = relation(SourceACL),
2849 binary_acl = relation(BinaryACL)))
2851 mapper(Keyring, self.tbl_keyrings,
2852 properties = dict(keyring_name = self.tbl_keyrings.c.name,
2853 keyring_id = self.tbl_keyrings.c.id))
2855 mapper(DBChange, self.tbl_changes,
2856 properties = dict(change_id = self.tbl_changes.c.id,
2857 poolfiles = relation(PoolFile,
2858 secondary=self.tbl_changes_pool_files,
2859 backref="changeslinks"),
2860 seen = self.tbl_changes.c.seen,
2861 source = self.tbl_changes.c.source,
2862 binaries = self.tbl_changes.c.binaries,
2863 architecture = self.tbl_changes.c.architecture,
2864 distribution = self.tbl_changes.c.distribution,
2865 urgency = self.tbl_changes.c.urgency,
2866 maintainer = self.tbl_changes.c.maintainer,
2867 changedby = self.tbl_changes.c.changedby,
2868 date = self.tbl_changes.c.date,
2869 version = self.tbl_changes.c.version,
2870 files = relation(ChangePendingFile,
2871 secondary=self.tbl_changes_pending_files_map,
2872 backref="changesfile"),
2873 in_queue_id = self.tbl_changes.c.in_queue,
2874 in_queue = relation(PolicyQueue,
2875 primaryjoin=(self.tbl_changes.c.in_queue==self.tbl_policy_queue.c.id)),
2876 approved_for_id = self.tbl_changes.c.approved_for))
2878 mapper(ChangePendingBinary, self.tbl_changes_pending_binaries,
2879 properties = dict(change_pending_binary_id = self.tbl_changes_pending_binaries.c.id))
2881 mapper(ChangePendingFile, self.tbl_changes_pending_files,
2882 properties = dict(change_pending_file_id = self.tbl_changes_pending_files.c.id,
2883 filename = self.tbl_changes_pending_files.c.filename,
2884 size = self.tbl_changes_pending_files.c.size,
2885 md5sum = self.tbl_changes_pending_files.c.md5sum,
2886 sha1sum = self.tbl_changes_pending_files.c.sha1sum,
2887 sha256sum = self.tbl_changes_pending_files.c.sha256sum))
2889 mapper(ChangePendingSource, self.tbl_changes_pending_source,
2890 properties = dict(change_pending_source_id = self.tbl_changes_pending_source.c.id,
2891 change = relation(DBChange),
2892 maintainer = relation(Maintainer,
2893 primaryjoin=(self.tbl_changes_pending_source.c.maintainer_id==self.tbl_maintainer.c.id)),
2894 changedby = relation(Maintainer,
2895 primaryjoin=(self.tbl_changes_pending_source.c.changedby_id==self.tbl_maintainer.c.id)),
2896 fingerprint = relation(Fingerprint),
2897 source_files = relation(ChangePendingFile,
2898 secondary=self.tbl_changes_pending_source_files,
2899 backref="pending_sources")))
2900 mapper(KeyringACLMap, self.tbl_keyring_acl_map,
2901 properties = dict(keyring_acl_map_id = self.tbl_keyring_acl_map.c.id,
2902 keyring = relation(Keyring, backref="keyring_acl_map"),
2903 architecture = relation(Architecture)))
2905 mapper(Location, self.tbl_location,
2906 properties = dict(location_id = self.tbl_location.c.id,
2907 component_id = self.tbl_location.c.component,
2908 component = relation(Component),
2909 archive_id = self.tbl_location.c.archive,
2910 archive = relation(Archive),
2911 archive_type = self.tbl_location.c.type))
2913 mapper(Maintainer, self.tbl_maintainer,
2914 properties = dict(maintainer_id = self.tbl_maintainer.c.id))
2916 mapper(NewComment, self.tbl_new_comments,
2917 properties = dict(comment_id = self.tbl_new_comments.c.id))
2919 mapper(Override, self.tbl_override,
2920 properties = dict(suite_id = self.tbl_override.c.suite,
2921 suite = relation(Suite),
2922 component_id = self.tbl_override.c.component,
2923 component = relation(Component),
2924 priority_id = self.tbl_override.c.priority,
2925 priority = relation(Priority),
2926 section_id = self.tbl_override.c.section,
2927 section = relation(Section),
2928 overridetype_id = self.tbl_override.c.type,
2929 overridetype = relation(OverrideType)))
2931 mapper(OverrideType, self.tbl_override_type,
2932 properties = dict(overridetype = self.tbl_override_type.c.type,
2933 overridetype_id = self.tbl_override_type.c.id))
2935 mapper(PolicyQueue, self.tbl_policy_queue,
2936 properties = dict(policy_queue_id = self.tbl_policy_queue.c.id))
2938 mapper(Priority, self.tbl_priority,
2939 properties = dict(priority_id = self.tbl_priority.c.id))
2941 mapper(Section, self.tbl_section,
2942 properties = dict(section_id = self.tbl_section.c.id))
2944 mapper(DBSource, self.tbl_source,
2945 properties = dict(source_id = self.tbl_source.c.id,
2946 version = self.tbl_source.c.version,
2947 maintainer_id = self.tbl_source.c.maintainer,
2948 maintainer = relation(Maintainer,
2949 primaryjoin=(self.tbl_source.c.maintainer==self.tbl_maintainer.c.id)),
2950 poolfile_id = self.tbl_source.c.file,
2951 poolfile = relation(PoolFile),
2952 fingerprint_id = self.tbl_source.c.sig_fpr,
2953 fingerprint = relation(Fingerprint),
2954 changedby_id = self.tbl_source.c.changedby,
2955 changedby = relation(Maintainer,
2956 primaryjoin=(self.tbl_source.c.changedby==self.tbl_maintainer.c.id)),
2957 srcfiles = relation(DSCFile,
2958 primaryjoin=(self.tbl_source.c.id==self.tbl_dsc_files.c.source)),
2959 srcassociations = relation(SrcAssociation,
2960 primaryjoin=(self.tbl_source.c.id==self.tbl_src_associations.c.source)),
2961 srcuploaders = relation(SrcUploader)))
2963 mapper(SourceACL, self.tbl_source_acl,
2964 properties = dict(source_acl_id = self.tbl_source_acl.c.id))
2966 mapper(SrcAssociation, self.tbl_src_associations,
2967 properties = dict(sa_id = self.tbl_src_associations.c.id,
2968 suite_id = self.tbl_src_associations.c.suite,
2969 suite = relation(Suite),
2970 source_id = self.tbl_src_associations.c.source,
2971 source = relation(DBSource)))
2973 mapper(SrcFormat, self.tbl_src_format,
2974 properties = dict(src_format_id = self.tbl_src_format.c.id,
2975 format_name = self.tbl_src_format.c.format_name))
2977 mapper(SrcUploader, self.tbl_src_uploaders,
2978 properties = dict(uploader_id = self.tbl_src_uploaders.c.id,
2979 source_id = self.tbl_src_uploaders.c.source,
2980 source = relation(DBSource,
2981 primaryjoin=(self.tbl_src_uploaders.c.source==self.tbl_source.c.id)),
2982 maintainer_id = self.tbl_src_uploaders.c.maintainer,
2983 maintainer = relation(Maintainer,
2984 primaryjoin=(self.tbl_src_uploaders.c.maintainer==self.tbl_maintainer.c.id))))
2986 mapper(Suite, self.tbl_suite,
2987 properties = dict(suite_id = self.tbl_suite.c.id,
2988 policy_queue = relation(PolicyQueue),
2989 copy_queues = relation(BuildQueue, secondary=self.tbl_suite_build_queue_copy)))
2991 mapper(SuiteArchitecture, self.tbl_suite_architectures,
2992 properties = dict(suite_id = self.tbl_suite_architectures.c.suite,
2993 suite = relation(Suite, backref='suitearchitectures'),
2994 arch_id = self.tbl_suite_architectures.c.architecture,
2995 architecture = relation(Architecture)))
2997 mapper(SuiteSrcFormat, self.tbl_suite_src_formats,
2998 properties = dict(suite_id = self.tbl_suite_src_formats.c.suite,
2999 suite = relation(Suite, backref='suitesrcformats'),
3000 src_format_id = self.tbl_suite_src_formats.c.src_format,
3001 src_format = relation(SrcFormat)))
3003 mapper(Uid, self.tbl_uid,
3004 properties = dict(uid_id = self.tbl_uid.c.id,
3005 fingerprint = relation(Fingerprint)))
3007 mapper(UploadBlock, self.tbl_upload_blocks,
3008 properties = dict(upload_block_id = self.tbl_upload_blocks.c.id,
3009 fingerprint = relation(Fingerprint, backref="uploadblocks"),
3010 uid = relation(Uid, backref="uploadblocks")))
3012 ## Connection functions
3013 def __createconn(self):
3014 from config import Config
3018 connstr = "postgres://%s" % cnf["DB::Host"]
3019 if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
3020 connstr += ":%s" % cnf["DB::Port"]
3021 connstr += "/%s" % cnf["DB::Name"]
3024 connstr = "postgres:///%s" % cnf["DB::Name"]
3025 if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
3026 connstr += "?port=%s" % cnf["DB::Port"]
3028 self.db_pg = create_engine(connstr, echo=self.debug)
3029 self.db_meta = MetaData()
3030 self.db_meta.bind = self.db_pg
3031 self.db_smaker = sessionmaker(bind=self.db_pg,
3035 self.__setuptables()
3036 self.__setupmappers()
3039 return self.db_smaker()
3041 __all__.append('DBConn')