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 in uploader_ids:
2281 if added_ids.has_key(up):
2282 utils.warn("Already saw uploader %s for source %s" % (up, source.source))
2288 su.maintainer_id = up
2289 su.source_id = source.source_id
2294 return source, dsc_component, dsc_location_id, pfs
2296 __all__.append('add_dsc_to_db')
2299 def add_deb_to_db(u, filename, session=None):
2301 Contrary to what you might expect, this routine deals with both
2302 debs and udebs. That info is in 'dbtype', whilst 'type' is
2303 'deb' for both of them
2306 entry = u.pkg.files[filename]
2309 bin.package = entry["package"]
2310 bin.version = entry["version"]
2311 bin.maintainer_id = get_or_set_maintainer(entry["maintainer"], session).maintainer_id
2312 bin.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
2313 bin.arch_id = get_architecture(entry["architecture"], session).arch_id
2314 bin.binarytype = entry["dbtype"]
2317 filename = entry["pool name"] + filename
2318 fullpath = os.path.join(cnf["Dir::Pool"], filename)
2319 if not entry.get("location id", None):
2320 entry["location id"] = get_location(cnf["Dir::Pool"], entry["component"], session=session).location_id
2322 if entry.get("files id", None):
2323 poolfile = get_poolfile_by_id(bin.poolfile_id)
2324 bin.poolfile_id = entry["files id"]
2326 poolfile = add_poolfile(filename, entry, entry["location id"], session)
2327 bin.poolfile_id = entry["files id"] = poolfile.file_id
2330 bin_sources = get_sources_from_name(entry["source package"], entry["source version"], session=session)
2331 if len(bin_sources) != 1:
2332 raise NoSourceFieldError, "Unable to find a unique source id for %s (%s), %s, file %s, type %s, signed by %s" % \
2333 (bin.package, bin.version, bin.architecture.arch_string,
2334 filename, bin.binarytype, u.pkg.changes["fingerprint"])
2336 bin.source_id = bin_sources[0].source_id
2338 # Add and flush object so it has an ID
2342 # Add BinAssociations
2343 for suite_name in u.pkg.changes["distribution"].keys():
2344 ba = BinAssociation()
2345 ba.binary_id = bin.binary_id
2346 ba.suite_id = get_suite(suite_name).suite_id
2351 # Deal with contents - disabled for now
2352 #contents = copy_temporary_contents(bin.package, bin.version, bin.architecture.arch_string, os.path.basename(filename), None, session)
2354 # print "REJECT\nCould not determine contents of package %s" % bin.package
2355 # session.rollback()
2356 # raise MissingContents, "No contents stored for package %s, and couldn't determine contents of %s" % (bin.package, filename)
2360 __all__.append('add_deb_to_db')
2362 ################################################################################
2364 class SourceACL(object):
2365 def __init__(self, *args, **kwargs):
2369 return '<SourceACL %s>' % self.source_acl_id
2371 __all__.append('SourceACL')
2373 ################################################################################
2375 class SrcAssociation(object):
2376 def __init__(self, *args, **kwargs):
2380 return '<SrcAssociation %s (%s, %s)>' % (self.sa_id, self.source, self.suite)
2382 __all__.append('SrcAssociation')
2384 ################################################################################
2386 class SrcFormat(object):
2387 def __init__(self, *args, **kwargs):
2391 return '<SrcFormat %s>' % (self.format_name)
2393 __all__.append('SrcFormat')
2395 ################################################################################
2397 class SrcUploader(object):
2398 def __init__(self, *args, **kwargs):
2402 return '<SrcUploader %s>' % self.uploader_id
2404 __all__.append('SrcUploader')
2406 ################################################################################
2408 SUITE_FIELDS = [ ('SuiteName', 'suite_name'),
2409 ('SuiteID', 'suite_id'),
2410 ('Version', 'version'),
2411 ('Origin', 'origin'),
2413 ('Description', 'description'),
2414 ('Untouchable', 'untouchable'),
2415 ('Announce', 'announce'),
2416 ('Codename', 'codename'),
2417 ('OverrideCodename', 'overridecodename'),
2418 ('ValidTime', 'validtime'),
2419 ('Priority', 'priority'),
2420 ('NotAutomatic', 'notautomatic'),
2421 ('CopyChanges', 'copychanges'),
2422 ('CopyDotDak', 'copydotdak'),
2423 ('CommentsDir', 'commentsdir'),
2424 ('OverrideSuite', 'overridesuite'),
2425 ('ChangelogBase', 'changelogbase')]
2428 class Suite(object):
2429 def __init__(self, *args, **kwargs):
2433 return '<Suite %s>' % self.suite_name
2435 def __eq__(self, val):
2436 if isinstance(val, str):
2437 return (self.suite_name == val)
2438 # This signals to use the normal comparison operator
2439 return NotImplemented
2441 def __ne__(self, val):
2442 if isinstance(val, str):
2443 return (self.suite_name != val)
2444 # This signals to use the normal comparison operator
2445 return NotImplemented
2449 for disp, field in SUITE_FIELDS:
2450 val = getattr(self, field, None)
2452 ret.append("%s: %s" % (disp, val))
2454 return "\n".join(ret)
2456 __all__.append('Suite')
2459 def get_suite_architecture(suite, architecture, session=None):
2461 Returns a SuiteArchitecture object given C{suite} and ${arch} or None if it
2465 @param suite: Suite name to search for
2467 @type architecture: str
2468 @param architecture: Architecture name to search for
2470 @type session: Session
2471 @param session: Optional SQL session object (a temporary one will be
2472 generated if not supplied)
2474 @rtype: SuiteArchitecture
2475 @return: the SuiteArchitecture object or None
2478 q = session.query(SuiteArchitecture)
2479 q = q.join(Architecture).filter_by(arch_string=architecture)
2480 q = q.join(Suite).filter_by(suite_name=suite)
2484 except NoResultFound:
2487 __all__.append('get_suite_architecture')
2490 def get_suite(suite, session=None):
2492 Returns Suite object for given C{suite name}.
2495 @param suite: The name of the suite
2497 @type session: Session
2498 @param session: Optional SQLA session object (a temporary one will be
2499 generated if not supplied)
2502 @return: Suite object for the requested suite name (None if not present)
2505 q = session.query(Suite).filter_by(suite_name=suite)
2509 except NoResultFound:
2512 __all__.append('get_suite')
2514 ################################################################################
2516 class SuiteArchitecture(object):
2517 def __init__(self, *args, **kwargs):
2521 return '<SuiteArchitecture (%s, %s)>' % (self.suite_id, self.arch_id)
2523 __all__.append('SuiteArchitecture')
2526 def get_suite_architectures(suite, skipsrc=False, skipall=False, session=None):
2528 Returns list of Architecture objects for given C{suite} name
2531 @param source: Suite name to search for
2533 @type skipsrc: boolean
2534 @param skipsrc: Whether to skip returning the 'source' architecture entry
2537 @type skipall: boolean
2538 @param skipall: Whether to skip returning the 'all' architecture entry
2541 @type session: Session
2542 @param session: Optional SQL session object (a temporary one will be
2543 generated if not supplied)
2546 @return: list of Architecture objects for the given name (may be empty)
2549 q = session.query(Architecture)
2550 q = q.join(SuiteArchitecture)
2551 q = q.join(Suite).filter_by(suite_name=suite)
2554 q = q.filter(Architecture.arch_string != 'source')
2557 q = q.filter(Architecture.arch_string != 'all')
2559 q = q.order_by('arch_string')
2563 __all__.append('get_suite_architectures')
2565 ################################################################################
2567 class SuiteSrcFormat(object):
2568 def __init__(self, *args, **kwargs):
2572 return '<SuiteSrcFormat (%s, %s)>' % (self.suite_id, self.src_format_id)
2574 __all__.append('SuiteSrcFormat')
2577 def get_suite_src_formats(suite, session=None):
2579 Returns list of allowed SrcFormat for C{suite}.
2582 @param suite: Suite name to search for
2584 @type session: Session
2585 @param session: Optional SQL session object (a temporary one will be
2586 generated if not supplied)
2589 @return: the list of allowed source formats for I{suite}
2592 q = session.query(SrcFormat)
2593 q = q.join(SuiteSrcFormat)
2594 q = q.join(Suite).filter_by(suite_name=suite)
2595 q = q.order_by('format_name')
2599 __all__.append('get_suite_src_formats')
2601 ################################################################################
2604 def __init__(self, *args, **kwargs):
2607 def __eq__(self, val):
2608 if isinstance(val, str):
2609 return (self.uid == val)
2610 # This signals to use the normal comparison operator
2611 return NotImplemented
2613 def __ne__(self, val):
2614 if isinstance(val, str):
2615 return (self.uid != val)
2616 # This signals to use the normal comparison operator
2617 return NotImplemented
2620 return '<Uid %s (%s)>' % (self.uid, self.name)
2622 __all__.append('Uid')
2625 def add_database_user(uidname, session=None):
2627 Adds a database user
2629 @type uidname: string
2630 @param uidname: The uid of the user to add
2632 @type session: SQLAlchemy
2633 @param session: Optional SQL session object (a temporary one will be
2634 generated if not supplied). If not passed, a commit will be performed at
2635 the end of the function, otherwise the caller is responsible for commiting.
2638 @return: the uid object for the given uidname
2641 session.execute("CREATE USER :uid", {'uid': uidname})
2642 session.commit_or_flush()
2644 __all__.append('add_database_user')
2647 def get_or_set_uid(uidname, session=None):
2649 Returns uid object for given uidname.
2651 If no matching uidname is found, a row is inserted.
2653 @type uidname: string
2654 @param uidname: The uid to add
2656 @type session: SQLAlchemy
2657 @param session: Optional SQL session object (a temporary one will be
2658 generated if not supplied). If not passed, a commit will be performed at
2659 the end of the function, otherwise the caller is responsible for commiting.
2662 @return: the uid object for the given uidname
2665 q = session.query(Uid).filter_by(uid=uidname)
2669 except NoResultFound:
2673 session.commit_or_flush()
2678 __all__.append('get_or_set_uid')
2681 def get_uid_from_fingerprint(fpr, session=None):
2682 q = session.query(Uid)
2683 q = q.join(Fingerprint).filter_by(fingerprint=fpr)
2687 except NoResultFound:
2690 __all__.append('get_uid_from_fingerprint')
2692 ################################################################################
2694 class UploadBlock(object):
2695 def __init__(self, *args, **kwargs):
2699 return '<UploadBlock %s (%s)>' % (self.source, self.upload_block_id)
2701 __all__.append('UploadBlock')
2703 ################################################################################
2705 class DBConn(object):
2707 database module init.
2711 def __init__(self, *args, **kwargs):
2712 self.__dict__ = self.__shared_state
2714 if not getattr(self, 'initialised', False):
2715 self.initialised = True
2716 self.debug = kwargs.has_key('debug')
2719 def __setuptables(self):
2728 'build_queue_files',
2731 'content_associations',
2732 'content_file_names',
2733 'content_file_paths',
2734 'changes_pending_binaries',
2735 'changes_pending_files',
2736 'changes_pending_files_map',
2737 'changes_pending_source',
2738 'changes_pending_source_files',
2739 'changes_pool_files',
2751 'pending_content_associations',
2761 'suite_architectures',
2762 'suite_src_formats',
2763 'suite_build_queue_copy',
2768 for table_name in tables:
2769 table = Table(table_name, self.db_meta, autoload=True)
2770 setattr(self, 'tbl_%s' % table_name, table)
2772 def __setupmappers(self):
2773 mapper(Architecture, self.tbl_architecture,
2774 properties = dict(arch_id = self.tbl_architecture.c.id))
2776 mapper(Archive, self.tbl_archive,
2777 properties = dict(archive_id = self.tbl_archive.c.id,
2778 archive_name = self.tbl_archive.c.name))
2780 mapper(BinAssociation, self.tbl_bin_associations,
2781 properties = dict(ba_id = self.tbl_bin_associations.c.id,
2782 suite_id = self.tbl_bin_associations.c.suite,
2783 suite = relation(Suite),
2784 binary_id = self.tbl_bin_associations.c.bin,
2785 binary = relation(DBBinary)))
2787 mapper(BuildQueue, self.tbl_build_queue,
2788 properties = dict(queue_id = self.tbl_build_queue.c.id))
2790 mapper(BuildQueueFile, self.tbl_build_queue_files,
2791 properties = dict(buildqueue = relation(BuildQueue, backref='queuefiles'),
2792 poolfile = relation(PoolFile, backref='buildqueueinstances')))
2794 mapper(DBBinary, self.tbl_binaries,
2795 properties = dict(binary_id = self.tbl_binaries.c.id,
2796 package = self.tbl_binaries.c.package,
2797 version = self.tbl_binaries.c.version,
2798 maintainer_id = self.tbl_binaries.c.maintainer,
2799 maintainer = relation(Maintainer),
2800 source_id = self.tbl_binaries.c.source,
2801 source = relation(DBSource),
2802 arch_id = self.tbl_binaries.c.architecture,
2803 architecture = relation(Architecture),
2804 poolfile_id = self.tbl_binaries.c.file,
2805 poolfile = relation(PoolFile),
2806 binarytype = self.tbl_binaries.c.type,
2807 fingerprint_id = self.tbl_binaries.c.sig_fpr,
2808 fingerprint = relation(Fingerprint),
2809 install_date = self.tbl_binaries.c.install_date,
2810 binassociations = relation(BinAssociation,
2811 primaryjoin=(self.tbl_binaries.c.id==self.tbl_bin_associations.c.bin))))
2813 mapper(BinaryACL, self.tbl_binary_acl,
2814 properties = dict(binary_acl_id = self.tbl_binary_acl.c.id))
2816 mapper(BinaryACLMap, self.tbl_binary_acl_map,
2817 properties = dict(binary_acl_map_id = self.tbl_binary_acl_map.c.id,
2818 fingerprint = relation(Fingerprint, backref="binary_acl_map"),
2819 architecture = relation(Architecture)))
2821 mapper(Component, self.tbl_component,
2822 properties = dict(component_id = self.tbl_component.c.id,
2823 component_name = self.tbl_component.c.name))
2825 mapper(DBConfig, self.tbl_config,
2826 properties = dict(config_id = self.tbl_config.c.id))
2828 mapper(DSCFile, self.tbl_dsc_files,
2829 properties = dict(dscfile_id = self.tbl_dsc_files.c.id,
2830 source_id = self.tbl_dsc_files.c.source,
2831 source = relation(DBSource),
2832 poolfile_id = self.tbl_dsc_files.c.file,
2833 poolfile = relation(PoolFile)))
2835 mapper(PoolFile, self.tbl_files,
2836 properties = dict(file_id = self.tbl_files.c.id,
2837 filesize = self.tbl_files.c.size,
2838 location_id = self.tbl_files.c.location,
2839 location = relation(Location)))
2841 mapper(Fingerprint, self.tbl_fingerprint,
2842 properties = dict(fingerprint_id = self.tbl_fingerprint.c.id,
2843 uid_id = self.tbl_fingerprint.c.uid,
2844 uid = relation(Uid),
2845 keyring_id = self.tbl_fingerprint.c.keyring,
2846 keyring = relation(Keyring),
2847 source_acl = relation(SourceACL),
2848 binary_acl = relation(BinaryACL)))
2850 mapper(Keyring, self.tbl_keyrings,
2851 properties = dict(keyring_name = self.tbl_keyrings.c.name,
2852 keyring_id = self.tbl_keyrings.c.id))
2854 mapper(DBChange, self.tbl_changes,
2855 properties = dict(change_id = self.tbl_changes.c.id,
2856 poolfiles = relation(PoolFile,
2857 secondary=self.tbl_changes_pool_files,
2858 backref="changeslinks"),
2859 seen = self.tbl_changes.c.seen,
2860 source = self.tbl_changes.c.source,
2861 binaries = self.tbl_changes.c.binaries,
2862 architecture = self.tbl_changes.c.architecture,
2863 distribution = self.tbl_changes.c.distribution,
2864 urgency = self.tbl_changes.c.urgency,
2865 maintainer = self.tbl_changes.c.maintainer,
2866 changedby = self.tbl_changes.c.changedby,
2867 date = self.tbl_changes.c.date,
2868 version = self.tbl_changes.c.version,
2869 files = relation(ChangePendingFile,
2870 secondary=self.tbl_changes_pending_files_map,
2871 backref="changesfile"),
2872 in_queue_id = self.tbl_changes.c.in_queue,
2873 in_queue = relation(PolicyQueue,
2874 primaryjoin=(self.tbl_changes.c.in_queue==self.tbl_policy_queue.c.id)),
2875 approved_for_id = self.tbl_changes.c.approved_for))
2877 mapper(ChangePendingBinary, self.tbl_changes_pending_binaries,
2878 properties = dict(change_pending_binary_id = self.tbl_changes_pending_binaries.c.id))
2880 mapper(ChangePendingFile, self.tbl_changes_pending_files,
2881 properties = dict(change_pending_file_id = self.tbl_changes_pending_files.c.id,
2882 filename = self.tbl_changes_pending_files.c.filename,
2883 size = self.tbl_changes_pending_files.c.size,
2884 md5sum = self.tbl_changes_pending_files.c.md5sum,
2885 sha1sum = self.tbl_changes_pending_files.c.sha1sum,
2886 sha256sum = self.tbl_changes_pending_files.c.sha256sum))
2888 mapper(ChangePendingSource, self.tbl_changes_pending_source,
2889 properties = dict(change_pending_source_id = self.tbl_changes_pending_source.c.id,
2890 change = relation(DBChange),
2891 maintainer = relation(Maintainer,
2892 primaryjoin=(self.tbl_changes_pending_source.c.maintainer_id==self.tbl_maintainer.c.id)),
2893 changedby = relation(Maintainer,
2894 primaryjoin=(self.tbl_changes_pending_source.c.changedby_id==self.tbl_maintainer.c.id)),
2895 fingerprint = relation(Fingerprint),
2896 source_files = relation(ChangePendingFile,
2897 secondary=self.tbl_changes_pending_source_files,
2898 backref="pending_sources")))
2899 mapper(KeyringACLMap, self.tbl_keyring_acl_map,
2900 properties = dict(keyring_acl_map_id = self.tbl_keyring_acl_map.c.id,
2901 keyring = relation(Keyring, backref="keyring_acl_map"),
2902 architecture = relation(Architecture)))
2904 mapper(Location, self.tbl_location,
2905 properties = dict(location_id = self.tbl_location.c.id,
2906 component_id = self.tbl_location.c.component,
2907 component = relation(Component),
2908 archive_id = self.tbl_location.c.archive,
2909 archive = relation(Archive),
2910 archive_type = self.tbl_location.c.type))
2912 mapper(Maintainer, self.tbl_maintainer,
2913 properties = dict(maintainer_id = self.tbl_maintainer.c.id))
2915 mapper(NewComment, self.tbl_new_comments,
2916 properties = dict(comment_id = self.tbl_new_comments.c.id))
2918 mapper(Override, self.tbl_override,
2919 properties = dict(suite_id = self.tbl_override.c.suite,
2920 suite = relation(Suite),
2921 component_id = self.tbl_override.c.component,
2922 component = relation(Component),
2923 priority_id = self.tbl_override.c.priority,
2924 priority = relation(Priority),
2925 section_id = self.tbl_override.c.section,
2926 section = relation(Section),
2927 overridetype_id = self.tbl_override.c.type,
2928 overridetype = relation(OverrideType)))
2930 mapper(OverrideType, self.tbl_override_type,
2931 properties = dict(overridetype = self.tbl_override_type.c.type,
2932 overridetype_id = self.tbl_override_type.c.id))
2934 mapper(PolicyQueue, self.tbl_policy_queue,
2935 properties = dict(policy_queue_id = self.tbl_policy_queue.c.id))
2937 mapper(Priority, self.tbl_priority,
2938 properties = dict(priority_id = self.tbl_priority.c.id))
2940 mapper(Section, self.tbl_section,
2941 properties = dict(section_id = self.tbl_section.c.id))
2943 mapper(DBSource, self.tbl_source,
2944 properties = dict(source_id = self.tbl_source.c.id,
2945 version = self.tbl_source.c.version,
2946 maintainer_id = self.tbl_source.c.maintainer,
2947 maintainer = relation(Maintainer,
2948 primaryjoin=(self.tbl_source.c.maintainer==self.tbl_maintainer.c.id)),
2949 poolfile_id = self.tbl_source.c.file,
2950 poolfile = relation(PoolFile),
2951 fingerprint_id = self.tbl_source.c.sig_fpr,
2952 fingerprint = relation(Fingerprint),
2953 changedby_id = self.tbl_source.c.changedby,
2954 changedby = relation(Maintainer,
2955 primaryjoin=(self.tbl_source.c.changedby==self.tbl_maintainer.c.id)),
2956 srcfiles = relation(DSCFile,
2957 primaryjoin=(self.tbl_source.c.id==self.tbl_dsc_files.c.source)),
2958 srcassociations = relation(SrcAssociation,
2959 primaryjoin=(self.tbl_source.c.id==self.tbl_src_associations.c.source)),
2960 srcuploaders = relation(SrcUploader)))
2962 mapper(SourceACL, self.tbl_source_acl,
2963 properties = dict(source_acl_id = self.tbl_source_acl.c.id))
2965 mapper(SrcAssociation, self.tbl_src_associations,
2966 properties = dict(sa_id = self.tbl_src_associations.c.id,
2967 suite_id = self.tbl_src_associations.c.suite,
2968 suite = relation(Suite),
2969 source_id = self.tbl_src_associations.c.source,
2970 source = relation(DBSource)))
2972 mapper(SrcFormat, self.tbl_src_format,
2973 properties = dict(src_format_id = self.tbl_src_format.c.id,
2974 format_name = self.tbl_src_format.c.format_name))
2976 mapper(SrcUploader, self.tbl_src_uploaders,
2977 properties = dict(uploader_id = self.tbl_src_uploaders.c.id,
2978 source_id = self.tbl_src_uploaders.c.source,
2979 source = relation(DBSource,
2980 primaryjoin=(self.tbl_src_uploaders.c.source==self.tbl_source.c.id)),
2981 maintainer_id = self.tbl_src_uploaders.c.maintainer,
2982 maintainer = relation(Maintainer,
2983 primaryjoin=(self.tbl_src_uploaders.c.maintainer==self.tbl_maintainer.c.id))))
2985 mapper(Suite, self.tbl_suite,
2986 properties = dict(suite_id = self.tbl_suite.c.id,
2987 policy_queue = relation(PolicyQueue),
2988 copy_queues = relation(BuildQueue, secondary=self.tbl_suite_build_queue_copy)))
2990 mapper(SuiteArchitecture, self.tbl_suite_architectures,
2991 properties = dict(suite_id = self.tbl_suite_architectures.c.suite,
2992 suite = relation(Suite, backref='suitearchitectures'),
2993 arch_id = self.tbl_suite_architectures.c.architecture,
2994 architecture = relation(Architecture)))
2996 mapper(SuiteSrcFormat, self.tbl_suite_src_formats,
2997 properties = dict(suite_id = self.tbl_suite_src_formats.c.suite,
2998 suite = relation(Suite, backref='suitesrcformats'),
2999 src_format_id = self.tbl_suite_src_formats.c.src_format,
3000 src_format = relation(SrcFormat)))
3002 mapper(Uid, self.tbl_uid,
3003 properties = dict(uid_id = self.tbl_uid.c.id,
3004 fingerprint = relation(Fingerprint)))
3006 mapper(UploadBlock, self.tbl_upload_blocks,
3007 properties = dict(upload_block_id = self.tbl_upload_blocks.c.id,
3008 fingerprint = relation(Fingerprint, backref="uploadblocks"),
3009 uid = relation(Uid, backref="uploadblocks")))
3011 ## Connection functions
3012 def __createconn(self):
3013 from config import Config
3017 connstr = "postgres://%s" % cnf["DB::Host"]
3018 if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
3019 connstr += ":%s" % cnf["DB::Port"]
3020 connstr += "/%s" % cnf["DB::Name"]
3023 connstr = "postgres:///%s" % cnf["DB::Name"]
3024 if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
3025 connstr += "?port=%s" % cnf["DB::Port"]
3027 self.db_pg = create_engine(connstr, echo=self.debug)
3028 self.db_meta = MetaData()
3029 self.db_meta.bind = self.db_pg
3030 self.db_smaker = sessionmaker(bind=self.db_pg,
3034 self.__setuptables()
3035 self.__setupmappers()
3038 return self.db_smaker()
3040 __all__.append('DBConn')