daklib/dbconn.py

   1 #!/usr/bin/python
   2
   3 """ DB access class
   4
   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
  11 """
  12
  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.
  17
  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.
  22
  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
  26
  27 ################################################################################
  28
  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"
  33
  34 ################################################################################
  35
  36 import os
  37 import re
  38 import psycopg2
  39 import traceback
  40 import datetime
  41
  42 from inspect import getargspec
  43
  44 import sqlalchemy
  45 from sqlalchemy import create_engine, Table, MetaData
  46 from sqlalchemy.orm import sessionmaker, mapper, relation
  47 from sqlalchemy import types as sqltypes
  48
  49 # Don't remove this, we re-export the exceptions to scripts which import us
  50 from sqlalchemy.exc import *
  51 from sqlalchemy.orm.exc import NoResultFound
  52
  53 # Only import Config until Queue stuff is changed to store its config
  54 # in the database
  55 from config import Config
  56 from singleton import Singleton
  57 from textutils import fix_maintainer
  58
  59 ################################################################################
  60
  61 # Patch in support for the debversion field type so that it works during
  62 # reflection
  63
  64 class DebVersion(sqltypes.Text):
  65     def get_col_spec(self):
  66         return "DEBVERSION"
  67
  68 sa_major_version = sqlalchemy.__version__[0:3]
  69 if sa_major_version == "0.5":
  70     from sqlalchemy.databases import postgres
  71     postgres.ischema_names['debversion'] = DebVersion
  72 else:
  73     raise Exception("dak isn't ported to SQLA versions != 0.5 yet.  See daklib/dbconn.py")
  74
  75 ################################################################################
  76
  77 __all__ = ['IntegrityError', 'SQLAlchemyError']
  78
  79 ################################################################################
  80
  81 def session_wrapper(fn):
  82     """
  83     Wrapper around common ".., session=None):" handling. If the wrapped
  84     function is called without passing 'session', we create a local one
  85     and destroy it when the function ends.
  86
  87     Also attaches a commit_or_flush method to the session; if we created a
  88     local session, this is a synonym for session.commit(), otherwise it is a
  89     synonym for session.flush().
  90     """
  91
  92     def wrapped(*args, **kwargs):
  93         private_transaction = False
  94
  95         # Find the session object
  96         session = kwargs.get('session')
  97
  98         if session is None:
  99             if len(args) <= len(getargspec(fn)[0]) - 1:
 100                 # No session specified as last argument or in kwargs
 101                 private_transaction = True
 102                 session = kwargs['session'] = DBConn().session()
 103             else:
 104                 # Session is last argument in args
 105                 session = args[-1]
 106                 if session is None:
 107                     args = list(args)
 108                     session = args[-1] = DBConn().session()
 109                     private_transaction = True
 110
 111         if private_transaction:
 112             session.commit_or_flush = session.commit
 113         else:
 114             session.commit_or_flush = session.flush
 115
 116         try:
 117             return fn(*args, **kwargs)
 118         finally:
 119             if private_transaction:
 120                 # We created a session; close it.
 121                 session.close()
 122
 123     wrapped.__doc__ = fn.__doc__
 124     wrapped.func_name = fn.func_name
 125
 126     return wrapped
 127
 128 ################################################################################
 129
 130 class Architecture(object):
 131     def __init__(self, *args, **kwargs):
 132         pass
 133
 134     def __eq__(self, val):
 135         if isinstance(val, str):
 136             return (self.arch_string== val)
 137         # This signals to use the normal comparison operator
 138         return NotImplemented
 139
 140     def __ne__(self, val):
 141         if isinstance(val, str):
 142             return (self.arch_string != val)
 143         # This signals to use the normal comparison operator
 144         return NotImplemented
 145
 146     def __repr__(self):
 147         return '<Architecture %s>' % self.arch_string
 148
 149 __all__.append('Architecture')
 150
 151 @session_wrapper
 152 def get_architecture(architecture, session=None):
 153     """
 154     Returns database id for given C{architecture}.
 155
 156     @type architecture: string
 157     @param architecture: The name of the architecture
 158
 159     @type session: Session
 160     @param session: Optional SQLA session object (a temporary one will be
 161     generated if not supplied)
 162
 163     @rtype: Architecture
 164     @return: Architecture object for the given arch (None if not present)
 165     """
 166
 167     q = session.query(Architecture).filter_by(arch_string=architecture)
 168
 169     try:
 170         return q.one()
 171     except NoResultFound:
 172         return None
 173
 174 __all__.append('get_architecture')
 175
 176 @session_wrapper
 177 def get_architecture_suites(architecture, session=None):
 178     """
 179     Returns list of Suite objects for given C{architecture} name
 180
 181     @type source: str
 182     @param source: Architecture name to search for
 183
 184     @type session: Session
 185     @param session: Optional SQL session object (a temporary one will be
 186     generated if not supplied)
 187
 188     @rtype: list
 189     @return: list of Suite objects for the given name (may be empty)
 190     """
 191
 192     q = session.query(Suite)
 193     q = q.join(SuiteArchitecture)
 194     q = q.join(Architecture).filter_by(arch_string=architecture).order_by('suite_name')
 195
 196     ret = q.all()
 197
 198     return ret
 199
 200 __all__.append('get_architecture_suites')
 201
 202 ################################################################################
 203
 204 class Archive(object):
 205     def __init__(self, *args, **kwargs):
 206         pass
 207
 208     def __repr__(self):
 209         return '<Archive %s>' % self.archive_name
 210
 211 __all__.append('Archive')
 212
 213 @session_wrapper
 214 def get_archive(archive, session=None):
 215     """
 216     returns database id for given C{archive}.
 217
 218     @type archive: string
 219     @param archive: the name of the arhive
 220
 221     @type session: Session
 222     @param session: Optional SQLA session object (a temporary one will be
 223     generated if not supplied)
 224
 225     @rtype: Archive
 226     @return: Archive object for the given name (None if not present)
 227
 228     """
 229     archive = archive.lower()
 230
 231     q = session.query(Archive).filter_by(archive_name=archive)
 232
 233     try:
 234         return q.one()
 235     except NoResultFound:
 236         return None
 237
 238 __all__.append('get_archive')
 239
 240 ################################################################################
 241
 242 class BinAssociation(object):
 243     def __init__(self, *args, **kwargs):
 244         pass
 245
 246     def __repr__(self):
 247         return '<BinAssociation %s (%s, %s)>' % (self.ba_id, self.binary, self.suite)
 248
 249 __all__.append('BinAssociation')
 250
 251 ################################################################################
 252
 253 class BinContents(object):
 254     def __init__(self, *args, **kwargs):
 255         pass
 256
 257     def __repr__(self):
 258         return '<BinContents (%s, %s)>' % (self.binary, self.filename)
 259
 260 __all__.append('BinContents')
 261
 262 ################################################################################
 263
 264 class DBBinary(object):
 265     def __init__(self, *args, **kwargs):
 266         pass
 267
 268     def __repr__(self):
 269         return '<DBBinary %s (%s, %s)>' % (self.package, self.version, self.architecture)
 270
 271 __all__.append('DBBinary')
 272
 273 @session_wrapper
 274 def get_suites_binary_in(package, session=None):
 275     """
 276     Returns list of Suite objects which given C{package} name is in
 277
 278     @type source: str
 279     @param source: DBBinary package name to search for
 280
 281     @rtype: list
 282     @return: list of Suite objects for the given package
 283     """
 284
 285     return session.query(Suite).join(BinAssociation).join(DBBinary).filter_by(package=package).all()
 286
 287 __all__.append('get_suites_binary_in')
 288
 289 @session_wrapper
 290 def get_binary_from_id(binary_id, session=None):
 291     """
 292     Returns DBBinary object for given C{id}
 293
 294     @type binary_id: int
 295     @param binary_id: Id of the required binary
 296
 297     @type session: Session
 298     @param session: Optional SQLA session object (a temporary one will be
 299     generated if not supplied)
 300
 301     @rtype: DBBinary
 302     @return: DBBinary object for the given binary (None if not present)
 303     """
 304
 305     q = session.query(DBBinary).filter_by(binary_id=binary_id)
 306
 307     try:
 308         return q.one()
 309     except NoResultFound:
 310         return None
 311
 312 __all__.append('get_binary_from_id')
 313
 314 @session_wrapper
 315 def get_binaries_from_name(package, version=None, architecture=None, session=None):
 316     """
 317     Returns list of DBBinary objects for given C{package} name
 318
 319     @type package: str
 320     @param package: DBBinary package name to search for
 321
 322     @type version: str or None
 323     @param version: Version to search for (or None)
 324
 325     @type package: str, list or None
 326     @param package: Architectures to limit to (or None if no limit)
 327
 328     @type session: Session
 329     @param session: Optional SQL session object (a temporary one will be
 330     generated if not supplied)
 331
 332     @rtype: list
 333     @return: list of DBBinary objects for the given name (may be empty)
 334     """
 335
 336     q = session.query(DBBinary).filter_by(package=package)
 337
 338     if version is not None:
 339         q = q.filter_by(version=version)
 340
 341     if architecture is not None:
 342         if not isinstance(architecture, list):
 343             architecture = [architecture]
 344         q = q.join(Architecture).filter(Architecture.arch_string.in_(architecture))
 345
 346     ret = q.all()
 347
 348     return ret
 349
 350 __all__.append('get_binaries_from_name')
 351
 352 @session_wrapper
 353 def get_binaries_from_source_id(source_id, session=None):
 354     """
 355     Returns list of DBBinary objects for given C{source_id}
 356
 357     @type source_id: int
 358     @param source_id: source_id to search for
 359
 360     @type session: Session
 361     @param session: Optional SQL session object (a temporary one will be
 362     generated if not supplied)
 363
 364     @rtype: list
 365     @return: list of DBBinary objects for the given name (may be empty)
 366     """
 367
 368     return session.query(DBBinary).filter_by(source_id=source_id).all()
 369
 370 __all__.append('get_binaries_from_source_id')
 371
 372 @session_wrapper
 373 def get_binary_from_name_suite(package, suitename, session=None):
 374     ### For dak examine-package
 375     ### XXX: Doesn't use object API yet
 376
 377     sql = """SELECT DISTINCT(b.package), b.version, c.name, su.suite_name
 378              FROM binaries b, files fi, location l, component c, bin_associations ba, suite su
 379              WHERE b.package=:package
 380                AND b.file = fi.id
 381                AND fi.location = l.id
 382                AND l.component = c.id
 383                AND ba.bin=b.id
 384                AND ba.suite = su.id
 385                AND su.suite_name=:suitename
 386           ORDER BY b.version DESC"""
 387
 388     return session.execute(sql, {'package': package, 'suitename': suitename})
 389
 390 __all__.append('get_binary_from_name_suite')
 391
 392 @session_wrapper
 393 def get_binary_components(package, suitename, arch, session=None):
 394     # Check for packages that have moved from one component to another
 395     query = """SELECT c.name FROM binaries b, bin_associations ba, suite s, location l, component c, architecture a, files f
 396     WHERE b.package=:package AND s.suite_name=:suitename
 397       AND (a.arch_string = :arch OR a.arch_string = 'all')
 398       AND ba.bin = b.id AND ba.suite = s.id AND b.architecture = a.id
 399       AND f.location = l.id
 400       AND l.component = c.id
 401       AND b.file = f.id"""
 402
 403     vals = {'package': package, 'suitename': suitename, 'arch': arch}
 404
 405     return session.execute(query, vals)
 406
 407 __all__.append('get_binary_components')
 408
 409 ################################################################################
 410
 411 class BinaryACL(object):
 412     def __init__(self, *args, **kwargs):
 413         pass
 414
 415     def __repr__(self):
 416         return '<BinaryACL %s>' % self.binary_acl_id
 417
 418 __all__.append('BinaryACL')
 419
 420 ################################################################################
 421
 422 class BinaryACLMap(object):
 423     def __init__(self, *args, **kwargs):
 424         pass
 425
 426     def __repr__(self):
 427         return '<BinaryACLMap %s>' % self.binary_acl_map_id
 428
 429 __all__.append('BinaryACLMap')
 430
 431 ################################################################################
 432
 433 class Component(object):
 434     def __init__(self, *args, **kwargs):
 435         pass
 436
 437     def __eq__(self, val):
 438         if isinstance(val, str):
 439             return (self.component_name == val)
 440         # This signals to use the normal comparison operator
 441         return NotImplemented
 442
 443     def __ne__(self, val):
 444         if isinstance(val, str):
 445             return (self.component_name != val)
 446         # This signals to use the normal comparison operator
 447         return NotImplemented
 448
 449     def __repr__(self):
 450         return '<Component %s>' % self.component_name
 451
 452
 453 __all__.append('Component')
 454
 455 @session_wrapper
 456 def get_component(component, session=None):
 457     """
 458     Returns database id for given C{component}.
 459
 460     @type component: string
 461     @param component: The name of the override type
 462
 463     @rtype: int
 464     @return: the database id for the given component
 465
 466     """
 467     component = component.lower()
 468
 469     q = session.query(Component).filter_by(component_name=component)
 470
 471     try:
 472         return q.one()
 473     except NoResultFound:
 474         return None
 475
 476 __all__.append('get_component')
 477
 478 ################################################################################
 479
 480 class DBConfig(object):
 481     def __init__(self, *args, **kwargs):
 482         pass
 483
 484     def __repr__(self):
 485         return '<DBConfig %s>' % self.name
 486
 487 __all__.append('DBConfig')
 488
 489 ################################################################################
 490
 491 @session_wrapper
 492 def get_or_set_contents_file_id(filename, session=None):
 493     """
 494     Returns database id for given filename.
 495
 496     If no matching file is found, a row is inserted.
 497
 498     @type filename: string
 499     @param filename: The filename
 500     @type session: SQLAlchemy
 501     @param session: Optional SQL session object (a temporary one will be
 502     generated if not supplied).  If not passed, a commit will be performed at
 503     the end of the function, otherwise the caller is responsible for commiting.
 504
 505     @rtype: int
 506     @return: the database id for the given component
 507     """
 508
 509     q = session.query(ContentFilename).filter_by(filename=filename)
 510
 511     try:
 512         ret = q.one().cafilename_id
 513     except NoResultFound:
 514         cf = ContentFilename()
 515         cf.filename = filename
 516         session.add(cf)
 517         session.commit_or_flush()
 518         ret = cf.cafilename_id
 519
 520     return ret
 521
 522 __all__.append('get_or_set_contents_file_id')
 523
 524 @session_wrapper
 525 def get_contents(suite, overridetype, section=None, session=None):
 526     """
 527     Returns contents for a suite / overridetype combination, limiting
 528     to a section if not None.
 529
 530     @type suite: Suite
 531     @param suite: Suite object
 532
 533     @type overridetype: OverrideType
 534     @param overridetype: OverrideType object
 535
 536     @type section: Section
 537     @param section: Optional section object to limit results to
 538
 539     @type session: SQLAlchemy
 540     @param session: Optional SQL session object (a temporary one will be
 541     generated if not supplied)
 542
 543     @rtype: ResultsProxy
 544     @return: ResultsProxy object set up to return tuples of (filename, section,
 545     package, arch_id)
 546     """
 547
 548     # find me all of the contents for a given suite
 549     contents_q = """SELECT (p.path||'/'||n.file) AS fn,
 550                             s.section,
 551                             b.package,
 552                             b.architecture
 553                    FROM content_associations c join content_file_paths p ON (c.filepath=p.id)
 554                    JOIN content_file_names n ON (c.filename=n.id)
 555                    JOIN binaries b ON (b.id=c.binary_pkg)
 556                    JOIN override o ON (o.package=b.package)
 557                    JOIN section s ON (s.id=o.section)
 558                    WHERE o.suite = :suiteid AND o.type = :overridetypeid
 559                    AND b.type=:overridetypename"""
 560
 561     vals = {'suiteid': suite.suite_id,
 562             'overridetypeid': overridetype.overridetype_id,
 563             'overridetypename': overridetype.overridetype}
 564
 565     if section is not None:
 566         contents_q += " AND s.id = :sectionid"
 567         vals['sectionid'] = section.section_id
 568
 569     contents_q += " ORDER BY fn"
 570
 571     return session.execute(contents_q, vals)
 572
 573 __all__.append('get_contents')
 574
 575 ################################################################################
 576
 577 class ContentFilepath(object):
 578     def __init__(self, *args, **kwargs):
 579         pass
 580
 581     def __repr__(self):
 582         return '<ContentFilepath %s>' % self.filepath
 583
 584 __all__.append('ContentFilepath')
 585
 586 @session_wrapper
 587 def get_or_set_contents_path_id(filepath, session=None):
 588     """
 589     Returns database id for given path.
 590
 591     If no matching file is found, a row is inserted.
 592
 593     @type filename: string
 594     @param filename: The filepath
 595     @type session: SQLAlchemy
 596     @param session: Optional SQL session object (a temporary one will be
 597     generated if not supplied).  If not passed, a commit will be performed at
 598     the end of the function, otherwise the caller is responsible for commiting.
 599
 600     @rtype: int
 601     @return: the database id for the given path
 602     """
 603
 604     q = session.query(ContentFilepath).filter_by(filepath=filepath)
 605
 606     try:
 607         ret = q.one().cafilepath_id
 608     except NoResultFound:
 609         cf = ContentFilepath()
 610         cf.filepath = filepath
 611         session.add(cf)
 612         session.commit_or_flush()
 613         ret = cf.cafilepath_id
 614
 615     return ret
 616
 617 __all__.append('get_or_set_contents_path_id')
 618
 619 ################################################################################
 620
 621 class ContentAssociation(object):
 622     def __init__(self, *args, **kwargs):
 623         pass
 624
 625     def __repr__(self):
 626         return '<ContentAssociation %s>' % self.ca_id
 627
 628 __all__.append('ContentAssociation')
 629
 630 def insert_content_paths(binary_id, fullpaths, session=None):
 631     """
 632     Make sure given path is associated with given binary id
 633
 634     @type binary_id: int
 635     @param binary_id: the id of the binary
 636     @type fullpaths: list
 637     @param fullpaths: the list of paths of the file being associated with the binary
 638     @type session: SQLAlchemy session
 639     @param session: Optional SQLAlchemy session.  If this is passed, the caller
 640     is responsible for ensuring a transaction has begun and committing the
 641     results or rolling back based on the result code.  If not passed, a commit
 642     will be performed at the end of the function, otherwise the caller is
 643     responsible for commiting.
 644
 645     @return: True upon success
 646     """
 647
 648     privatetrans = False
 649     if session is None:
 650         session = DBConn().session()
 651         privatetrans = True
 652
 653     try:
 654         # Insert paths
 655         pathcache = {}
 656         for fullpath in fullpaths:
 657             if fullpath.startswith( './' ):
 658                 fullpath = fullpath[2:]
 659
 660             session.execute( "INSERT INTO bin_contents ( file, binary_id ) VALUES ( :filename, :id )", { 'filename': fullpath, 'id': binary_id}  )
 661
 662         session.commit()
 663         if privatetrans:
 664             session.close()
 665         return True
 666
 667     except:
 668         traceback.print_exc()
 669
 670         # Only rollback if we set up the session ourself
 671         if privatetrans:
 672             session.rollback()
 673             session.close()
 674
 675         return False
 676
 677 __all__.append('insert_content_paths')
 678
 679 ################################################################################
 680
 681 class DSCFile(object):
 682     def __init__(self, *args, **kwargs):
 683         pass
 684
 685     def __repr__(self):
 686         return '<DSCFile %s>' % self.dscfile_id
 687
 688 __all__.append('DSCFile')
 689
 690 @session_wrapper
 691 def get_dscfiles(dscfile_id=None, source_id=None, poolfile_id=None, session=None):
 692     """
 693     Returns a list of DSCFiles which may be empty
 694
 695     @type dscfile_id: int (optional)
 696     @param dscfile_id: the dscfile_id of the DSCFiles to find
 697
 698     @type source_id: int (optional)
 699     @param source_id: the source id related to the DSCFiles to find
 700
 701     @type poolfile_id: int (optional)
 702     @param poolfile_id: the poolfile id related to the DSCFiles to find
 703
 704     @rtype: list
 705     @return: Possibly empty list of DSCFiles
 706     """
 707
 708     q = session.query(DSCFile)
 709
 710     if dscfile_id is not None:
 711         q = q.filter_by(dscfile_id=dscfile_id)
 712
 713     if source_id is not None:
 714         q = q.filter_by(source_id=source_id)
 715
 716     if poolfile_id is not None:
 717         q = q.filter_by(poolfile_id=poolfile_id)
 718
 719     return q.all()
 720
 721 __all__.append('get_dscfiles')
 722
 723 ################################################################################
 724
 725 class PoolFile(object):
 726     def __init__(self, *args, **kwargs):
 727         pass
 728
 729     def __repr__(self):
 730         return '<PoolFile %s>' % self.filename
 731
 732     @property
 733     def fullpath(self):
 734         return os.path.join(self.location.path, self.filename)
 735
 736 __all__.append('PoolFile')
 737
 738 @session_wrapper
 739 def check_poolfile(filename, filesize, md5sum, location_id, session=None):
 740     """
 741     Returns a tuple:
 742      (ValidFileFound [boolean or None], PoolFile object or None)
 743
 744     @type filename: string
 745     @param filename: the filename of the file to check against the DB
 746
 747     @type filesize: int
 748     @param filesize: the size of the file to check against the DB
 749
 750     @type md5sum: string
 751     @param md5sum: the md5sum of the file to check against the DB
 752
 753     @type location_id: int
 754     @param location_id: the id of the location to look in
 755
 756     @rtype: tuple
 757     @return: Tuple of length 2.
 758              If more than one file found with that name:
 759                     (None,  None)
 760              If valid pool file found: (True, PoolFile object)
 761              If valid pool file not found:
 762                     (False, None) if no file found
 763                     (False, PoolFile object) if file found with size/md5sum mismatch
 764     """
 765
 766     q = session.query(PoolFile).filter_by(filename=filename)
 767     q = q.join(Location).filter_by(location_id=location_id)
 768
 769     ret = None
 770
 771     if q.count() > 1:
 772         ret = (None, None)
 773     elif q.count() < 1:
 774         ret = (False, None)
 775     else:
 776         obj = q.one()
 777         if obj.md5sum != md5sum or obj.filesize != int(filesize):
 778             ret = (False, obj)
 779
 780     if ret is None:
 781         ret = (True, obj)
 782
 783     return ret
 784
 785 __all__.append('check_poolfile')
 786
 787 @session_wrapper
 788 def get_poolfile_by_id(file_id, session=None):
 789     """
 790     Returns a PoolFile objects or None for the given id
 791
 792     @type file_id: int
 793     @param file_id: the id of the file to look for
 794
 795     @rtype: PoolFile or None
 796     @return: either the PoolFile object or None
 797     """
 798
 799     q = session.query(PoolFile).filter_by(file_id=file_id)
 800
 801     try:
 802         return q.one()
 803     except NoResultFound:
 804         return None
 805
 806 __all__.append('get_poolfile_by_id')
 807
 808
 809 @session_wrapper
 810 def get_poolfile_by_name(filename, location_id=None, session=None):
 811     """
 812     Returns an array of PoolFile objects for the given filename and
 813     (optionally) location_id
 814
 815     @type filename: string
 816     @param filename: the filename of the file to check against the DB
 817
 818     @type location_id: int
 819     @param location_id: the id of the location to look in (optional)
 820
 821     @rtype: array
 822     @return: array of PoolFile objects
 823     """
 824
 825     q = session.query(PoolFile).filter_by(filename=filename)
 826
 827     if location_id is not None:
 828         q = q.join(Location).filter_by(location_id=location_id)
 829
 830     return q.all()
 831
 832 __all__.append('get_poolfile_by_name')
 833
 834 @session_wrapper
 835 def get_poolfile_like_name(filename, session=None):
 836     """
 837     Returns an array of PoolFile objects which are like the given name
 838
 839     @type filename: string
 840     @param filename: the filename of the file to check against the DB
 841
 842     @rtype: array
 843     @return: array of PoolFile objects
 844     """
 845
 846     # TODO: There must be a way of properly using bind parameters with %FOO%
 847     q = session.query(PoolFile).filter(PoolFile.filename.like('%%%s%%' % filename))
 848
 849     return q.all()
 850
 851 __all__.append('get_poolfile_like_name')
 852
 853 ################################################################################
 854
 855 class Fingerprint(object):
 856     def __init__(self, *args, **kwargs):
 857         pass
 858
 859     def __repr__(self):
 860         return '<Fingerprint %s>' % self.fingerprint
 861
 862 __all__.append('Fingerprint')
 863
 864 @session_wrapper
 865 def get_fingerprint(fpr, session=None):
 866     """
 867     Returns Fingerprint object for given fpr.
 868
 869     @type fpr: string
 870     @param fpr: The fpr to find / add
 871
 872     @type session: SQLAlchemy
 873     @param session: Optional SQL session object (a temporary one will be
 874     generated if not supplied).
 875
 876     @rtype: Fingerprint
 877     @return: the Fingerprint object for the given fpr or None
 878     """
 879
 880     q = session.query(Fingerprint).filter_by(fingerprint=fpr)
 881
 882     try:
 883         ret = q.one()
 884     except NoResultFound:
 885         ret = None
 886
 887     return ret
 888
 889 __all__.append('get_fingerprint')
 890
 891 @session_wrapper
 892 def get_or_set_fingerprint(fpr, session=None):
 893     """
 894     Returns Fingerprint object for given fpr.
 895
 896     If no matching fpr is found, a row is inserted.
 897
 898     @type fpr: string
 899     @param fpr: The fpr to find / add
 900
 901     @type session: SQLAlchemy
 902     @param session: Optional SQL session object (a temporary one will be
 903     generated if not supplied).  If not passed, a commit will be performed at
 904     the end of the function, otherwise the caller is responsible for commiting.
 905     A flush will be performed either way.
 906
 907     @rtype: Fingerprint
 908     @return: the Fingerprint object for the given fpr
 909     """
 910
 911     q = session.query(Fingerprint).filter_by(fingerprint=fpr)
 912
 913     try:
 914         ret = q.one()
 915     except NoResultFound:
 916         fingerprint = Fingerprint()
 917         fingerprint.fingerprint = fpr
 918         session.add(fingerprint)
 919         session.commit_or_flush()
 920         ret = fingerprint
 921
 922     return ret
 923
 924 __all__.append('get_or_set_fingerprint')
 925
 926 ################################################################################
 927
 928 # Helper routine for Keyring class
 929 def get_ldap_name(entry):
 930     name = []
 931     for k in ["cn", "mn", "sn"]:
 932         ret = entry.get(k)
 933         if ret and ret[0] != "" and ret[0] != "-":
 934             name.append(ret[0])
 935     return " ".join(name)
 936
 937 ################################################################################
 938
 939 class Keyring(object):
 940     gpg_invocation = "gpg --no-default-keyring --keyring %s" +\
 941                      " --with-colons --fingerprint --fingerprint"
 942
 943     keys = {}
 944     fpr_lookup = {}
 945
 946     def __init__(self, *args, **kwargs):
 947         pass
 948
 949     def __repr__(self):
 950         return '<Keyring %s>' % self.keyring_name
 951
 952     def de_escape_gpg_str(self, txt):
 953         esclist = re.split(r'(\\x..)', txt)
 954         for x in range(1,len(esclist),2):
 955             esclist[x] = "%c" % (int(esclist[x][2:],16))
 956         return "".join(esclist)
 957
 958     def load_keys(self, keyring):
 959         import email.Utils
 960
 961         if not self.keyring_id:
 962             raise Exception('Must be initialized with database information')
 963
 964         k = os.popen(self.gpg_invocation % keyring, "r")
 965         key = None
 966         signingkey = False
 967
 968         for line in k.xreadlines():
 969             field = line.split(":")
 970             if field[0] == "pub":
 971                 key = field[4]
 972                 (name, addr) = email.Utils.parseaddr(field[9])
 973                 name = re.sub(r"\s*[(].*[)]", "", name)
 974                 if name == "" or addr == "" or "@" not in addr:
 975                     name = field[9]
 976                     addr = "invalid-uid"
 977                 name = self.de_escape_gpg_str(name)
 978                 self.keys[key] = {"email": addr}
 979                 if name != "":
 980                     self.keys[key]["name"] = name
 981                 self.keys[key]["aliases"] = [name]
 982                 self.keys[key]["fingerprints"] = []
 983                 signingkey = True
 984             elif key and field[0] == "sub" and len(field) >= 12:
 985                 signingkey = ("s" in field[11])
 986             elif key and field[0] == "uid":
 987                 (name, addr) = email.Utils.parseaddr(field[9])
 988                 if name and name not in self.keys[key]["aliases"]:
 989                     self.keys[key]["aliases"].append(name)
 990             elif signingkey and field[0] == "fpr":
 991                 self.keys[key]["fingerprints"].append(field[9])
 992                 self.fpr_lookup[field[9]] = key
 993
 994     def import_users_from_ldap(self, session):
 995         import ldap
 996         cnf = Config()
 997
 998         LDAPDn = cnf["Import-LDAP-Fingerprints::LDAPDn"]
 999         LDAPServer = cnf["Import-LDAP-Fingerprints::LDAPServer"]
