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