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