1000
1001         l = ldap.open(LDAPServer)
1002         l.simple_bind_s("","")
1003         Attrs = l.search_s(LDAPDn, ldap.SCOPE_ONELEVEL,
1004                "(&(keyfingerprint=*)(gidnumber=%s))" % (cnf["Import-Users-From-Passwd::ValidGID"]),
1005                ["uid", "keyfingerprint", "cn", "mn", "sn"])
1006
1007         ldap_fin_uid_id = {}
1008
1009         byuid = {}
1010         byname = {}
1011
1012         for i in Attrs:
1013             entry = i[1]
1014             uid = entry["uid"][0]
1015             name = get_ldap_name(entry)
1016             fingerprints = entry["keyFingerPrint"]
1017             keyid = None
1018             for f in fingerprints:
1019                 key = self.fpr_lookup.get(f, None)
1020                 if key not in self.keys:
1021                     continue
1022                 self.keys[key]["uid"] = uid
1023
1024                 if keyid != None:
1025                     continue
1026                 keyid = get_or_set_uid(uid, session).uid_id
1027                 byuid[keyid] = (uid, name)
1028                 byname[uid] = (keyid, name)
1029
1030         return (byname, byuid)
1031
1032     def generate_users_from_keyring(self, format, session):
1033         byuid = {}
1034         byname = {}
1035         any_invalid = False
1036         for x in self.keys.keys():
1037             if self.keys[x]["email"] == "invalid-uid":
1038                 any_invalid = True
1039                 self.keys[x]["uid"] = format % "invalid-uid"
1040             else:
1041                 uid = format % self.keys[x]["email"]
1042                 keyid = get_or_set_uid(uid, session).uid_id
1043                 byuid[keyid] = (uid, self.keys[x]["name"])
1044                 byname[uid] = (keyid, self.keys[x]["name"])
1045                 self.keys[x]["uid"] = uid
1046
1047         if any_invalid:
1048             uid = format % "invalid-uid"
1049             keyid = get_or_set_uid(uid, session).uid_id
1050             byuid[keyid] = (uid, "ungeneratable user id")
1051             byname[uid] = (keyid, "ungeneratable user id")
1052
1053         return (byname, byuid)
1054
1055 __all__.append('Keyring')
1056
1057 @session_wrapper
1058 def get_keyring(keyring, session=None):
1059     """
1060     If C{keyring} does not have an entry in the C{keyrings} table yet, return None
1061     If C{keyring} already has an entry, simply return the existing Keyring
1062
1063     @type keyring: string
1064     @param keyring: the keyring name
1065
1066     @rtype: Keyring
1067     @return: the Keyring object for this keyring
1068     """
1069
1070     q = session.query(Keyring).filter_by(keyring_name=keyring)
1071
1072     try:
1073         return q.one()
1074     except NoResultFound:
1075         return None
1076
1077 __all__.append('get_keyring')
1078
1079 ################################################################################
1080
1081 class KeyringACLMap(object):
1082     def __init__(self, *args, **kwargs):
1083         pass
1084
1085     def __repr__(self):
1086         return '<KeyringACLMap %s>' % self.keyring_acl_map_id
1087
1088 __all__.append('KeyringACLMap')
1089
1090 ################################################################################
1091
1092 class KnownChange(object):
1093     def __init__(self, *args, **kwargs):
1094         pass
1095
1096     def __repr__(self):
1097         return '<KnownChange %s>' % self.changesname
1098
1099 __all__.append('KnownChange')
1100
1101 @session_wrapper
1102 def get_knownchange(filename, session=None):
1103     """
1104     returns knownchange object for given C{filename}.
1105
1106     @type archive: string
1107     @param archive: the name of the arhive
1108
1109     @type session: Session
1110     @param session: Optional SQLA session object (a temporary one will be
1111     generated if not supplied)
1112
1113     @rtype: Archive
1114     @return: Archive object for the given name (None if not present)
1115
1116     """
1117     q = session.query(KnownChange).filter_by(changesname=filename)
1118
1119     try:
1120         return q.one()
1121     except NoResultFound:
1122         return None
1123
1124 __all__.append('get_knownchange')
1125
1126 ################################################################################
1127
1128 class KnownChangePendingFile(object):
1129     def __init__(self, *args, **kwargs):
1130         pass
1131
1132     def __repr__(self):
1133         return '<KnownChangePendingFile %s>' % self.known_change_pending_file_id
1134
1135 __all__.append('KnownChangePendingFile')
1136
1137 ################################################################################
1138
1139 class Location(object):
1140     def __init__(self, *args, **kwargs):
1141         pass
1142
1143     def __repr__(self):
1144         return '<Location %s (%s)>' % (self.path, self.location_id)
1145
1146 __all__.append('Location')
1147
1148 @session_wrapper
1149 def get_location(location, component=None, archive=None, session=None):
1150     """
1151     Returns Location object for the given combination of location, component
1152     and archive
1153
1154     @type location: string
1155     @param location: the path of the location, e.g. I{/srv/ftp.debian.org/ftp/pool/}
1156
1157     @type component: string
1158     @param component: the component name (if None, no restriction applied)
1159
1160     @type archive: string
1161     @param archive_id: the archive name (if None, no restriction applied)
1162
1163     @rtype: Location / None
1164     @return: Either a Location object or None if one can't be found
1165     """
1166
1167     q = session.query(Location).filter_by(path=location)
1168
1169     if archive is not None:
1170         q = q.join(Archive).filter_by(archive_name=archive)
1171
1172     if component is not None:
1173         q = q.join(Component).filter_by(component_name=component)
1174
1175     try:
1176         return q.one()
1177     except NoResultFound:
1178         return None
1179
1180 __all__.append('get_location')
1181
1182 ################################################################################
1183
1184 class Maintainer(object):
1185     def __init__(self, *args, **kwargs):
1186         pass
1187
1188     def __repr__(self):
1189         return '''<Maintainer '%s' (%s)>''' % (self.name, self.maintainer_id)
1190
1191     def get_split_maintainer(self):
1192         if not hasattr(self, 'name') or self.name is None:
1193             return ('', '', '', '')
1194
1195         return fix_maintainer(self.name.strip())
1196
1197 __all__.append('Maintainer')
1198
1199 @session_wrapper
1200 def get_or_set_maintainer(name, session=None):
1201     """
1202     Returns Maintainer object for given maintainer name.
1203
1204     If no matching maintainer name is found, a row is inserted.
1205
1206     @type name: string
1207     @param name: The maintainer name to add
1208
1209     @type session: SQLAlchemy
1210     @param session: Optional SQL session object (a temporary one will be
1211     generated if not supplied).  If not passed, a commit will be performed at
1212     the end of the function, otherwise the caller is responsible for commiting.
1213     A flush will be performed either way.
1214
1215     @rtype: Maintainer
1216     @return: the Maintainer object for the given maintainer
1217     """
1218
1219     q = session.query(Maintainer).filter_by(name=name)
1220     try:
1221         ret = q.one()
1222     except NoResultFound:
1223         maintainer = Maintainer()
1224         maintainer.name = name
1225         session.add(maintainer)
1226         session.commit_or_flush()
1227         ret = maintainer
1228
1229     return ret
1230
1231 __all__.append('get_or_set_maintainer')
1232
1233 @session_wrapper
1234 def get_maintainer(maintainer_id, session=None):
1235     """
1236     Return the name of the maintainer behind C{maintainer_id} or None if that
1237     maintainer_id is invalid.
1238
1239     @type maintainer_id: int
1240     @param maintainer_id: the id of the maintainer
1241
1242     @rtype: Maintainer
1243     @return: the Maintainer with this C{maintainer_id}
1244     """
1245
1246     return session.query(Maintainer).get(maintainer_id)
1247
1248 __all__.append('get_maintainer')
1249
1250 ################################################################################
1251
1252 class NewComment(object):
1253     def __init__(self, *args, **kwargs):
1254         pass
1255
1256     def __repr__(self):
1257         return '''<NewComment for '%s %s' (%s)>''' % (self.package, self.version, self.comment_id)
1258
1259 __all__.append('NewComment')
1260
1261 @session_wrapper
1262 def has_new_comment(package, version, session=None):
1263     """
1264     Returns true if the given combination of C{package}, C{version} has a comment.
1265
1266     @type package: string
1267     @param package: name of the package
1268
1269     @type version: string
1270     @param version: package version
1271
1272     @type session: Session
1273     @param session: Optional SQLA session object (a temporary one will be
1274     generated if not supplied)
1275
1276     @rtype: boolean
1277     @return: true/false
1278     """
1279
1280     q = session.query(NewComment)
1281     q = q.filter_by(package=package)
1282     q = q.filter_by(version=version)
1283
1284     return bool(q.count() > 0)
1285
1286 __all__.append('has_new_comment')
1287
1288 @session_wrapper
1289 def get_new_comments(package=None, version=None, comment_id=None, session=None):
1290     """
1291     Returns (possibly empty) list of NewComment objects for the given
1292     parameters
1293
1294     @type package: string (optional)
1295     @param package: name of the package
1296
1297     @type version: string (optional)
1298     @param version: package version
1299
1300     @type comment_id: int (optional)
1301     @param comment_id: An id of a comment
1302
1303     @type session: Session
1304     @param session: Optional SQLA session object (a temporary one will be
1305     generated if not supplied)
1306
1307     @rtype: list
1308     @return: A (possibly empty) list of NewComment objects will be returned
1309     """
1310
1311     q = session.query(NewComment)
1312     if package is not None: q = q.filter_by(package=package)
1313     if version is not None: q = q.filter_by(version=version)
1314     if comment_id is not None: q = q.filter_by(comment_id=comment_id)
1315
1316     return q.all()
1317
1318 __all__.append('get_new_comments')
1319
1320 ################################################################################
1321
1322 class Override(object):
1323     def __init__(self, *args, **kwargs):
1324         pass
1325
1326     def __repr__(self):
1327         return '<Override %s (%s)>' % (self.package, self.suite_id)
1328
1329 __all__.append('Override')
1330
1331 @session_wrapper
1332 def get_override(package, suite=None, component=None, overridetype=None, session=None):
1333     """
1334     Returns Override object for the given parameters
1335
1336     @type package: string
1337     @param package: The name of the package
1338
1339     @type suite: string, list or None
1340     @param suite: The name of the suite (or suites if a list) to limit to.  If
1341                   None, don't limit.  Defaults to None.
1342
1343     @type component: string, list or None
1344     @param component: The name of the component (or components if a list) to
1345                       limit to.  If None, don't limit.  Defaults to None.
1346
1347     @type overridetype: string, list or None
1348     @param overridetype: The name of the overridetype (or overridetypes if a list) to
1349                          limit to.  If None, don't limit.  Defaults to None.
1350
1351     @type session: Session
1352     @param session: Optional SQLA session object (a temporary one will be
1353     generated if not supplied)
1354
1355     @rtype: list
1356     @return: A (possibly empty) list of Override objects will be returned
1357     """
1358
1359     q = session.query(Override)
1360     q = q.filter_by(package=package)
1361
1362     if suite is not None:
1363         if not isinstance(suite, list): suite = [suite]
1364         q = q.join(Suite).filter(Suite.suite_name.in_(suite))
1365
1366     if component is not None:
1367         if not isinstance(component, list): component = [component]
1368         q = q.join(Component).filter(Component.component_name.in_(component))
1369
1370     if overridetype is not None:
1371         if not isinstance(overridetype, list): overridetype = [overridetype]
1372         q = q.join(OverrideType).filter(OverrideType.overridetype.in_(overridetype))
1373
1374     return q.all()
1375
1376 __all__.append('get_override')
1377
1378
1379 ################################################################################
1380
1381 class OverrideType(object):
1382     def __init__(self, *args, **kwargs):
1383         pass
1384
1385     def __repr__(self):
1386         return '<OverrideType %s>' % self.overridetype
1387
1388 __all__.append('OverrideType')
1389
1390 @session_wrapper
1391 def get_override_type(override_type, session=None):
1392     """
1393     Returns OverrideType object for given C{override type}.
1394
1395     @type override_type: string
1396     @param override_type: The name of the override type
1397
1398     @type session: Session
1399     @param session: Optional SQLA session object (a temporary one will be
1400     generated if not supplied)
1401
1402     @rtype: int
1403     @return: the database id for the given override type
1404     """
1405
1406     q = session.query(OverrideType).filter_by(overridetype=override_type)
1407
1408     try:
1409         return q.one()
1410     except NoResultFound:
1411         return None
1412
1413 __all__.append('get_override_type')
1414
1415 ################################################################################
1416
1417 class PendingContentAssociation(object):
1418     def __init__(self, *args, **kwargs):
1419         pass
1420
1421     def __repr__(self):
1422         return '<PendingContentAssociation %s>' % self.pca_id
1423
1424 __all__.append('PendingContentAssociation')
1425
1426 def insert_pending_content_paths(package, fullpaths, session=None):
1427     """
1428     Make sure given paths are temporarily associated with given
1429     package
1430
1431     @type package: dict
1432     @param package: the package to associate with should have been read in from the binary control file
1433     @type fullpaths: list
1434     @param fullpaths: the list of paths of the file being associated with the binary
1435     @type session: SQLAlchemy session
1436     @param session: Optional SQLAlchemy session.  If this is passed, the caller
1437     is responsible for ensuring a transaction has begun and committing the
1438     results or rolling back based on the result code.  If not passed, a commit
1439     will be performed at the end of the function
1440
1441     @return: True upon success, False if there is a problem
1442     """
1443
1444     privatetrans = False
1445
1446     if session is None:
1447         session = DBConn().session()
1448         privatetrans = True
1449
1450     try:
1451         arch = get_architecture(package['Architecture'], session)
1452         arch_id = arch.arch_id
1453
1454         # Remove any already existing recorded files for this package
1455         q = session.query(PendingContentAssociation)
1456         q = q.filter_by(package=package['Package'])
1457         q = q.filter_by(version=package['Version'])
1458         q = q.filter_by(architecture=arch_id)
1459         q.delete()
1460
1461         # Insert paths
1462         pathcache = {}
1463         for fullpath in fullpaths:
1464             (path, filename) = os.path.split(fullpath)
1465
1466             if path.startswith( "./" ):
1467                 path = path[2:]
1468
1469             filepath_id = get_or_set_contents_path_id(path, session)
1470             filename_id = get_or_set_contents_file_id(filename, session)
1471
1472             pathcache[fullpath] = (filepath_id, filename_id)
1473
1474         for fullpath, dat in pathcache.items():
1475             pca = PendingContentAssociation()
1476             pca.package = package['Package']
1477             pca.version = package['Version']
1478             pca.filepath_id = dat[0]
1479             pca.filename_id = dat[1]
1480             pca.architecture = arch_id
1481             session.add(pca)
1482
1483         # Only commit if we set up the session ourself
1484         if privatetrans:
1485             session.commit()
1486             session.close()
1487         else:
1488             session.flush()
1489
1490         return True
1491     except Exception, e:
1492         traceback.print_exc()
1493
1494         # Only rollback if we set up the session ourself
1495         if privatetrans:
1496             session.rollback()
1497             session.close()
1498
1499         return False
1500
1501 __all__.append('insert_pending_content_paths')
1502
1503 ################################################################################
1504
1505 class Priority(object):
1506     def __init__(self, *args, **kwargs):
1507         pass
1508
1509     def __eq__(self, val):
1510         if isinstance(val, str):
1511             return (self.priority == val)
1512         # This signals to use the normal comparison operator
1513         return NotImplemented
1514
1515     def __ne__(self, val):
1516         if isinstance(val, str):
1517             return (self.priority != val)
1518         # This signals to use the normal comparison operator
1519         return NotImplemented
1520
1521     def __repr__(self):
1522         return '<Priority %s (%s)>' % (self.priority, self.priority_id)
1523
1524 __all__.append('Priority')
1525
1526 @session_wrapper
1527 def get_priority(priority, session=None):
1528     """
1529     Returns Priority object for given C{priority name}.
1530
1531     @type priority: string
1532     @param priority: The name of the priority
1533
1534     @type session: Session
1535     @param session: Optional SQLA session object (a temporary one will be
1536     generated if not supplied)
1537
1538     @rtype: Priority
1539     @return: Priority object for the given priority
1540     """
1541
1542     q = session.query(Priority).filter_by(priority=priority)
1543
1544     try:
1545         return q.one()
1546     except NoResultFound:
1547         return None
1548
1549 __all__.append('get_priority')
1550
1551 @session_wrapper
1552 def get_priorities(session=None):
1553     """
1554     Returns dictionary of priority names -> id mappings
1555
1556     @type session: Session
1557     @param session: Optional SQL session object (a temporary one will be
1558     generated if not supplied)
1559
1560     @rtype: dictionary
1561     @return: dictionary of priority names -> id mappings
1562     """
1563
1564     ret = {}
1565     q = session.query(Priority)
1566     for x in q.all():
1567         ret[x.priority] = x.priority_id
1568
1569     return ret
1570
1571 __all__.append('get_priorities')
1572
1573 ################################################################################
1574
1575 class Queue(object):
1576     def __init__(self, *args, **kwargs):
1577         pass
1578
1579     def __repr__(self):
1580         return '<Queue %s>' % self.queue_name
1581
1582     def add_file_from_pool(self, poolfile):
1583         """Copies a file into the pool.  Assumes that the PoolFile object is
1584         attached to the same SQLAlchemy session as the Queue object is.
1585
1586         The caller is responsible for committing after calling this function."""
1587         poolfile_basename = poolfile.filename[poolfile.filename.rindex(os.sep)+1:]
1588
1589         # Check if we have a file of this name or this ID already
1590         for f in self.queuefiles:
1591             if f.fileid is not None and f.fileid == poolfile.file_id or \
1592                f.poolfile.filename == poolfile_basename:
1593                    # In this case, update the QueueFile entry so we
1594                    # don't remove it too early
1595                    f.lastused = datetime.now()
1596                    DBConn().session().object_session(pf).add(f)
1597                    return f
1598
1599         # Prepare QueueFile object
1600         qf = QueueFile()
1601         qf.queue_id = self.queue_id
1602         qf.lastused = datetime.now()
1603         qf.filename = dest
1604
1605         targetpath = qf.fullpath
1606         queuepath = os.path.join(self.path, poolfile_basename)
1607
1608         try:
1609             if self.copy_pool_files:
1610                 # We need to copy instead of symlink
1611                 import utils
1612                 utils.copy(targetfile, queuepath)
1613                 # NULL in the fileid field implies a copy
1614                 qf.fileid = None
1615             else:
1616                 os.symlink(targetfile, queuepath)
1617                 qf.fileid = poolfile.file_id
1618         except OSError:
1619             return None
1620
1621         # Get the same session as the PoolFile is using and add the qf to it
1622         DBConn().session().object_session(poolfile).add(qf)
1623
1624         return qf
1625
1626
1627 __all__.append('Queue')
1628
1629 @session_wrapper
1630 def get_queue(queuename, session=None):
1631     """
1632     Returns Queue object for given C{queue name}, creating it if it does not
1633     exist.
1634
1635     @type queuename: string
1636     @param queuename: The name of the queue
1637
1638     @type session: Session
1639     @param session: Optional SQLA session object (a temporary one will be
1640     generated if not supplied)
1641
1642     @rtype: Queue
1643     @return: Queue object for the given queue
1644     """
1645
1646     q = session.query(Queue).filter_by(queue_name=queuename)
1647
1648     try:
1649         return q.one()
1650     except NoResultFound:
1651         return None
1652
1653 __all__.append('get_queue')
1654
1655 ################################################################################
1656
1657 class QueueFile(object):
1658     def __init__(self, *args, **kwargs):
1659         pass
1660
1661     def __repr__(self):
1662         return '<QueueFile %s (%s)>' % (self.filename, self.queue_id)
1663
1664 __all__.append('QueueFile')
1665
1666 ################################################################################
1667
1668 class Section(object):
1669     def __init__(self, *args, **kwargs):
1670         pass
1671
1672     def __eq__(self, val):
1673         if isinstance(val, str):
1674             return (self.section == val)
1675         # This signals to use the normal comparison operator
1676         return NotImplemented
1677
1678     def __ne__(self, val):
1679         if isinstance(val, str):
1680             return (self.section != val)
1681         # This signals to use the normal comparison operator
1682         return NotImplemented
1683
1684     def __repr__(self):
1685         return '<Section %s>' % self.section
1686
1687 __all__.append('Section')
1688
1689 @session_wrapper
1690 def get_section(section, session=None):
1691     """
1692     Returns Section object for given C{section name}.
1693
1694     @type section: string
1695     @param section: The name of the section
1696
1697     @type session: Session
1698     @param session: Optional SQLA session object (a temporary one will be
1699     generated if not supplied)
1700
1701     @rtype: Section
1702     @return: Section object for the given section name
1703     """
1704
1705     q = session.query(Section).filter_by(section=section)
1706
1707     try:
1708         return q.one()
1709     except NoResultFound:
1710         return None
1711
1712 __all__.append('get_section')
1713
1714 @session_wrapper
1715 def get_sections(session=None):
1716     """
1717     Returns dictionary of section names -> id mappings
1718
1719     @type session: Session
1720     @param session: Optional SQL session object (a temporary one will be
1721     generated if not supplied)
1722
1723     @rtype: dictionary
1724     @return: dictionary of section names -> id mappings
1725     """
1726
1727     ret = {}
1728     q = session.query(Section)
1729     for x in q.all():
1730         ret[x.section] = x.section_id
1731
1732     return ret
1733
1734 __all__.append('get_sections')
1735
1736 ################################################################################
1737
1738 class DBSource(object):
1739     def __init__(self, *args, **kwargs):
1740         pass
1741
1742     def __repr__(self):
1743         return '<DBSource %s (%s)>' % (self.source, self.version)
1744
1745 __all__.append('DBSource')
1746
1747 @session_wrapper
1748 def source_exists(source, source_version, suites = ["any"], session=None):
1749     """
1750     Ensure that source exists somewhere in the archive for the binary
1751     upload being processed.
1752       1. exact match     => 1.0-3
1753       2. bin-only NMU    => 1.0-3+b1 , 1.0-3.1+b1
1754
1755     @type package: string
1756     @param package: package source name
1757
1758     @type source_version: string
1759     @param source_version: expected source version
1760
1761     @type suites: list
1762     @param suites: list of suites to check in, default I{any}
1763
1764     @type session: Session
1765     @param session: Optional SQLA session object (a temporary one will be
1766     generated if not supplied)
1767
1768     @rtype: int
1769     @return: returns 1 if a source with expected version is found, otherwise 0
1770
1771     """
1772
1773     cnf = Config()
1774     ret = 1
1775
1776     for suite in suites:
1777         q = session.query(DBSource).filter_by(source=source)
1778         if suite != "any":
1779             # source must exist in suite X, or in some other suite that's
1780             # mapped to X, recursively... silent-maps are counted too,
1781             # unreleased-maps aren't.
1782             maps = cnf.ValueList("SuiteMappings")[:]
1783             maps.reverse()
1784             maps = [ m.split() for m in maps ]
1785             maps = [ (x[1], x[2]) for x in maps
1786                             if x[0] == "map" or x[0] == "silent-map" ]
1787             s = [suite]
1788             for x in maps:
1789                 if x[1] in s and x[0] not in s:
1790                     s.append(x[0])
1791
1792             q = q.join(SrcAssociation).join(Suite)
1793             q = q.filter(Suite.suite_name.in_(s))
1794
1795         # Reduce the query results to a list of version numbers
1796         ql = [ j.version for j in q.all() ]
1797
1798         # Try (1)
1799         if source_version in ql:
1800             continue
1801
1802         # Try (2)
1803         from daklib.regexes import re_bin_only_nmu
1804         orig_source_version = re_bin_only_nmu.sub('', source_version)
1805         if orig_source_version in ql:
1806             continue
1807
1808         # No source found so return not ok
1809         ret = 0
1810
1811     return ret
1812
1813 __all__.append('source_exists')
1814
1815 @session_wrapper
1816 def get_suites_source_in(source, session=None):
1817     """
1818     Returns list of Suite objects which given C{source} name is in
1819
1820     @type source: str
1821     @param source: DBSource package name to search for
1822
1823     @rtype: list
1824     @return: list of Suite objects for the given source
1825     """
1826
1827     return session.query(Suite).join(SrcAssociation).join(DBSource).filter_by(source=source).all()
1828
1829 __all__.append('get_suites_source_in')
1830
1831 @session_wrapper
1832 def get_sources_from_name(source, version=None, dm_upload_allowed=None, session=None):
1833     """
1834     Returns list of DBSource objects for given C{source} name and other parameters
1835
1836     @type source: str
1837     @param source: DBSource package name to search for
1838
1839     @type source: str or None
1840     @param source: DBSource version name to search for or None if not applicable
1841
1842     @type dm_upload_allowed: bool
1843     @param dm_upload_allowed: If None, no effect.  If True or False, only
1844     return packages with that dm_upload_allowed setting
1845
1846     @type session: Session
1847     @param session: Optional SQL session object (a temporary one will be
1848     generated if not supplied)
1849
1850     @rtype: list
1851     @return: list of DBSource objects for the given name (may be empty)
1852     """
1853
1854     q = session.query(DBSource).filter_by(source=source)
1855
1856     if version is not None:
1857         q = q.filter_by(version=version)
1858
1859     if dm_upload_allowed is not None:
1860         q = q.filter_by(dm_upload_allowed=dm_upload_allowed)
1861
1862     return q.all()
1863
1864 __all__.append('get_sources_from_name')
1865
1866 @session_wrapper
1867 def get_source_in_suite(source, suite, session=None):
1868     """
1869     Returns list of DBSource objects for a combination of C{source} and C{suite}.
1870
1871       - B{source} - source package name, eg. I{mailfilter}, I{bbdb}, I{glibc}
1872       - B{suite} - a suite name, eg. I{unstable}
1873
1874     @type source: string
1875     @param source: source package name
1876
1877     @type suite: string
1878     @param suite: the suite name
1879
1880     @rtype: string
1881     @return: the version for I{source} in I{suite}
1882
1883     """
1884
1885     q = session.query(SrcAssociation)
1886     q = q.join('source').filter_by(source=source)
1887     q = q.join('suite').filter_by(suite_name=suite)
1888
1889     try:
1890         return q.one().source
1891     except NoResultFound:
1892         return None
1893
1894 __all__.append('get_source_in_suite')
1895
1896 ################################################################################
1897
1898 class SourceACL(object):
1899     def __init__(self, *args, **kwargs):
1900         pass
1901
1902     def __repr__(self):
1903         return '<SourceACL %s>' % self.source_acl_id
1904
1905 __all__.append('SourceACL')
1906
1907 ################################################################################
1908
1909 class SrcAssociation(object):
1910     def __init__(self, *args, **kwargs):
1911         pass
1912
1913     def __repr__(self):
1914         return '<SrcAssociation %s (%s, %s)>' % (self.sa_id, self.source, self.suite)
1915
1916 __all__.append('SrcAssociation')
1917
1918 ################################################################################
1919
1920 class SrcFormat(object):
1921     def __init__(self, *args, **kwargs):
1922         pass
1923
1924     def __repr__(self):
1925         return '<SrcFormat %s>' % (self.format_name)
1926
1927 __all__.append('SrcFormat')
1928
1929 ################################################################################
1930
1931 class SrcUploader(object):
1932     def __init__(self, *args, **kwargs):
1933         pass
1934
1935     def __repr__(self):
1936         return '<SrcUploader %s>' % self.uploader_id
1937
1938 __all__.append('SrcUploader')
1939
1940 ################################################################################
1941
1942 SUITE_FIELDS = [ ('SuiteName', 'suite_name'),
1943                  ('SuiteID', 'suite_id'),
1944                  ('Version', 'version'),
1945                  ('Origin', 'origin'),
1946                  ('Label', 'label'),
1947                  ('Description', 'description'),
1948                  ('Untouchable', 'untouchable'),
1949                  ('Announce', 'announce'),
1950                  ('Codename', 'codename'),
1951                  ('OverrideCodename', 'overridecodename'),
1952                  ('ValidTime', 'validtime'),
1953                  ('Priority', 'priority'),
1954                  ('NotAutomatic', 'notautomatic'),
1955                  ('CopyChanges', 'copychanges'),
1956                  ('CopyDotDak', 'copydotdak'),
1957                  ('CommentsDir', 'commentsdir'),
1958                  ('OverrideSuite', 'overridesuite'),
1959                  ('ChangelogBase', 'changelogbase')]
1960
1961
1962 class Suite(object):
1963     def __init__(self, *args, **kwargs):
1964         pass
1965
1966     def __repr__(self):
1967         return '<Suite %s>' % self.suite_name
1968
1969     def __eq__(self, val):
1970         if isinstance(val, str):
1971             return (self.suite_name == val)
1972         # This signals to use the normal comparison operator
1973         return NotImplemented
1974
1975     def __ne__(self, val):
1976         if isinstance(val, str):
1977             return (self.suite_name != val)
1978         # This signals to use the normal comparison operator
1979         return NotImplemented
1980
1981     def details(self):
1982         ret = []
1983         for disp, field in SUITE_FIELDS:
1984             val = getattr(self, field, None)
1985             if val is not None:
1986                 ret.append("%s: %s" % (disp, val))
1987
1988         return "\n".join(ret)
1989
1990 __all__.append('Suite')
1991
1992 @session_wrapper
1993 def get_suite_architecture(suite, architecture, session=None):
1994     """
1995     Returns a SuiteArchitecture object given C{suite} and ${arch} or None if it
1996     doesn't exist
1997
1998     @type suite: str
1999     @param suite: Suite name to search for
2000
2001     @type architecture: str
2002     @param architecture: Architecture name to search for
2003
2004     @type session: Session
2005     @param session: Optional SQL session object (a temporary one will be
2006     generated if not supplied)
2007
2008     @rtype: SuiteArchitecture
2009     @return: the SuiteArchitecture object or None
2010     """
2011
2012     q = session.query(SuiteArchitecture)
2013     q = q.join(Architecture).filter_by(arch_string=architecture)
2014     q = q.join(Suite).filter_by(suite_name=suite)
2015
2016     try:
2017         return q.one()
2018     except NoResultFound:
2019         return None
2020
2021 __all__.append('get_suite_architecture')
2022
2023 @session_wrapper
2024 def get_suite(suite, session=None):
2025     """
2026     Returns Suite object for given C{suite name}.
2027
2028     @type suite: string
2029     @param suite: The name of the suite
2030
2031     @type session: Session
2032     @param session: Optional SQLA session object (a temporary one will be
2033     generated if not supplied)
2034
2035     @rtype: Suite
2036     @return: Suite object for the requested suite name (None if not present)
2037     """
2038
2039     q = session.query(Suite).filter_by(suite_name=suite)
2040
2041     try:
2042         return q.one()
2043     except NoResultFound:
2044         return None
2045
2046 __all__.append('get_suite')
2047
2048 ################################################################################
2049
2050 class SuiteArchitecture(object):
2051     def __init__(self, *args, **kwargs):
2052         pass
2053
2054     def __repr__(self):
2055         return '<SuiteArchitecture (%s, %s)>' % (self.suite_id, self.arch_id)
2056
2057 __all__.append('SuiteArchitecture')
2058
2059 @session_wrapper
2060 def get_suite_architectures(suite, skipsrc=False, skipall=False, session=None):
2061     """
2062     Returns list of Architecture objects for given C{suite} name
2063
2064     @type source: str
2065     @param source: Suite name to search for
2066
2067     @type skipsrc: boolean
2068     @param skipsrc: Whether to skip returning the 'source' architecture entry
2069     (Default False)
2070
2071     @type skipall: boolean
2072     @param skipall: Whether to skip returning the 'all' architecture entry
2073     (Default False)
2074
2075     @type session: Session
2076     @param session: Optional SQL session object (a temporary one will be
2077     generated if not supplied)
2078
2079     @rtype: list
2080     @return: list of Architecture objects for the given name (may be empty)
2081     """
2082
2083     q = session.query(Architecture)
2084     q = q.join(SuiteArchitecture)
2085     q = q.join(Suite).filter_by(suite_name=suite)
2086
2087     if skipsrc:
2088         q = q.filter(Architecture.arch_string != 'source')
2089
2090     if skipall:
2091         q = q.filter(Architecture.arch_string != 'all')
2092
2093     q = q.order_by('arch_string')
2094
2095     return q.all()
2096
2097 __all__.append('get_suite_architectures')
2098
2099 ################################################################################
2100
2101 class SuiteSrcFormat(object):
2102     def __init__(self, *args, **kwargs):
2103         pass
2104
2105     def __repr__(self):
2106         return '<SuiteSrcFormat (%s, %s)>' % (self.suite_id, self.src_format_id)
2107
2108 __all__.append('SuiteSrcFormat')
2109
2110 @session_wrapper
2111 def get_suite_src_formats(suite, session=None):
2112     """
2113     Returns list of allowed SrcFormat for C{suite}.
2114
2115     @type suite: str
2116     @param suite: Suite name to search for
2117
2118     @type session: Session
2119     @param session: Optional SQL session object (a temporary one will be
2120     generated if not supplied)
2121
2122     @rtype: list
2123     @return: the list of allowed source formats for I{suite}
2124     """
2125
2126     q = session.query(SrcFormat)
2127     q = q.join(SuiteSrcFormat)
2128     q = q.join(Suite).filter_by(suite_name=suite)
2129     q = q.order_by('format_name')
2130
2131     return q.all()
2132
2133 __all__.append('get_suite_src_formats')
2134
2135 ################################################################################
2136
2137 class Uid(object):
2138     def __init__(self, *args, **kwargs):
2139         pass
2140
2141     def __eq__(self, val):
2142         if isinstance(val, str):
2143             return (self.uid == val)
2144         # This signals to use the normal comparison operator
2145         return NotImplemented
2146
2147     def __ne__(self, val):
2148         if isinstance(val, str):
2149             return (self.uid != val)
2150         # This signals to use the normal comparison operator
2151         return NotImplemented
2152
2153     def __repr__(self):
2154         return '<Uid %s (%s)>' % (self.uid, self.name)
2155
2156 __all__.append('Uid')
2157
2158 @session_wrapper
2159 def add_database_user(uidname, session=None):
2160     """
2161     Adds a database user
2162
2163     @type uidname: string
2164     @param uidname: The uid of the user to add
2165
2166     @type session: SQLAlchemy
2167     @param session: Optional SQL session object (a temporary one will be
2168     generated if not supplied).  If not passed, a commit will be performed at
2169     the end of the function, otherwise the caller is responsible for commiting.
2170
2171     @rtype: Uid
2172     @return: the uid object for the given uidname
2173     """
2174
2175     session.execute("CREATE USER :uid", {'uid': uidname})
2176     session.commit_or_flush()
2177
2178 __all__.append('add_database_user')
2179
2180 @session_wrapper
2181 def get_or_set_uid(uidname, session=None):
2182     """
2183     Returns uid object for given uidname.
2184
2185     If no matching uidname is found, a row is inserted.
2186
2187     @type uidname: string
2188     @param uidname: The uid to add
2189
2190     @type session: SQLAlchemy
2191     @param session: Optional SQL session object (a temporary one will be
2192     generated if not supplied).  If not passed, a commit will be performed at
2193     the end of the function, otherwise the caller is responsible for commiting.
2194
2195     @rtype: Uid
2196     @return: the uid object for the given uidname
2197     """
2198
2199     q = session.query(Uid).filter_by(uid=uidname)
2200
2201     try:
2202         ret = q.one()
2203     except NoResultFound:
2204         uid = Uid()
2205         uid.uid = uidname
2206         session.add(uid)
2207         session.commit_or_flush()
2208         ret = uid
2209
2210     return ret
2211
2212 __all__.append('get_or_set_uid')
2213
2214 @session_wrapper
2215 def get_uid_from_fingerprint(fpr, session=None):
2216     q = session.query(Uid)
2217     q = q.join(Fingerprint).filter_by(fingerprint=fpr)
2218
2219     try:
2220         return q.one()
2221     except NoResultFound:
2222         return None
2223
2224 __all__.append('get_uid_from_fingerprint')
2225
2226 ################################################################################
2227
2228 class UploadBlock(object):
2229     def __init__(self, *args, **kwargs):
2230         pass
2231
2232     def __repr__(self):
2233         return '<UploadBlock %s (%s)>' % (self.source, self.upload_block_id)
2234
2235 __all__.append('UploadBlock')
2236
2237 ################################################################################
2238
2239 class DBConn(Singleton):
2240     """
2241     database module init.
2242     """
2243     def __init__(self, *args, **kwargs):
2244         super(DBConn, self).__init__(*args, **kwargs)
2245
2246     def _startup(self, *args, **kwargs):
2247         self.debug = False
2248         if kwargs.has_key('debug'):
2249             self.debug = True
2250         self.__createconn()
2251
2252     def __setuptables(self):
2253         self.tbl_architecture = Table('architecture', self.db_meta, autoload=True)
2254         self.tbl_archive = Table('archive', self.db_meta, autoload=True)
2255         self.tbl_bin_associations = Table('bin_associations', self.db_meta, autoload=True)
2256         self.tbl_binaries = Table('binaries', self.db_meta, autoload=True)
2257         self.tbl_binary_acl = Table('binary_acl', self.db_meta, autoload=True)
2258         self.tbl_binary_acl_map = Table('binary_acl_map', self.db_meta, autoload=True)
2259         self.tbl_component = Table('component', self.db_meta, autoload=True)
2260         self.tbl_config = Table('config', self.db_meta, autoload=True)
2261         self.tbl_content_associations = Table('content_associations', self.db_meta, autoload=True)
2262         self.tbl_content_file_names = Table('content_file_names', self.db_meta, autoload=True)
2263         self.tbl_content_file_paths = Table('content_file_paths', self.db_meta, autoload=True)
2264         self.tbl_changes_pending_files = Table('changes_pending_files', self.db_meta, autoload=True)
2265         self.tbl_changes_pool_files = Table('changes_pool_files', self.db_meta, autoload=True)
2266         self.tbl_dsc_files = Table('dsc_files', self.db_meta, autoload=True)
2267         self.tbl_files = Table('files', self.db_meta, autoload=True)
2268         self.tbl_fingerprint = Table('fingerprint', self.db_meta, autoload=True)
2269         self.tbl_keyrings = Table('keyrings', self.db_meta, autoload=True)
2270         self.tbl_known_changes = Table('known_changes', self.db_meta, autoload=True)
2271         self.tbl_keyring_acl_map = Table('keyring_acl_map', self.db_meta, autoload=True)
2272         self.tbl_location = Table('location', self.db_meta, autoload=True)
2273         self.tbl_maintainer = Table('maintainer', self.db_meta, autoload=True)
2274         self.tbl_new_comments = Table('new_comments', self.db_meta, autoload=True)
2275         self.tbl_override = Table('override', self.db_meta, autoload=True)
2276         self.tbl_override_type = Table('override_type', self.db_meta, autoload=True)
2277         self.tbl_pending_content_associations = Table('pending_content_associations', self.db_meta, autoload=True)
2278         self.tbl_priority = Table('priority', self.db_meta, autoload=True)
2279         self.tbl_queue = Table('queue', self.db_meta, autoload=True)
2280         self.tbl_queue_files = Table('queue_files', self.db_meta, autoload=True)
2281         self.tbl_section = Table('section', self.db_meta, autoload=True)
2282         self.tbl_source = Table('source', self.db_meta, autoload=True)
2283         self.tbl_source_acl = Table('source_acl', self.db_meta, autoload=True)
2284         self.tbl_src_associations = Table('src_associations', self.db_meta, autoload=True)
2285         self.tbl_src_format = Table('src_format', self.db_meta, autoload=True)
2286         self.tbl_src_uploaders = Table('src_uploaders', self.db_meta, autoload=True)
2287         self.tbl_suite = Table('suite', self.db_meta, autoload=True)
2288         self.tbl_suite_architectures = Table('suite_architectures', self.db_meta, autoload=True)
2289         self.tbl_suite_src_formats = Table('suite_src_formats', self.db_meta, autoload=True)
2290         self.tbl_suite_queue_copy = Table('suite_queue_copy', self.db_meta, autoload=True)
2291         self.tbl_uid = Table('uid', self.db_meta, autoload=True)
2292         self.tbl_upload_blocks = Table('upload_blocks', self.db_meta, autoload=True)
2293
2294     def __setupmappers(self):
2295         mapper(Architecture, self.tbl_architecture,
2296                properties = dict(arch_id = self.tbl_architecture.c.id))
2297
2298         mapper(Archive, self.tbl_archive,
2299                properties = dict(archive_id = self.tbl_archive.c.id,
2300                                  archive_name = self.tbl_archive.c.name))
2301
2302         mapper(BinAssociation, self.tbl_bin_associations,
2303                properties = dict(ba_id = self.tbl_bin_associations.c.id,
2304                                  suite_id = self.tbl_bin_associations.c.suite,
2305                                  suite = relation(Suite),
2306                                  binary_id = self.tbl_bin_associations.c.bin,
2307                                  binary = relation(DBBinary)))
2308
2309
2310         mapper(DBBinary, self.tbl_binaries,
2311                properties = dict(binary_id = self.tbl_binaries.c.id,
2312                                  package = self.tbl_binaries.c.package,
2313                                  version = self.tbl_binaries.c.version,
2314                                  maintainer_id = self.tbl_binaries.c.maintainer,
2315                                  maintainer = relation(Maintainer),
2316                                  source_id = self.tbl_binaries.c.source,
2317                                  source = relation(DBSource),
2318                                  arch_id = self.tbl_binaries.c.architecture,
2319                                  architecture = relation(Architecture),
2320                                  poolfile_id = self.tbl_binaries.c.file,
2321                                  poolfile = relation(PoolFile),
2322                                  binarytype = self.tbl_binaries.c.type,
2323                                  fingerprint_id = self.tbl_binaries.c.sig_fpr,
2324                                  fingerprint = relation(Fingerprint),
2325                                  install_date = self.tbl_binaries.c.install_date,
2326                                  binassociations = relation(BinAssociation,
2327                                                             primaryjoin=(self.tbl_binaries.c.id==self.tbl_bin_associations.c.bin))))
2328
2329         mapper(BinaryACL, self.tbl_binary_acl,
2330                properties = dict(binary_acl_id = self.tbl_binary_acl.c.id))
2331
2332         mapper(BinaryACLMap, self.tbl_binary_acl_map,
2333                properties = dict(binary_acl_map_id = self.tbl_binary_acl_map.c.id,
2334                                  fingerprint = relation(Fingerprint, backref="binary_acl_map"),
2335                                  architecture = relation(Architecture)))
2336
2337         mapper(Component, self.tbl_component,
2338                properties = dict(component_id = self.tbl_component.c.id,
2339                                  component_name = self.tbl_component.c.name))
2340
2341         mapper(DBConfig, self.tbl_config,
2342                properties = dict(config_id = self.tbl_config.c.id))
2343
2344         mapper(DSCFile, self.tbl_dsc_files,
2345                properties = dict(dscfile_id = self.tbl_dsc_files.c.id,
2346                                  source_id = self.tbl_dsc_files.c.source,
2347                                  source = relation(DBSource),
2348                                  poolfile_id = self.tbl_dsc_files.c.file,
2349                                  poolfile = relation(PoolFile)))
2350
2351         mapper(PoolFile, self.tbl_files,
2352                properties = dict(file_id = self.tbl_files.c.id,
2353                                  filesize = self.tbl_files.c.size,
2354                                  location_id = self.tbl_files.c.location,
2355                                  location = relation(Location)))
2356
2357         mapper(Fingerprint, self.tbl_fingerprint,
2358                properties = dict(fingerprint_id = self.tbl_fingerprint.c.id,
2359                                  uid_id = self.tbl_fingerprint.c.uid,
2360                                  uid = relation(Uid),
2361                                  keyring_id = self.tbl_fingerprint.c.keyring,
2362                                  keyring = relation(Keyring),
2363                                  source_acl = relation(SourceACL),
2364                                  binary_acl = relation(BinaryACL)))
2365
2366         mapper(Keyring, self.tbl_keyrings,
2367                properties = dict(keyring_name = self.tbl_keyrings.c.name,
2368                                  keyring_id = self.tbl_keyrings.c.id))
2369
2370         mapper(KnownChange, self.tbl_known_changes,
2371                properties = dict(known_change_id = self.tbl_known_changes.c.id,
2372                                  poolfiles = relation(PoolFile,
2373                                                       secondary=self.tbl_changes_pool_files,
2374                                                       backref="changeslinks"),
2375                                  files = relation(KnownChangePendingFile, backref="changesfile")))
2376
2377         mapper(KnownChangePendingFile, self.tbl_changes_pending_files,
2378                properties = dict(known_change_pending_file_id = self.tbl_changes_pending_files.id))
2379
2380         mapper(KeyringACLMap, self.tbl_keyring_acl_map,
2381                properties = dict(keyring_acl_map_id = self.tbl_keyring_acl_map.c.id,
2382                                  keyring = relation(Keyring, backref="keyring_acl_map"),
2383                                  architecture = relation(Architecture)))
2384
2385         mapper(Location, self.tbl_location,
2386                properties = dict(location_id = self.tbl_location.c.id,
2387                                  component_id = self.tbl_location.c.component,
2388                                  component = relation(Component),
2389                                  archive_id = self.tbl_location.c.archive,
2390                                  archive = relation(Archive),
2391                                  archive_type = self.tbl_location.c.type))
2392
2393         mapper(Maintainer, self.tbl_maintainer,
2394                properties = dict(maintainer_id = self.tbl_maintainer.c.id))
2395
2396         mapper(NewComment, self.tbl_new_comments,
2397                properties = dict(comment_id = self.tbl_new_comments.c.id))
2398
2399         mapper(Override, self.tbl_override,
2400                properties = dict(suite_id = self.tbl_override.c.suite,
2401                                  suite = relation(Suite),
2402                                  component_id = self.tbl_override.c.component,
2403                                  component = relation(Component),
2404                                  priority_id = self.tbl_override.c.priority,
2405                                  priority = relation(Priority),
2406                                  section_id = self.tbl_override.c.section,
2407                                  section = relation(Section),
2408                                  overridetype_id = self.tbl_override.c.type,
2409                                  overridetype = relation(OverrideType)))
2410
2411         mapper(OverrideType, self.tbl_override_type,
2412                properties = dict(overridetype = self.tbl_override_type.c.type,
2413                                  overridetype_id = self.tbl_override_type.c.id))
2414
2415         mapper(Priority, self.tbl_priority,
2416                properties = dict(priority_id = self.tbl_priority.c.id))
2417
2418         mapper(Queue, self.tbl_queue,
2419                properties = dict(queue_id = self.tbl_queue.c.id))
2420
2421         mapper(QueueFile, self.tbl_queue_files,
2422                properties = dict(queue = relation(Queue, backref='queuefiles'),
2423                                  poolfile = relation(PoolFile, backref='queueinstances')))
2424
2425         mapper(Section, self.tbl_section,
2426                properties = dict(section_id = self.tbl_section.c.id))
2427
2428         mapper(DBSource, self.tbl_source,
2429                properties = dict(source_id = self.tbl_source.c.id,
2430                                  version = self.tbl_source.c.version,
2431                                  maintainer_id = self.tbl_source.c.maintainer,
2432                                  maintainer = relation(Maintainer,
2433                                                        primaryjoin=(self.tbl_source.c.maintainer==self.tbl_maintainer.c.id)),
2434                                  poolfile_id = self.tbl_source.c.file,
2435                                  poolfile = relation(PoolFile),
2436                                  fingerprint_id = self.tbl_source.c.sig_fpr,
2437                                  fingerprint = relation(Fingerprint),
2438                                  changedby_id = self.tbl_source.c.changedby,
2439                                  changedby = relation(Maintainer,
2440                                                       primaryjoin=(self.tbl_source.c.changedby==self.tbl_maintainer.c.id)),
2441                                  srcfiles = relation(DSCFile,
2442                                                      primaryjoin=(self.tbl_source.c.id==self.tbl_dsc_files.c.source)),
2443                                  srcassociations = relation(SrcAssociation,
2444                                                             primaryjoin=(self.tbl_source.c.id==self.tbl_src_associations.c.source)),
2445                                  srcuploaders = relation(SrcUploader)))
2446
2447         mapper(SourceACL, self.tbl_source_acl,
2448                properties = dict(source_acl_id = self.tbl_source_acl.c.id))
2449
2450         mapper(SrcAssociation, self.tbl_src_associations,
2451                properties = dict(sa_id = self.tbl_src_associations.c.id,
2452                                  suite_id = self.tbl_src_associations.c.suite,
2453                                  suite = relation(Suite),
2454                                  source_id = self.tbl_src_associations.c.source,
2455                                  source = relation(DBSource)))
2456
2457         mapper(SrcFormat, self.tbl_src_format,
2458                properties = dict(src_format_id = self.tbl_src_format.c.id,
2459                                  format_name = self.tbl_src_format.c.format_name))
2460
2461         mapper(SrcUploader, self.tbl_src_uploaders,
2462                properties = dict(uploader_id = self.tbl_src_uploaders.c.id,
2463                                  source_id = self.tbl_src_uploaders.c.source,
2464                                  source = relation(DBSource,
2465                                                    primaryjoin=(self.tbl_src_uploaders.c.source==self.tbl_source.c.id)),
2466                                  maintainer_id = self.tbl_src_uploaders.c.maintainer,
2467                                  maintainer = relation(Maintainer,
2468                                                        primaryjoin=(self.tbl_src_uploaders.c.maintainer==self.tbl_maintainer.c.id))))
2469
2470         mapper(Suite, self.tbl_suite,
2471                properties = dict(suite_id = self.tbl_suite.c.id,
2472                                  policy_queue = relation(Queue),
2473                                  copy_queues = relation(Queue, secondary=self.tbl_suite_queue_copy)))
2474
2475         mapper(SuiteArchitecture, self.tbl_suite_architectures,
2476                properties = dict(suite_id = self.tbl_suite_architectures.c.suite,
2477                                  suite = relation(Suite, backref='suitearchitectures'),
2478                                  arch_id = self.tbl_suite_architectures.c.architecture,
2479                                  architecture = relation(Architecture)))
2480
2481         mapper(SuiteSrcFormat, self.tbl_suite_src_formats,
2482                properties = dict(suite_id = self.tbl_suite_src_formats.c.suite,
2483                                  suite = relation(Suite, backref='suitesrcformats'),
2484                                  src_format_id = self.tbl_suite_src_formats.c.src_format,
2485                                  src_format = relation(SrcFormat)))
2486
2487         mapper(Uid, self.tbl_uid,
2488                properties = dict(uid_id = self.tbl_uid.c.id,
2489                                  fingerprint = relation(Fingerprint)))
2490
2491         mapper(UploadBlock, self.tbl_upload_blocks,
2492                properties = dict(upload_block_id = self.tbl_upload_blocks.c.id,
2493                                  fingerprint = relation(Fingerprint, backref="uploadblocks"),
2494                                  uid = relation(Uid, backref="uploadblocks")))
2495
2496     ## Connection functions
2497     def __createconn(self):
2498         from config import Config
2499         cnf = Config()
2500         if cnf["DB::Host"]:
2501             # TCP/IP
2502             connstr = "postgres://%s" % cnf["DB::Host"]
2503             if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
2504                 connstr += ":%s" % cnf["DB::Port"]
2505             connstr += "/%s" % cnf["DB::Name"]
2506         else:
2507             # Unix Socket
2508             connstr = "postgres:///%s" % cnf["DB::Name"]
2509             if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
2510                 connstr += "?port=%s" % cnf["DB::Port"]
2511
2512         self.db_pg   = create_engine(connstr, echo=self.debug)
2513         self.db_meta = MetaData()
2514         self.db_meta.bind = self.db_pg
2515         self.db_smaker = sessionmaker(bind=self.db_pg,
2516                                       autoflush=True,
2517                                       autocommit=False)
2518
2519         self.__setuptables()
2520         self.__setupmappers()
2521
2522     def session(self):
2523         return self.db_smaker()
2524
2525 __all__.append('DBConn')
2526
2527