]> git.decadent.org.uk Git - dak.git/blob - daklib/dbconn.py
293f4dcb799e7abcf0587194dfa593925e1df58d
[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, 2010  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 apt_pkg
37 import os
38 from os.path import normpath
39 import re
40 import psycopg2
41 import traceback
42 import commands
43 import signal
44
45 try:
46     # python >= 2.6
47     import json
48 except:
49     # python <= 2.5
50     import simplejson as json
51
52 from datetime import datetime, timedelta
53 from errno import ENOENT
54 from tempfile import mkstemp, mkdtemp
55 from subprocess import Popen, PIPE
56 from tarfile import TarFile
57
58 from inspect import getargspec
59
60 import sqlalchemy
61 from sqlalchemy import create_engine, Table, MetaData, Column, Integer, desc, \
62     Text, ForeignKey
63 from sqlalchemy.orm import sessionmaker, mapper, relation, object_session, \
64     backref, MapperExtension, EXT_CONTINUE, object_mapper, clear_mappers
65 from sqlalchemy import types as sqltypes
66 from sqlalchemy.orm.collections import attribute_mapped_collection
67 from sqlalchemy.ext.associationproxy import association_proxy
68
69 # Don't remove this, we re-export the exceptions to scripts which import us
70 from sqlalchemy.exc import *
71 from sqlalchemy.orm.exc import NoResultFound
72
73 # Only import Config until Queue stuff is changed to store its config
74 # in the database
75 from config import Config
76 from textutils import fix_maintainer
77 from dak_exceptions import DBUpdateError, NoSourceFieldError, FileExistsError
78
79 # suppress some deprecation warnings in squeeze related to sqlalchemy
80 import warnings
81 warnings.filterwarnings('ignore', \
82     "The SQLAlchemy PostgreSQL dialect has been renamed from 'postgres' to 'postgresql'.*", \
83     SADeprecationWarning)
84 warnings.filterwarnings('ignore', \
85     "Predicate of partial index .* ignored during reflection", \
86     SAWarning)
87
88
89 ################################################################################
90
91 # Patch in support for the debversion field type so that it works during
92 # reflection
93
94 try:
95     # that is for sqlalchemy 0.6
96     UserDefinedType = sqltypes.UserDefinedType
97 except:
98     # this one for sqlalchemy 0.5
99     UserDefinedType = sqltypes.TypeEngine
100
101 class DebVersion(UserDefinedType):
102     def get_col_spec(self):
103         return "DEBVERSION"
104
105     def bind_processor(self, dialect):
106         return None
107
108     # ' = None' is needed for sqlalchemy 0.5:
109     def result_processor(self, dialect, coltype = None):
110         return None
111
112 sa_major_version = sqlalchemy.__version__[0:3]
113 if sa_major_version in ["0.5", "0.6", "0.7"]:
114     from sqlalchemy.databases import postgres
115     postgres.ischema_names['debversion'] = DebVersion
116 else:
117     raise Exception("dak only ported to SQLA versions 0.5 to 0.7.  See daklib/dbconn.py")
118
119 ################################################################################
120
121 __all__ = ['IntegrityError', 'SQLAlchemyError', 'DebVersion']
122
123 ################################################################################
124
125 def session_wrapper(fn):
126     """
127     Wrapper around common ".., session=None):" handling. If the wrapped
128     function is called without passing 'session', we create a local one
129     and destroy it when the function ends.
130
131     Also attaches a commit_or_flush method to the session; if we created a
132     local session, this is a synonym for session.commit(), otherwise it is a
133     synonym for session.flush().
134     """
135
136     def wrapped(*args, **kwargs):
137         private_transaction = False
138
139         # Find the session object
140         session = kwargs.get('session')
141
142         if session is None:
143             if len(args) <= len(getargspec(fn)[0]) - 1:
144                 # No session specified as last argument or in kwargs
145                 private_transaction = True
146                 session = kwargs['session'] = DBConn().session()
147             else:
148                 # Session is last argument in args
149                 session = args[-1]
150                 if session is None:
151                     args = list(args)
152                     session = args[-1] = DBConn().session()
153                     private_transaction = True
154
155         if private_transaction:
156             session.commit_or_flush = session.commit
157         else:
158             session.commit_or_flush = session.flush
159
160         try:
161             return fn(*args, **kwargs)
162         finally:
163             if private_transaction:
164                 # We created a session; close it.
165                 session.close()
166
167     wrapped.__doc__ = fn.__doc__
168     wrapped.func_name = fn.func_name
169
170     return wrapped
171
172 __all__.append('session_wrapper')
173
174 ################################################################################
175
176 class ORMObject(object):
177     """
178     ORMObject is a base class for all ORM classes mapped by SQLalchemy. All
179     derived classes must implement the properties() method.
180     """
181
182     def properties(self):
183         '''
184         This method should be implemented by all derived classes and returns a
185         list of the important properties. The properties 'created' and
186         'modified' will be added automatically. A suffix '_count' should be
187         added to properties that are lists or query objects. The most important
188         property name should be returned as the first element in the list
189         because it is used by repr().
190         '''
191         return []
192
193     def json(self):
194         '''
195         Returns a JSON representation of the object based on the properties
196         returned from the properties() method.
197         '''
198         data = {}
199         # add created and modified
200         all_properties = self.properties() + ['created', 'modified']
201         for property in all_properties:
202             # check for list or query
203             if property[-6:] == '_count':
204                 real_property = property[:-6]
205                 if not hasattr(self, real_property):
206                     continue
207                 value = getattr(self, real_property)
208                 if hasattr(value, '__len__'):
209                     # list
210                     value = len(value)
211                 elif hasattr(value, 'count'):
212                     # query (but not during validation)
213                     if self.in_validation:
214                         continue
215                     value = value.count()
216                 else:
217                     raise KeyError('Do not understand property %s.' % property)
218             else:
219                 if not hasattr(self, property):
220                     continue
221                 # plain object
222                 value = getattr(self, property)
223                 if value is None:
224                     # skip None
225                     continue
226                 elif isinstance(value, ORMObject):
227                     # use repr() for ORMObject types
228                     value = repr(value)
229                 else:
230                     # we want a string for all other types because json cannot
231                     # encode everything
232                     value = str(value)
233             data[property] = value
234         return json.dumps(data)
235
236     def classname(self):
237         '''
238         Returns the name of the class.
239         '''
240         return type(self).__name__
241
242     def __repr__(self):
243         '''
244         Returns a short string representation of the object using the first
245         element from the properties() method.
246         '''
247         primary_property = self.properties()[0]
248         value = getattr(self, primary_property)
249         return '<%s %s>' % (self.classname(), str(value))
250
251     def __str__(self):
252         '''
253         Returns a human readable form of the object using the properties()
254         method.
255         '''
256         return '<%s %s>' % (self.classname(), self.json())
257
258     def not_null_constraints(self):
259         '''
260         Returns a list of properties that must be not NULL. Derived classes
261         should override this method if needed.
262         '''
263         return []
264
265     validation_message = \
266         "Validation failed because property '%s' must not be empty in object\n%s"
267
268     in_validation = False
269
270     def validate(self):
271         '''
272         This function validates the not NULL constraints as returned by
273         not_null_constraints(). It raises the DBUpdateError exception if
274         validation fails.
275         '''
276         for property in self.not_null_constraints():
277             # TODO: It is a bit awkward that the mapper configuration allow
278             # directly setting the numeric _id columns. We should get rid of it
279             # in the long run.
280             if hasattr(self, property + '_id') and \
281                 getattr(self, property + '_id') is not None:
282                 continue
283             if not hasattr(self, property) or getattr(self, property) is None:
284                 # str() might lead to races due to a 2nd flush
285                 self.in_validation = True
286                 message = self.validation_message % (property, str(self))
287                 self.in_validation = False
288                 raise DBUpdateError(message)
289
290     @classmethod
291     @session_wrapper
292     def get(cls, primary_key,  session = None):
293         '''
294         This is a support function that allows getting an object by its primary
295         key.
296
297         Architecture.get(3[, session])
298
299         instead of the more verbose
300
301         session.query(Architecture).get(3)
302         '''
303         return session.query(cls).get(primary_key)
304
305     def session(self, replace = False):
306         '''
307         Returns the current session that is associated with the object. May
308         return None is object is in detached state.
309         '''
310
311         return object_session(self)
312
313     def clone(self, session = None):
314         '''
315         Clones the current object in a new session and returns the new clone. A
316         fresh session is created if the optional session parameter is not
317         provided. The function will fail if a session is provided and has
318         unflushed changes.
319
320         RATIONALE: SQLAlchemy's session is not thread safe. This method clones
321         an existing object to allow several threads to work with their own
322         instances of an ORMObject.
323
324         WARNING: Only persistent (committed) objects can be cloned. Changes
325         made to the original object that are not committed yet will get lost.
326         The session of the new object will always be rolled back to avoid
327         ressource leaks.
328         '''
329
330         if self.session() is None:
331             raise RuntimeError( \
332                 'Method clone() failed for detached object:\n%s' % self)
333         self.session().flush()
334         mapper = object_mapper(self)
335         primary_key = mapper.primary_key_from_instance(self)
336         object_class = self.__class__
337         if session is None:
338             session = DBConn().session()
339         elif len(session.new) + len(session.dirty) + len(session.deleted) > 0:
340             raise RuntimeError( \
341                 'Method clone() failed due to unflushed changes in session.')
342         new_object = session.query(object_class).get(primary_key)
343         session.rollback()
344         if new_object is None:
345             raise RuntimeError( \
346                 'Method clone() failed for non-persistent object:\n%s' % self)
347         return new_object
348
349 __all__.append('ORMObject')
350
351 ################################################################################
352
353 class Validator(MapperExtension):
354     '''
355     This class calls the validate() method for each instance for the
356     'before_update' and 'before_insert' events. A global object validator is
357     used for configuring the individual mappers.
358     '''
359
360     def before_update(self, mapper, connection, instance):
361         instance.validate()
362         return EXT_CONTINUE
363
364     def before_insert(self, mapper, connection, instance):
365         instance.validate()
366         return EXT_CONTINUE
367
368 validator = Validator()
369
370 ################################################################################
371
372 class Architecture(ORMObject):
373     def __init__(self, arch_string = None, description = None):
374         self.arch_string = arch_string
375         self.description = description
376
377     def __eq__(self, val):
378         if isinstance(val, str):
379             return (self.arch_string== val)
380         # This signals to use the normal comparison operator
381         return NotImplemented
382
383     def __ne__(self, val):
384         if isinstance(val, str):
385             return (self.arch_string != val)
386         # This signals to use the normal comparison operator
387         return NotImplemented
388
389     def properties(self):
390         return ['arch_string', 'arch_id', 'suites_count']
391
392     def not_null_constraints(self):
393         return ['arch_string']
394
395 __all__.append('Architecture')
396
397 @session_wrapper
398 def get_architecture(architecture, session=None):
399     """
400     Returns database id for given C{architecture}.
401
402     @type architecture: string
403     @param architecture: The name of the architecture
404
405     @type session: Session
406     @param session: Optional SQLA session object (a temporary one will be
407     generated if not supplied)
408
409     @rtype: Architecture
410     @return: Architecture object for the given arch (None if not present)
411     """
412
413     q = session.query(Architecture).filter_by(arch_string=architecture)
414
415     try:
416         return q.one()
417     except NoResultFound:
418         return None
419
420 __all__.append('get_architecture')
421
422 # TODO: should be removed because the implementation is too trivial
423 @session_wrapper
424 def get_architecture_suites(architecture, session=None):
425     """
426     Returns list of Suite objects for given C{architecture} name
427
428     @type architecture: str
429     @param architecture: Architecture name to search for
430
431     @type session: Session
432     @param session: Optional SQL session object (a temporary one will be
433     generated if not supplied)
434
435     @rtype: list
436     @return: list of Suite objects for the given name (may be empty)
437     """
438
439     return get_architecture(architecture, session).suites
440
441 __all__.append('get_architecture_suites')
442
443 ################################################################################
444
445 class Archive(object):
446     def __init__(self, *args, **kwargs):
447         pass
448
449     def __repr__(self):
450         return '<Archive %s>' % self.archive_name
451
452 __all__.append('Archive')
453
454 @session_wrapper
455 def get_archive(archive, session=None):
456     """
457     returns database id for given C{archive}.
458
459     @type archive: string
460     @param archive: the name of the arhive
461
462     @type session: Session
463     @param session: Optional SQLA session object (a temporary one will be
464     generated if not supplied)
465
466     @rtype: Archive
467     @return: Archive object for the given name (None if not present)
468
469     """
470     archive = archive.lower()
471
472     q = session.query(Archive).filter_by(archive_name=archive)
473
474     try:
475         return q.one()
476     except NoResultFound:
477         return None
478
479 __all__.append('get_archive')
480
481 ################################################################################
482
483 class ArchiveFile(object):
484     def __init__(self, archive=None, component=None, file=None):
485         self.archive = archive
486         self.component = component
487         self.file = file
488     @property
489     def path(self):
490         return os.path.join(self.archive.path, 'pool', self.component.component_name, self.file.filename)
491
492 __all__.append('ArchiveFile')
493
494 ################################################################################
495
496 class BinContents(ORMObject):
497     def __init__(self, file = None, binary = None):
498         self.file = file
499         self.binary = binary
500
501     def properties(self):
502         return ['file', 'binary']
503
504 __all__.append('BinContents')
505
506 ################################################################################
507
508 def subprocess_setup():
509     # Python installs a SIGPIPE handler by default. This is usually not what
510     # non-Python subprocesses expect.
511     signal.signal(signal.SIGPIPE, signal.SIG_DFL)
512
513 class DBBinary(ORMObject):
514     def __init__(self, package = None, source = None, version = None, \
515         maintainer = None, architecture = None, poolfile = None, \
516         binarytype = 'deb', fingerprint=None):
517         self.package = package
518         self.source = source
519         self.version = version
520         self.maintainer = maintainer
521         self.architecture = architecture
522         self.poolfile = poolfile
523         self.binarytype = binarytype
524         self.fingerprint = fingerprint
525
526     @property
527     def pkid(self):
528         return self.binary_id
529
530     def properties(self):
531         return ['package', 'version', 'maintainer', 'source', 'architecture', \
532             'poolfile', 'binarytype', 'fingerprint', 'install_date', \
533             'suites_count', 'binary_id', 'contents_count', 'extra_sources']
534
535     def not_null_constraints(self):
536         return ['package', 'version', 'maintainer', 'source',  'poolfile', \
537             'binarytype']
538
539     metadata = association_proxy('key', 'value')
540
541     def scan_contents(self):
542         '''
543         Yields the contents of the package. Only regular files are yielded and
544         the path names are normalized after converting them from either utf-8
545         or iso8859-1 encoding. It yields the string ' <EMPTY PACKAGE>' if the
546         package does not contain any regular file.
547         '''
548         fullpath = self.poolfile.fullpath
549         dpkg = Popen(['dpkg-deb', '--fsys-tarfile', fullpath], stdout = PIPE,
550             preexec_fn = subprocess_setup)
551         tar = TarFile.open(fileobj = dpkg.stdout, mode = 'r|')
552         for member in tar.getmembers():
553             if not member.isdir():
554                 name = normpath(member.name)
555                 # enforce proper utf-8 encoding
556                 try:
557                     name.decode('utf-8')
558                 except UnicodeDecodeError:
559                     name = name.decode('iso8859-1').encode('utf-8')
560                 yield name
561         tar.close()
562         dpkg.stdout.close()
563         dpkg.wait()
564
565     def read_control(self):
566         '''
567         Reads the control information from a binary.
568
569         @rtype: text
570         @return: stanza text of the control section.
571         '''
572         import utils
573         fullpath = self.poolfile.fullpath
574         deb_file = open(fullpath, 'r')
575         stanza = utils.deb_extract_control(deb_file)
576         deb_file.close()
577
578         return stanza
579
580     def read_control_fields(self):
581         '''
582         Reads the control information from a binary and return
583         as a dictionary.
584
585         @rtype: dict
586         @return: fields of the control section as a dictionary.
587         '''
588         import apt_pkg
589         stanza = self.read_control()
590         return apt_pkg.TagSection(stanza)
591
592 __all__.append('DBBinary')
593
594 @session_wrapper
595 def get_suites_binary_in(package, session=None):
596     """
597     Returns list of Suite objects which given C{package} name is in
598
599     @type package: str
600     @param package: DBBinary package name to search for
601
602     @rtype: list
603     @return: list of Suite objects for the given package
604     """
605
606     return session.query(Suite).filter(Suite.binaries.any(DBBinary.package == package)).all()
607
608 __all__.append('get_suites_binary_in')
609
610 @session_wrapper
611 def get_component_by_package_suite(package, suite_list, arch_list=[], session=None):
612     '''
613     Returns the component name of the newest binary package in suite_list or
614     None if no package is found. The result can be optionally filtered by a list
615     of architecture names.
616
617     @type package: str
618     @param package: DBBinary package name to search for
619
620     @type suite_list: list of str
621     @param suite_list: list of suite_name items
622
623     @type arch_list: list of str
624     @param arch_list: optional list of arch_string items that defaults to []
625
626     @rtype: str or NoneType
627     @return: name of component or None
628     '''
629
630     q = session.query(DBBinary).filter_by(package = package). \
631         join(DBBinary.suites).filter(Suite.suite_name.in_(suite_list))
632     if len(arch_list) > 0:
633         q = q.join(DBBinary.architecture). \
634             filter(Architecture.arch_string.in_(arch_list))
635     binary = q.order_by(desc(DBBinary.version)).first()
636     if binary is None:
637         return None
638     else:
639         return binary.poolfile.component.component_name
640
641 __all__.append('get_component_by_package_suite')
642
643 ################################################################################
644
645 class BinaryACL(object):
646     def __init__(self, *args, **kwargs):
647         pass
648
649     def __repr__(self):
650         return '<BinaryACL %s>' % self.binary_acl_id
651
652 __all__.append('BinaryACL')
653
654 ################################################################################
655
656 class BinaryACLMap(object):
657     def __init__(self, *args, **kwargs):
658         pass
659
660     def __repr__(self):
661         return '<BinaryACLMap %s>' % self.binary_acl_map_id
662
663 __all__.append('BinaryACLMap')
664
665 ################################################################################
666
667 class BuildQueue(object):
668     def __init__(self, *args, **kwargs):
669         pass
670
671     def __repr__(self):
672         return '<BuildQueue %s>' % self.queue_name
673
674 __all__.append('BuildQueue')
675
676 ################################################################################
677
678 class Component(ORMObject):
679     def __init__(self, component_name = None):
680         self.component_name = component_name
681
682     def __eq__(self, val):
683         if isinstance(val, str):
684             return (self.component_name == val)
685         # This signals to use the normal comparison operator
686         return NotImplemented
687
688     def __ne__(self, val):
689         if isinstance(val, str):
690             return (self.component_name != val)
691         # This signals to use the normal comparison operator
692         return NotImplemented
693
694     def properties(self):
695         return ['component_name', 'component_id', 'description', \
696             'meets_dfsg', 'overrides_count']
697
698     def not_null_constraints(self):
699         return ['component_name']
700
701
702 __all__.append('Component')
703
704 @session_wrapper
705 def get_component(component, session=None):
706     """
707     Returns database id for given C{component}.
708
709     @type component: string
710     @param component: The name of the override type
711
712     @rtype: int
713     @return: the database id for the given component
714
715     """
716     component = component.lower()
717
718     q = session.query(Component).filter_by(component_name=component)
719
720     try:
721         return q.one()
722     except NoResultFound:
723         return None
724
725 __all__.append('get_component')
726
727 @session_wrapper
728 def get_mapped_component(component_name, session=None):
729     """get component after mappings
730
731     Evaluate component mappings from ComponentMappings in dak.conf for the
732     given component name.
733
734     @todo: ansgar wants to get rid of this. It's currently only used for
735            the security archive
736
737     @type  component_name: str
738     @param component_name: component name
739
740     @param session: database session
741
742     @rtype:  L{daklib.dbconn.Component} or C{None}
743     @return: component after applying maps or C{None}
744     """
745     cnf = Config()
746     for m in cnf.value_list("ComponentMappings"):
747         (src, dst) = m.split()
748         if component_name == src:
749             component_name = dst
750     component = session.query(Component).filter_by(component_name=component_name).first()
751     return component
752
753 __all__.append('get_mapped_component')
754
755 @session_wrapper
756 def get_component_names(session=None):
757     """
758     Returns list of strings of component names.
759
760     @rtype: list
761     @return: list of strings of component names
762     """
763
764     return [ x.component_name for x in session.query(Component).all() ]
765
766 __all__.append('get_component_names')
767
768 ################################################################################
769
770 class DBConfig(object):
771     def __init__(self, *args, **kwargs):
772         pass
773
774     def __repr__(self):
775         return '<DBConfig %s>' % self.name
776
777 __all__.append('DBConfig')
778
779 ################################################################################
780
781 @session_wrapper
782 def get_or_set_contents_file_id(filename, session=None):
783     """
784     Returns database id for given filename.
785
786     If no matching file is found, a row is inserted.
787
788     @type filename: string
789     @param filename: The filename
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
795     @rtype: int
796     @return: the database id for the given component
797     """
798
799     q = session.query(ContentFilename).filter_by(filename=filename)
800
801     try:
802         ret = q.one().cafilename_id
803     except NoResultFound:
804         cf = ContentFilename()
805         cf.filename = filename
806         session.add(cf)
807         session.commit_or_flush()
808         ret = cf.cafilename_id
809
810     return ret
811
812 __all__.append('get_or_set_contents_file_id')
813
814 @session_wrapper
815 def get_contents(suite, overridetype, section=None, session=None):
816     """
817     Returns contents for a suite / overridetype combination, limiting
818     to a section if not None.
819
820     @type suite: Suite
821     @param suite: Suite object
822
823     @type overridetype: OverrideType
824     @param overridetype: OverrideType object
825
826     @type section: Section
827     @param section: Optional section object to limit results to
828
829     @type session: SQLAlchemy
830     @param session: Optional SQL session object (a temporary one will be
831     generated if not supplied)
832
833     @rtype: ResultsProxy
834     @return: ResultsProxy object set up to return tuples of (filename, section,
835     package, arch_id)
836     """
837
838     # find me all of the contents for a given suite
839     contents_q = """SELECT (p.path||'/'||n.file) AS fn,
840                             s.section,
841                             b.package,
842                             b.architecture
843                    FROM content_associations c join content_file_paths p ON (c.filepath=p.id)
844                    JOIN content_file_names n ON (c.filename=n.id)
845                    JOIN binaries b ON (b.id=c.binary_pkg)
846                    JOIN override o ON (o.package=b.package)
847                    JOIN section s ON (s.id=o.section)
848                    WHERE o.suite = :suiteid AND o.type = :overridetypeid
849                    AND b.type=:overridetypename"""
850
851     vals = {'suiteid': suite.suite_id,
852             'overridetypeid': overridetype.overridetype_id,
853             'overridetypename': overridetype.overridetype}
854
855     if section is not None:
856         contents_q += " AND s.id = :sectionid"
857         vals['sectionid'] = section.section_id
858
859     contents_q += " ORDER BY fn"
860
861     return session.execute(contents_q, vals)
862
863 __all__.append('get_contents')
864
865 ################################################################################
866
867 class ContentFilepath(object):
868     def __init__(self, *args, **kwargs):
869         pass
870
871     def __repr__(self):
872         return '<ContentFilepath %s>' % self.filepath
873
874 __all__.append('ContentFilepath')
875
876 @session_wrapper
877 def get_or_set_contents_path_id(filepath, session=None):
878     """
879     Returns database id for given path.
880
881     If no matching file is found, a row is inserted.
882
883     @type filepath: string
884     @param filepath: The filepath
885
886     @type session: SQLAlchemy
887     @param session: Optional SQL session object (a temporary one will be
888     generated if not supplied).  If not passed, a commit will be performed at
889     the end of the function, otherwise the caller is responsible for commiting.
890
891     @rtype: int
892     @return: the database id for the given path
893     """
894
895     q = session.query(ContentFilepath).filter_by(filepath=filepath)
896
897     try:
898         ret = q.one().cafilepath_id
899     except NoResultFound:
900         cf = ContentFilepath()
901         cf.filepath = filepath
902         session.add(cf)
903         session.commit_or_flush()
904         ret = cf.cafilepath_id
905
906     return ret
907
908 __all__.append('get_or_set_contents_path_id')
909
910 ################################################################################
911
912 class ContentAssociation(object):
913     def __init__(self, *args, **kwargs):
914         pass
915
916     def __repr__(self):
917         return '<ContentAssociation %s>' % self.ca_id
918
919 __all__.append('ContentAssociation')
920
921 def insert_content_paths(binary_id, fullpaths, session=None):
922     """
923     Make sure given path is associated with given binary id
924
925     @type binary_id: int
926     @param binary_id: the id of the binary
927     @type fullpaths: list
928     @param fullpaths: the list of paths of the file being associated with the binary
929     @type session: SQLAlchemy session
930     @param session: Optional SQLAlchemy session.  If this is passed, the caller
931     is responsible for ensuring a transaction has begun and committing the
932     results or rolling back based on the result code.  If not passed, a commit
933     will be performed at the end of the function, otherwise the caller is
934     responsible for commiting.
935
936     @return: True upon success
937     """
938
939     privatetrans = False
940     if session is None:
941         session = DBConn().session()
942         privatetrans = True
943
944     try:
945         # Insert paths
946         def generate_path_dicts():
947             for fullpath in fullpaths:
948                 if fullpath.startswith( './' ):
949                     fullpath = fullpath[2:]
950
951                 yield {'filename':fullpath, 'id': binary_id }
952
953         for d in generate_path_dicts():
954             session.execute( "INSERT INTO bin_contents ( file, binary_id ) VALUES ( :filename, :id )",
955                          d )
956
957         session.commit()
958         if privatetrans:
959             session.close()
960         return True
961
962     except:
963         traceback.print_exc()
964
965         # Only rollback if we set up the session ourself
966         if privatetrans:
967             session.rollback()
968             session.close()
969
970         return False
971
972 __all__.append('insert_content_paths')
973
974 ################################################################################
975
976 class DSCFile(object):
977     def __init__(self, *args, **kwargs):
978         pass
979
980     def __repr__(self):
981         return '<DSCFile %s>' % self.dscfile_id
982
983 __all__.append('DSCFile')
984
985 @session_wrapper
986 def get_dscfiles(dscfile_id=None, source_id=None, poolfile_id=None, session=None):
987     """
988     Returns a list of DSCFiles which may be empty
989
990     @type dscfile_id: int (optional)
991     @param dscfile_id: the dscfile_id of the DSCFiles to find
992
993     @type source_id: int (optional)
994     @param source_id: the source id related to the DSCFiles to find
995
996     @type poolfile_id: int (optional)
997     @param poolfile_id: the poolfile id related to the DSCFiles to find
998
999     @rtype: list
1000     @return: Possibly empty list of DSCFiles
1001     """
1002
1003     q = session.query(DSCFile)
1004
1005     if dscfile_id is not None:
1006         q = q.filter_by(dscfile_id=dscfile_id)
1007
1008     if source_id is not None:
1009         q = q.filter_by(source_id=source_id)
1010
1011     if poolfile_id is not None:
1012         q = q.filter_by(poolfile_id=poolfile_id)
1013
1014     return q.all()
1015
1016 __all__.append('get_dscfiles')
1017
1018 ################################################################################
1019
1020 class ExternalOverride(ORMObject):
1021     def __init__(self, *args, **kwargs):
1022         pass
1023
1024     def __repr__(self):
1025         return '<ExternalOverride %s = %s: %s>' % (self.package, self.key, self.value)
1026
1027 __all__.append('ExternalOverride')
1028
1029 ################################################################################
1030
1031 class PoolFile(ORMObject):
1032     def __init__(self, filename = None, filesize = -1, \
1033         md5sum = None):
1034         self.filename = filename
1035         self.filesize = filesize
1036         self.md5sum = md5sum
1037
1038     @property
1039     def fullpath(self):
1040         session = DBConn().session().object_session(self)
1041         af = session.query(ArchiveFile).join(Archive).filter(ArchiveFile.file == self).first()
1042         return af.path
1043
1044     @property
1045     def component(self):
1046         session = DBConn().session().object_session(self)
1047         component_id = session.query(ArchiveFile.component_id).filter(ArchiveFile.file == self) \
1048                               .group_by(ArchiveFile.component_id).one()
1049         return session.query(Component).get(component_id)
1050
1051     @property
1052     def basename(self):
1053         return os.path.basename(self.filename)
1054
1055     def is_valid(self, filesize = -1, md5sum = None):
1056         return self.filesize == long(filesize) and self.md5sum == md5sum
1057
1058     def properties(self):
1059         return ['filename', 'file_id', 'filesize', 'md5sum', 'sha1sum', \
1060             'sha256sum', 'source', 'binary', 'last_used']
1061
1062     def not_null_constraints(self):
1063         return ['filename', 'md5sum']
1064
1065     def identical_to(self, filename):
1066         """
1067         compare size and hash with the given file
1068
1069         @rtype: bool
1070         @return: true if the given file has the same size and hash as this object; false otherwise
1071         """
1072         st = os.stat(filename)
1073         if self.filesize != st.st_size:
1074             return False
1075
1076         f = open(filename, "r")
1077         sha256sum = apt_pkg.sha256sum(f)
1078         if sha256sum != self.sha256sum:
1079             return False
1080
1081         return True
1082
1083 __all__.append('PoolFile')
1084
1085 @session_wrapper
1086 def get_poolfile_like_name(filename, session=None):
1087     """
1088     Returns an array of PoolFile objects which are like the given name
1089
1090     @type filename: string
1091     @param filename: the filename of the file to check against the DB
1092
1093     @rtype: array
1094     @return: array of PoolFile objects
1095     """
1096
1097     # TODO: There must be a way of properly using bind parameters with %FOO%
1098     q = session.query(PoolFile).filter(PoolFile.filename.like('%%/%s' % filename))
1099
1100     return q.all()
1101
1102 __all__.append('get_poolfile_like_name')
1103
1104 ################################################################################
1105
1106 class Fingerprint(ORMObject):
1107     def __init__(self, fingerprint = None):
1108         self.fingerprint = fingerprint
1109
1110     def properties(self):
1111         return ['fingerprint', 'fingerprint_id', 'keyring', 'uid', \
1112             'binary_reject']
1113
1114     def not_null_constraints(self):
1115         return ['fingerprint']
1116
1117 __all__.append('Fingerprint')
1118
1119 @session_wrapper
1120 def get_fingerprint(fpr, session=None):
1121     """
1122     Returns Fingerprint object for given fpr.
1123
1124     @type fpr: string
1125     @param fpr: The fpr to find / add
1126
1127     @type session: SQLAlchemy
1128     @param session: Optional SQL session object (a temporary one will be
1129     generated if not supplied).
1130
1131     @rtype: Fingerprint
1132     @return: the Fingerprint object for the given fpr or None
1133     """
1134
1135     q = session.query(Fingerprint).filter_by(fingerprint=fpr)
1136
1137     try:
1138         ret = q.one()
1139     except NoResultFound:
1140         ret = None
1141
1142     return ret
1143
1144 __all__.append('get_fingerprint')
1145
1146 @session_wrapper
1147 def get_or_set_fingerprint(fpr, session=None):
1148     """
1149     Returns Fingerprint object for given fpr.
1150
1151     If no matching fpr is found, a row is inserted.
1152
1153     @type fpr: string
1154     @param fpr: The fpr to find / add
1155
1156     @type session: SQLAlchemy
1157     @param session: Optional SQL session object (a temporary one will be
1158     generated if not supplied).  If not passed, a commit will be performed at
1159     the end of the function, otherwise the caller is responsible for commiting.
1160     A flush will be performed either way.
1161
1162     @rtype: Fingerprint
1163     @return: the Fingerprint object for the given fpr
1164     """
1165
1166     q = session.query(Fingerprint).filter_by(fingerprint=fpr)
1167
1168     try:
1169         ret = q.one()
1170     except NoResultFound:
1171         fingerprint = Fingerprint()
1172         fingerprint.fingerprint = fpr
1173         session.add(fingerprint)
1174         session.commit_or_flush()
1175         ret = fingerprint
1176
1177     return ret
1178
1179 __all__.append('get_or_set_fingerprint')
1180
1181 ################################################################################
1182
1183 # Helper routine for Keyring class
1184 def get_ldap_name(entry):
1185     name = []
1186     for k in ["cn", "mn", "sn"]:
1187         ret = entry.get(k)
1188         if ret and ret[0] != "" and ret[0] != "-":
1189             name.append(ret[0])
1190     return " ".join(name)
1191
1192 ################################################################################
1193
1194 class Keyring(object):
1195     gpg_invocation = "gpg --no-default-keyring --keyring %s" +\
1196                      " --with-colons --fingerprint --fingerprint"
1197
1198     keys = {}
1199     fpr_lookup = {}
1200
1201     def __init__(self, *args, **kwargs):
1202         pass
1203
1204     def __repr__(self):
1205         return '<Keyring %s>' % self.keyring_name
1206
1207     def de_escape_gpg_str(self, txt):
1208         esclist = re.split(r'(\\x..)', txt)
1209         for x in range(1,len(esclist),2):
1210             esclist[x] = "%c" % (int(esclist[x][2:],16))
1211         return "".join(esclist)
1212
1213     def parse_address(self, uid):
1214         """parses uid and returns a tuple of real name and email address"""
1215         import email.Utils
1216         (name, address) = email.Utils.parseaddr(uid)
1217         name = re.sub(r"\s*[(].*[)]", "", name)
1218         name = self.de_escape_gpg_str(name)
1219         if name == "":
1220             name = uid
1221         return (name, address)
1222
1223     def load_keys(self, keyring):
1224         if not self.keyring_id:
1225             raise Exception('Must be initialized with database information')
1226
1227         k = os.popen(self.gpg_invocation % keyring, "r")
1228         key = None
1229         signingkey = False
1230
1231         for line in k:
1232             field = line.split(":")
1233             if field[0] == "pub":
1234                 key = field[4]
1235                 self.keys[key] = {}
1236                 (name, addr) = self.parse_address(field[9])
1237                 if "@" in addr:
1238                     self.keys[key]["email"] = addr
1239                     self.keys[key]["name"] = name
1240                 self.keys[key]["fingerprints"] = []
1241                 signingkey = True
1242             elif key and field[0] == "sub" and len(field) >= 12:
1243                 signingkey = ("s" in field[11])
1244             elif key and field[0] == "uid":
1245                 (name, addr) = self.parse_address(field[9])
1246                 if "email" not in self.keys[key] and "@" in addr:
1247                     self.keys[key]["email"] = addr
1248                     self.keys[key]["name"] = name
1249             elif signingkey and field[0] == "fpr":
1250                 self.keys[key]["fingerprints"].append(field[9])
1251                 self.fpr_lookup[field[9]] = key
1252
1253     def import_users_from_ldap(self, session):
1254         import ldap
1255         cnf = Config()
1256
1257         LDAPDn = cnf["Import-LDAP-Fingerprints::LDAPDn"]
1258         LDAPServer = cnf["Import-LDAP-Fingerprints::LDAPServer"]
1259
1260         l = ldap.open(LDAPServer)
1261         l.simple_bind_s("","")
1262         Attrs = l.search_s(LDAPDn, ldap.SCOPE_ONELEVEL,
1263                "(&(keyfingerprint=*)(gidnumber=%s))" % (cnf["Import-Users-From-Passwd::ValidGID"]),
1264                ["uid", "keyfingerprint", "cn", "mn", "sn"])
1265
1266         ldap_fin_uid_id = {}
1267
1268         byuid = {}
1269         byname = {}
1270
1271         for i in Attrs:
1272             entry = i[1]
1273             uid = entry["uid"][0]
1274             name = get_ldap_name(entry)
1275             fingerprints = entry["keyFingerPrint"]
1276             keyid = None
1277             for f in fingerprints:
1278                 key = self.fpr_lookup.get(f, None)
1279                 if key not in self.keys:
1280                     continue
1281                 self.keys[key]["uid"] = uid
1282
1283                 if keyid != None:
1284                     continue
1285                 keyid = get_or_set_uid(uid, session).uid_id
1286                 byuid[keyid] = (uid, name)
1287                 byname[uid] = (keyid, name)
1288
1289         return (byname, byuid)
1290
1291     def generate_users_from_keyring(self, format, session):
1292         byuid = {}
1293         byname = {}
1294         any_invalid = False
1295         for x in self.keys.keys():
1296             if "email" not in self.keys[x]:
1297                 any_invalid = True
1298                 self.keys[x]["uid"] = format % "invalid-uid"
1299             else:
1300                 uid = format % self.keys[x]["email"]
1301                 keyid = get_or_set_uid(uid, session).uid_id
1302                 byuid[keyid] = (uid, self.keys[x]["name"])
1303                 byname[uid] = (keyid, self.keys[x]["name"])
1304                 self.keys[x]["uid"] = uid
1305
1306         if any_invalid:
1307             uid = format % "invalid-uid"
1308             keyid = get_or_set_uid(uid, session).uid_id
1309             byuid[keyid] = (uid, "ungeneratable user id")
1310             byname[uid] = (keyid, "ungeneratable user id")
1311
1312         return (byname, byuid)
1313
1314 __all__.append('Keyring')
1315
1316 @session_wrapper
1317 def get_keyring(keyring, session=None):
1318     """
1319     If C{keyring} does not have an entry in the C{keyrings} table yet, return None
1320     If C{keyring} already has an entry, simply return the existing Keyring
1321
1322     @type keyring: string
1323     @param keyring: the keyring name
1324
1325     @rtype: Keyring
1326     @return: the Keyring object for this keyring
1327     """
1328
1329     q = session.query(Keyring).filter_by(keyring_name=keyring)
1330
1331     try:
1332         return q.one()
1333     except NoResultFound:
1334         return None
1335
1336 __all__.append('get_keyring')
1337
1338 @session_wrapper
1339 def get_active_keyring_paths(session=None):
1340     """
1341     @rtype: list
1342     @return: list of active keyring paths
1343     """
1344     return [ x.keyring_name for x in session.query(Keyring).filter(Keyring.active == True).order_by(desc(Keyring.priority)).all() ]
1345
1346 __all__.append('get_active_keyring_paths')
1347
1348 @session_wrapper
1349 def get_primary_keyring_path(session=None):
1350     """
1351     Get the full path to the highest priority active keyring
1352
1353     @rtype: str or None
1354     @return: path to the active keyring with the highest priority or None if no
1355              keyring is configured
1356     """
1357     keyrings = get_active_keyring_paths()
1358
1359     if len(keyrings) > 0:
1360         return keyrings[0]
1361     else:
1362         return None
1363
1364 __all__.append('get_primary_keyring_path')
1365
1366 ################################################################################
1367
1368 class KeyringACLMap(object):
1369     def __init__(self, *args, **kwargs):
1370         pass
1371
1372     def __repr__(self):
1373         return '<KeyringACLMap %s>' % self.keyring_acl_map_id
1374
1375 __all__.append('KeyringACLMap')
1376
1377 ################################################################################
1378
1379 class DBChange(object):
1380     def __init__(self, *args, **kwargs):
1381         pass
1382
1383     def __repr__(self):
1384         return '<DBChange %s>' % self.changesname
1385
1386 __all__.append('DBChange')
1387
1388 @session_wrapper
1389 def get_dbchange(filename, session=None):
1390     """
1391     returns DBChange object for given C{filename}.
1392
1393     @type filename: string
1394     @param filename: the name of the file
1395
1396     @type session: Session
1397     @param session: Optional SQLA session object (a temporary one will be
1398     generated if not supplied)
1399
1400     @rtype: DBChange
1401     @return:  DBChange object for the given filename (C{None} if not present)
1402
1403     """
1404     q = session.query(DBChange).filter_by(changesname=filename)
1405
1406     try:
1407         return q.one()
1408     except NoResultFound:
1409         return None
1410
1411 __all__.append('get_dbchange')
1412
1413 ################################################################################
1414
1415 class Maintainer(ORMObject):
1416     def __init__(self, name = None):
1417         self.name = name
1418
1419     def properties(self):
1420         return ['name', 'maintainer_id']
1421
1422     def not_null_constraints(self):
1423         return ['name']
1424
1425     def get_split_maintainer(self):
1426         if not hasattr(self, 'name') or self.name is None:
1427             return ('', '', '', '')
1428
1429         return fix_maintainer(self.name.strip())
1430
1431 __all__.append('Maintainer')
1432
1433 @session_wrapper
1434 def get_or_set_maintainer(name, session=None):
1435     """
1436     Returns Maintainer object for given maintainer name.
1437
1438     If no matching maintainer name is found, a row is inserted.
1439
1440     @type name: string
1441     @param name: The maintainer name to add
1442
1443     @type session: SQLAlchemy
1444     @param session: Optional SQL session object (a temporary one will be
1445     generated if not supplied).  If not passed, a commit will be performed at
1446     the end of the function, otherwise the caller is responsible for commiting.
1447     A flush will be performed either way.
1448
1449     @rtype: Maintainer
1450     @return: the Maintainer object for the given maintainer
1451     """
1452
1453     q = session.query(Maintainer).filter_by(name=name)
1454     try:
1455         ret = q.one()
1456     except NoResultFound:
1457         maintainer = Maintainer()
1458         maintainer.name = name
1459         session.add(maintainer)
1460         session.commit_or_flush()
1461         ret = maintainer
1462
1463     return ret
1464
1465 __all__.append('get_or_set_maintainer')
1466
1467 @session_wrapper
1468 def get_maintainer(maintainer_id, session=None):
1469     """
1470     Return the name of the maintainer behind C{maintainer_id} or None if that
1471     maintainer_id is invalid.
1472
1473     @type maintainer_id: int
1474     @param maintainer_id: the id of the maintainer
1475
1476     @rtype: Maintainer
1477     @return: the Maintainer with this C{maintainer_id}
1478     """
1479
1480     return session.query(Maintainer).get(maintainer_id)
1481
1482 __all__.append('get_maintainer')
1483
1484 ################################################################################
1485
1486 class NewComment(object):
1487     def __init__(self, *args, **kwargs):
1488         pass
1489
1490     def __repr__(self):
1491         return '''<NewComment for '%s %s' (%s)>''' % (self.package, self.version, self.comment_id)
1492
1493 __all__.append('NewComment')
1494
1495 @session_wrapper
1496 def has_new_comment(package, version, session=None):
1497     """
1498     Returns true if the given combination of C{package}, C{version} has a comment.
1499
1500     @type package: string
1501     @param package: name of the package
1502
1503     @type version: string
1504     @param version: package version
1505
1506     @type session: Session
1507     @param session: Optional SQLA session object (a temporary one will be
1508     generated if not supplied)
1509
1510     @rtype: boolean
1511     @return: true/false
1512     """
1513
1514     q = session.query(NewComment)
1515     q = q.filter_by(package=package)
1516     q = q.filter_by(version=version)
1517
1518     return bool(q.count() > 0)
1519
1520 __all__.append('has_new_comment')
1521
1522 @session_wrapper
1523 def get_new_comments(package=None, version=None, comment_id=None, session=None):
1524     """
1525     Returns (possibly empty) list of NewComment objects for the given
1526     parameters
1527
1528     @type package: string (optional)
1529     @param package: name of the package
1530
1531     @type version: string (optional)
1532     @param version: package version
1533
1534     @type comment_id: int (optional)
1535     @param comment_id: An id of a comment
1536
1537     @type session: Session
1538     @param session: Optional SQLA session object (a temporary one will be
1539     generated if not supplied)
1540
1541     @rtype: list
1542     @return: A (possibly empty) list of NewComment objects will be returned
1543     """
1544
1545     q = session.query(NewComment)
1546     if package is not None: q = q.filter_by(package=package)
1547     if version is not None: q = q.filter_by(version=version)
1548     if comment_id is not None: q = q.filter_by(comment_id=comment_id)
1549
1550     return q.all()
1551
1552 __all__.append('get_new_comments')
1553
1554 ################################################################################
1555
1556 class Override(ORMObject):
1557     def __init__(self, package = None, suite = None, component = None, overridetype = None, \
1558         section = None, priority = None):
1559         self.package = package
1560         self.suite = suite
1561         self.component = component
1562         self.overridetype = overridetype
1563         self.section = section
1564         self.priority = priority
1565
1566     def properties(self):
1567         return ['package', 'suite', 'component', 'overridetype', 'section', \
1568             'priority']
1569
1570     def not_null_constraints(self):
1571         return ['package', 'suite', 'component', 'overridetype', 'section']
1572
1573 __all__.append('Override')
1574
1575 @session_wrapper
1576 def get_override(package, suite=None, component=None, overridetype=None, session=None):
1577     """
1578     Returns Override object for the given parameters
1579
1580     @type package: string
1581     @param package: The name of the package
1582
1583     @type suite: string, list or None
1584     @param suite: The name of the suite (or suites if a list) to limit to.  If
1585                   None, don't limit.  Defaults to None.
1586
1587     @type component: string, list or None
1588     @param component: The name of the component (or components if a list) to
1589                       limit to.  If None, don't limit.  Defaults to None.
1590
1591     @type overridetype: string, list or None
1592     @param overridetype: The name of the overridetype (or overridetypes if a list) to
1593                          limit to.  If None, don't limit.  Defaults to None.
1594
1595     @type session: Session
1596     @param session: Optional SQLA session object (a temporary one will be
1597     generated if not supplied)
1598
1599     @rtype: list
1600     @return: A (possibly empty) list of Override objects will be returned
1601     """
1602
1603     q = session.query(Override)
1604     q = q.filter_by(package=package)
1605
1606     if suite is not None:
1607         if not isinstance(suite, list): suite = [suite]
1608         q = q.join(Suite).filter(Suite.suite_name.in_(suite))
1609
1610     if component is not None:
1611         if not isinstance(component, list): component = [component]
1612         q = q.join(Component).filter(Component.component_name.in_(component))
1613
1614     if overridetype is not None:
1615         if not isinstance(overridetype, list): overridetype = [overridetype]
1616         q = q.join(OverrideType).filter(OverrideType.overridetype.in_(overridetype))
1617
1618     return q.all()
1619
1620 __all__.append('get_override')
1621
1622
1623 ################################################################################
1624
1625 class OverrideType(ORMObject):
1626     def __init__(self, overridetype = None):
1627         self.overridetype = overridetype
1628
1629     def properties(self):
1630         return ['overridetype', 'overridetype_id', 'overrides_count']
1631
1632     def not_null_constraints(self):
1633         return ['overridetype']
1634
1635 __all__.append('OverrideType')
1636
1637 @session_wrapper
1638 def get_override_type(override_type, session=None):
1639     """
1640     Returns OverrideType object for given C{override type}.
1641
1642     @type override_type: string
1643     @param override_type: The name of the override type
1644
1645     @type session: Session
1646     @param session: Optional SQLA session object (a temporary one will be
1647     generated if not supplied)
1648
1649     @rtype: int
1650     @return: the database id for the given override type
1651     """
1652
1653     q = session.query(OverrideType).filter_by(overridetype=override_type)
1654
1655     try:
1656         return q.one()
1657     except NoResultFound:
1658         return None
1659
1660 __all__.append('get_override_type')
1661
1662 ################################################################################
1663
1664 class PolicyQueue(object):
1665     def __init__(self, *args, **kwargs):
1666         pass
1667
1668     def __repr__(self):
1669         return '<PolicyQueue %s>' % self.queue_name
1670
1671 __all__.append('PolicyQueue')
1672
1673 @session_wrapper
1674 def get_policy_queue(queuename, session=None):
1675     """
1676     Returns PolicyQueue object for given C{queue name}
1677
1678     @type queuename: string
1679     @param queuename: The name of the queue
1680
1681     @type session: Session
1682     @param session: Optional SQLA session object (a temporary one will be
1683     generated if not supplied)
1684
1685     @rtype: PolicyQueue
1686     @return: PolicyQueue object for the given queue
1687     """
1688
1689     q = session.query(PolicyQueue).filter_by(queue_name=queuename)
1690
1691     try:
1692         return q.one()
1693     except NoResultFound:
1694         return None
1695
1696 __all__.append('get_policy_queue')
1697
1698 ################################################################################
1699
1700 class PolicyQueueUpload(object):
1701     def __cmp__(self, other):
1702         ret = cmp(self.changes.source, other.changes.source)
1703         if ret == 0:
1704             ret = apt_pkg.version_compare(self.changes.version, other.changes.version)
1705         if ret == 0:
1706             if self.source is not None and other.source is None:
1707                 ret = -1
1708             elif self.source is None and other.source is not None:
1709                 ret = 1
1710         if ret == 0:
1711             ret = cmp(self.changes.changesname, other.changes.changesname)
1712         return ret
1713
1714 __all__.append('PolicyQueueUpload')
1715
1716 ################################################################################
1717
1718 class PolicyQueueByhandFile(object):
1719     pass
1720
1721 __all__.append('PolicyQueueByhandFile')
1722
1723 ################################################################################
1724
1725 class Priority(ORMObject):
1726     def __init__(self, priority = None, level = None):
1727         self.priority = priority
1728         self.level = level
1729
1730     def properties(self):
1731         return ['priority', 'priority_id', 'level', 'overrides_count']
1732
1733     def not_null_constraints(self):
1734         return ['priority', 'level']
1735
1736     def __eq__(self, val):
1737         if isinstance(val, str):
1738             return (self.priority == val)
1739         # This signals to use the normal comparison operator
1740         return NotImplemented
1741
1742     def __ne__(self, val):
1743         if isinstance(val, str):
1744             return (self.priority != val)
1745         # This signals to use the normal comparison operator
1746         return NotImplemented
1747
1748 __all__.append('Priority')
1749
1750 @session_wrapper
1751 def get_priority(priority, session=None):
1752     """
1753     Returns Priority object for given C{priority name}.
1754
1755     @type priority: string
1756     @param priority: The name of the priority
1757
1758     @type session: Session
1759     @param session: Optional SQLA session object (a temporary one will be
1760     generated if not supplied)
1761
1762     @rtype: Priority
1763     @return: Priority object for the given priority
1764     """
1765
1766     q = session.query(Priority).filter_by(priority=priority)
1767
1768     try:
1769         return q.one()
1770     except NoResultFound:
1771         return None
1772
1773 __all__.append('get_priority')
1774
1775 @session_wrapper
1776 def get_priorities(session=None):
1777     """
1778     Returns dictionary of priority names -> id mappings
1779
1780     @type session: Session
1781     @param session: Optional SQL session object (a temporary one will be
1782     generated if not supplied)
1783
1784     @rtype: dictionary
1785     @return: dictionary of priority names -> id mappings
1786     """
1787
1788     ret = {}
1789     q = session.query(Priority)
1790     for x in q.all():
1791         ret[x.priority] = x.priority_id
1792
1793     return ret
1794
1795 __all__.append('get_priorities')
1796
1797 ################################################################################
1798
1799 class Section(ORMObject):
1800     def __init__(self, section = None):
1801         self.section = section
1802
1803     def properties(self):
1804         return ['section', 'section_id', 'overrides_count']
1805
1806     def not_null_constraints(self):
1807         return ['section']
1808
1809     def __eq__(self, val):
1810         if isinstance(val, str):
1811             return (self.section == val)
1812         # This signals to use the normal comparison operator
1813         return NotImplemented
1814
1815     def __ne__(self, val):
1816         if isinstance(val, str):
1817             return (self.section != val)
1818         # This signals to use the normal comparison operator
1819         return NotImplemented
1820
1821 __all__.append('Section')
1822
1823 @session_wrapper
1824 def get_section(section, session=None):
1825     """
1826     Returns Section object for given C{section name}.
1827
1828     @type section: string
1829     @param section: The name of the section
1830
1831     @type session: Session
1832     @param session: Optional SQLA session object (a temporary one will be
1833     generated if not supplied)
1834
1835     @rtype: Section
1836     @return: Section object for the given section name
1837     """
1838
1839     q = session.query(Section).filter_by(section=section)
1840
1841     try:
1842         return q.one()
1843     except NoResultFound:
1844         return None
1845
1846 __all__.append('get_section')
1847
1848 @session_wrapper
1849 def get_sections(session=None):
1850     """
1851     Returns dictionary of section names -> id mappings
1852
1853     @type session: Session
1854     @param session: Optional SQL session object (a temporary one will be
1855     generated if not supplied)
1856
1857     @rtype: dictionary
1858     @return: dictionary of section names -> id mappings
1859     """
1860
1861     ret = {}
1862     q = session.query(Section)
1863     for x in q.all():
1864         ret[x.section] = x.section_id
1865
1866     return ret
1867
1868 __all__.append('get_sections')
1869
1870 ################################################################################
1871
1872 class SrcContents(ORMObject):
1873     def __init__(self, file = None, source = None):
1874         self.file = file
1875         self.source = source
1876
1877     def properties(self):
1878         return ['file', 'source']
1879
1880 __all__.append('SrcContents')
1881
1882 ################################################################################
1883
1884 from debian.debfile import Deb822
1885
1886 # Temporary Deb822 subclass to fix bugs with : handling; see #597249
1887 class Dak822(Deb822):
1888     def _internal_parser(self, sequence, fields=None):
1889         # The key is non-whitespace, non-colon characters before any colon.
1890         key_part = r"^(?P<key>[^: \t\n\r\f\v]+)\s*:\s*"
1891         single = re.compile(key_part + r"(?P<data>\S.*?)\s*$")
1892         multi = re.compile(key_part + r"$")
1893         multidata = re.compile(r"^\s(?P<data>.+?)\s*$")
1894
1895         wanted_field = lambda f: fields is None or f in fields
1896
1897         if isinstance(sequence, basestring):
1898             sequence = sequence.splitlines()
1899
1900         curkey = None
1901         content = ""
1902         for line in self.gpg_stripped_paragraph(sequence):
1903             m = single.match(line)
1904             if m:
1905                 if curkey:
1906                     self[curkey] = content
1907
1908                 if not wanted_field(m.group('key')):
1909                     curkey = None
1910                     continue
1911
1912                 curkey = m.group('key')
1913                 content = m.group('data')
1914                 continue
1915
1916             m = multi.match(line)
1917             if m:
1918                 if curkey:
1919                     self[curkey] = content
1920
1921                 if not wanted_field(m.group('key')):
1922                     curkey = None
1923                     continue
1924
1925                 curkey = m.group('key')
1926                 content = ""
1927                 continue
1928
1929             m = multidata.match(line)
1930             if m:
1931                 content += '\n' + line # XXX not m.group('data')?
1932                 continue
1933
1934         if curkey:
1935             self[curkey] = content
1936
1937
1938 class DBSource(ORMObject):
1939     def __init__(self, source = None, version = None, maintainer = None, \
1940         changedby = None, poolfile = None, install_date = None, fingerprint = None):
1941         self.source = source
1942         self.version = version
1943         self.maintainer = maintainer
1944         self.changedby = changedby
1945         self.poolfile = poolfile
1946         self.install_date = install_date
1947         self.fingerprint = fingerprint
1948
1949     @property
1950     def pkid(self):
1951         return self.source_id
1952
1953     def properties(self):
1954         return ['source', 'source_id', 'maintainer', 'changedby', \
1955             'fingerprint', 'poolfile', 'version', 'suites_count', \
1956             'install_date', 'binaries_count', 'uploaders_count']
1957
1958     def not_null_constraints(self):
1959         return ['source', 'version', 'install_date', 'maintainer', \
1960             'changedby', 'poolfile']
1961
1962     def read_control_fields(self):
1963         '''
1964         Reads the control information from a dsc
1965
1966         @rtype: tuple
1967         @return: fields is the dsc information in a dictionary form
1968         '''
1969         fullpath = self.poolfile.fullpath
1970         fields = Dak822(open(self.poolfile.fullpath, 'r'))
1971         return fields
1972
1973     metadata = association_proxy('key', 'value')
1974
1975     def scan_contents(self):
1976         '''
1977         Returns a set of names for non directories. The path names are
1978         normalized after converting them from either utf-8 or iso8859-1
1979         encoding.
1980         '''
1981         fullpath = self.poolfile.fullpath
1982         from daklib.contents import UnpackedSource
1983         unpacked = UnpackedSource(fullpath)
1984         fileset = set()
1985         for name in unpacked.get_all_filenames():
1986             # enforce proper utf-8 encoding
1987             try:
1988                 name.decode('utf-8')
1989             except UnicodeDecodeError:
1990                 name = name.decode('iso8859-1').encode('utf-8')
1991             fileset.add(name)
1992         return fileset
1993
1994 __all__.append('DBSource')
1995
1996 @session_wrapper
1997 def source_exists(source, source_version, suites = ["any"], session=None):
1998     """
1999     Ensure that source exists somewhere in the archive for the binary
2000     upload being processed.
2001       1. exact match     => 1.0-3
2002       2. bin-only NMU    => 1.0-3+b1 , 1.0-3.1+b1
2003
2004     @type source: string
2005     @param source: source name
2006
2007     @type source_version: string
2008     @param source_version: expected source version
2009
2010     @type suites: list
2011     @param suites: list of suites to check in, default I{any}
2012
2013     @type session: Session
2014     @param session: Optional SQLA session object (a temporary one will be
2015     generated if not supplied)
2016
2017     @rtype: int
2018     @return: returns 1 if a source with expected version is found, otherwise 0
2019
2020     """
2021
2022     cnf = Config()
2023     ret = True
2024
2025     from daklib.regexes import re_bin_only_nmu
2026     orig_source_version = re_bin_only_nmu.sub('', source_version)
2027
2028     for suite in suites:
2029         q = session.query(DBSource).filter_by(source=source). \
2030             filter(DBSource.version.in_([source_version, orig_source_version]))
2031         if suite != "any":
2032             # source must exist in 'suite' or a suite that is enhanced by 'suite'
2033             s = get_suite(suite, session)
2034             if s:
2035                 enhances_vcs = session.query(VersionCheck).filter(VersionCheck.suite==s).filter_by(check='Enhances')
2036                 considered_suites = [ vc.reference for vc in enhances_vcs ]
2037                 considered_suites.append(s)
2038
2039                 q = q.filter(DBSource.suites.any(Suite.suite_id.in_([s.suite_id for s in considered_suites])))
2040
2041         if q.count() > 0:
2042             continue
2043
2044         # No source found so return not ok
2045         ret = False
2046
2047     return ret
2048
2049 __all__.append('source_exists')
2050
2051 @session_wrapper
2052 def get_suites_source_in(source, session=None):
2053     """
2054     Returns list of Suite objects which given C{source} name is in
2055
2056     @type source: str
2057     @param source: DBSource package name to search for
2058
2059     @rtype: list
2060     @return: list of Suite objects for the given source
2061     """
2062
2063     return session.query(Suite).filter(Suite.sources.any(source=source)).all()
2064
2065 __all__.append('get_suites_source_in')
2066
2067 @session_wrapper
2068 def get_sources_from_name(source, version=None, dm_upload_allowed=None, session=None):
2069     """
2070     Returns list of DBSource objects for given C{source} name and other parameters
2071
2072     @type source: str
2073     @param source: DBSource package name to search for
2074
2075     @type version: str or None
2076     @param version: DBSource version name to search for or None if not applicable
2077
2078     @type dm_upload_allowed: bool
2079     @param dm_upload_allowed: If None, no effect.  If True or False, only
2080     return packages with that dm_upload_allowed setting
2081
2082     @type session: Session
2083     @param session: Optional SQL session object (a temporary one will be
2084     generated if not supplied)
2085
2086     @rtype: list
2087     @return: list of DBSource objects for the given name (may be empty)
2088     """
2089
2090     q = session.query(DBSource).filter_by(source=source)
2091
2092     if version is not None:
2093         q = q.filter_by(version=version)
2094
2095     if dm_upload_allowed is not None:
2096         q = q.filter_by(dm_upload_allowed=dm_upload_allowed)
2097
2098     return q.all()
2099
2100 __all__.append('get_sources_from_name')
2101
2102 # FIXME: This function fails badly if it finds more than 1 source package and
2103 # its implementation is trivial enough to be inlined.
2104 @session_wrapper
2105 def get_source_in_suite(source, suite, session=None):
2106     """
2107     Returns a DBSource object for a combination of C{source} and C{suite}.
2108
2109       - B{source} - source package name, eg. I{mailfilter}, I{bbdb}, I{glibc}
2110       - B{suite} - a suite name, eg. I{unstable}
2111
2112     @type source: string
2113     @param source: source package name
2114
2115     @type suite: string
2116     @param suite: the suite name
2117
2118     @rtype: string
2119     @return: the version for I{source} in I{suite}
2120
2121     """
2122
2123     q = get_suite(suite, session).get_sources(source)
2124     try:
2125         return q.one()
2126     except NoResultFound:
2127         return None
2128
2129 __all__.append('get_source_in_suite')
2130
2131 @session_wrapper
2132 def import_metadata_into_db(obj, session=None):
2133     """
2134     This routine works on either DBBinary or DBSource objects and imports
2135     their metadata into the database
2136     """
2137     fields = obj.read_control_fields()
2138     for k in fields.keys():
2139         try:
2140             # Try raw ASCII
2141             val = str(fields[k])
2142         except UnicodeEncodeError:
2143             # Fall back to UTF-8
2144             try:
2145                 val = fields[k].encode('utf-8')
2146             except UnicodeEncodeError:
2147                 # Finally try iso8859-1
2148                 val = fields[k].encode('iso8859-1')
2149                 # Otherwise we allow the exception to percolate up and we cause
2150                 # a reject as someone is playing silly buggers
2151
2152         obj.metadata[get_or_set_metadatakey(k, session)] = val
2153
2154     session.commit_or_flush()
2155
2156 __all__.append('import_metadata_into_db')
2157
2158 ################################################################################
2159
2160 class SourceACL(object):
2161     def __init__(self, *args, **kwargs):
2162         pass
2163
2164     def __repr__(self):
2165         return '<SourceACL %s>' % self.source_acl_id
2166
2167 __all__.append('SourceACL')
2168
2169 ################################################################################
2170
2171 class SrcFormat(object):
2172     def __init__(self, *args, **kwargs):
2173         pass
2174
2175     def __repr__(self):
2176         return '<SrcFormat %s>' % (self.format_name)
2177
2178 __all__.append('SrcFormat')
2179
2180 ################################################################################
2181
2182 SUITE_FIELDS = [ ('SuiteName', 'suite_name'),
2183                  ('SuiteID', 'suite_id'),
2184                  ('Version', 'version'),
2185                  ('Origin', 'origin'),
2186                  ('Label', 'label'),
2187                  ('Description', 'description'),
2188                  ('Untouchable', 'untouchable'),
2189                  ('Announce', 'announce'),
2190                  ('Codename', 'codename'),
2191                  ('OverrideCodename', 'overridecodename'),
2192                  ('ValidTime', 'validtime'),
2193                  ('Priority', 'priority'),
2194                  ('NotAutomatic', 'notautomatic'),
2195                  ('CopyChanges', 'copychanges'),
2196                  ('OverrideSuite', 'overridesuite')]
2197
2198 # Why the heck don't we have any UNIQUE constraints in table suite?
2199 # TODO: Add UNIQUE constraints for appropriate columns.
2200 class Suite(ORMObject):
2201     def __init__(self, suite_name = None, version = None):
2202         self.suite_name = suite_name
2203         self.version = version
2204
2205     def properties(self):
2206         return ['suite_name', 'version', 'sources_count', 'binaries_count', \
2207             'overrides_count']
2208
2209     def not_null_constraints(self):
2210         return ['suite_name']
2211
2212     def __eq__(self, val):
2213         if isinstance(val, str):
2214             return (self.suite_name == val)
2215         # This signals to use the normal comparison operator
2216         return NotImplemented
2217
2218     def __ne__(self, val):
2219         if isinstance(val, str):
2220             return (self.suite_name != val)
2221         # This signals to use the normal comparison operator
2222         return NotImplemented
2223
2224     def details(self):
2225         ret = []
2226         for disp, field in SUITE_FIELDS:
2227             val = getattr(self, field, None)
2228             if val is not None:
2229                 ret.append("%s: %s" % (disp, val))
2230
2231         return "\n".join(ret)
2232
2233     def get_architectures(self, skipsrc=False, skipall=False):
2234         """
2235         Returns list of Architecture objects
2236
2237         @type skipsrc: boolean
2238         @param skipsrc: Whether to skip returning the 'source' architecture entry
2239         (Default False)
2240
2241         @type skipall: boolean
2242         @param skipall: Whether to skip returning the 'all' architecture entry
2243         (Default False)
2244
2245         @rtype: list
2246         @return: list of Architecture objects for the given name (may be empty)
2247         """
2248
2249         q = object_session(self).query(Architecture).with_parent(self)
2250         if skipsrc:
2251             q = q.filter(Architecture.arch_string != 'source')
2252         if skipall:
2253             q = q.filter(Architecture.arch_string != 'all')
2254         return q.order_by(Architecture.arch_string).all()
2255
2256     def get_sources(self, source):
2257         """
2258         Returns a query object representing DBSource that is part of C{suite}.
2259
2260           - B{source} - source package name, eg. I{mailfilter}, I{bbdb}, I{glibc}
2261
2262         @type source: string
2263         @param source: source package name
2264
2265         @rtype: sqlalchemy.orm.query.Query
2266         @return: a query of DBSource
2267
2268         """
2269
2270         session = object_session(self)
2271         return session.query(DBSource).filter_by(source = source). \
2272             with_parent(self)
2273
2274     def get_overridesuite(self):
2275         if self.overridesuite is None:
2276             return self
2277         else:
2278             return object_session(self).query(Suite).filter_by(suite_name=self.overridesuite).one()
2279
2280     @property
2281     def path(self):
2282         return os.path.join(self.archive.path, 'dists', self.suite_name)
2283
2284 __all__.append('Suite')
2285
2286 @session_wrapper
2287 def get_suite(suite, session=None):
2288     """
2289     Returns Suite object for given C{suite name}.
2290
2291     @type suite: string
2292     @param suite: The name of the suite
2293
2294     @type session: Session
2295     @param session: Optional SQLA session object (a temporary one will be
2296     generated if not supplied)
2297
2298     @rtype: Suite
2299     @return: Suite object for the requested suite name (None if not present)
2300     """
2301
2302     q = session.query(Suite).filter_by(suite_name=suite)
2303
2304     try:
2305         return q.one()
2306     except NoResultFound:
2307         return None
2308
2309 __all__.append('get_suite')
2310
2311 ################################################################################
2312
2313 @session_wrapper
2314 def get_suite_architectures(suite, skipsrc=False, skipall=False, session=None):
2315     """
2316     Returns list of Architecture objects for given C{suite} name. The list is
2317     empty if suite does not exist.
2318
2319     @type suite: str
2320     @param suite: Suite name to search for
2321
2322     @type skipsrc: boolean
2323     @param skipsrc: Whether to skip returning the 'source' architecture entry
2324     (Default False)
2325
2326     @type skipall: boolean
2327     @param skipall: Whether to skip returning the 'all' architecture entry
2328     (Default False)
2329
2330     @type session: Session
2331     @param session: Optional SQL session object (a temporary one will be
2332     generated if not supplied)
2333
2334     @rtype: list
2335     @return: list of Architecture objects for the given name (may be empty)
2336     """
2337
2338     try:
2339         return get_suite(suite, session).get_architectures(skipsrc, skipall)
2340     except AttributeError:
2341         return []
2342
2343 __all__.append('get_suite_architectures')
2344
2345 ################################################################################
2346
2347 class Uid(ORMObject):
2348     def __init__(self, uid = None, name = None):
2349         self.uid = uid
2350         self.name = name
2351
2352     def __eq__(self, val):
2353         if isinstance(val, str):
2354             return (self.uid == val)
2355         # This signals to use the normal comparison operator
2356         return NotImplemented
2357
2358     def __ne__(self, val):
2359         if isinstance(val, str):
2360             return (self.uid != val)
2361         # This signals to use the normal comparison operator
2362         return NotImplemented
2363
2364     def properties(self):
2365         return ['uid', 'name', 'fingerprint']
2366
2367     def not_null_constraints(self):
2368         return ['uid']
2369
2370 __all__.append('Uid')
2371
2372 @session_wrapper
2373 def get_or_set_uid(uidname, session=None):
2374     """
2375     Returns uid object for given uidname.
2376
2377     If no matching uidname is found, a row is inserted.
2378
2379     @type uidname: string
2380     @param uidname: The uid to add
2381
2382     @type session: SQLAlchemy
2383     @param session: Optional SQL session object (a temporary one will be
2384     generated if not supplied).  If not passed, a commit will be performed at
2385     the end of the function, otherwise the caller is responsible for commiting.
2386
2387     @rtype: Uid
2388     @return: the uid object for the given uidname
2389     """
2390
2391     q = session.query(Uid).filter_by(uid=uidname)
2392
2393     try:
2394         ret = q.one()
2395     except NoResultFound:
2396         uid = Uid()
2397         uid.uid = uidname
2398         session.add(uid)
2399         session.commit_or_flush()
2400         ret = uid
2401
2402     return ret
2403
2404 __all__.append('get_or_set_uid')
2405
2406 @session_wrapper
2407 def get_uid_from_fingerprint(fpr, session=None):
2408     q = session.query(Uid)
2409     q = q.join(Fingerprint).filter_by(fingerprint=fpr)
2410
2411     try:
2412         return q.one()
2413     except NoResultFound:
2414         return None
2415
2416 __all__.append('get_uid_from_fingerprint')
2417
2418 ################################################################################
2419
2420 class UploadBlock(object):
2421     def __init__(self, *args, **kwargs):
2422         pass
2423
2424     def __repr__(self):
2425         return '<UploadBlock %s (%s)>' % (self.source, self.upload_block_id)
2426
2427 __all__.append('UploadBlock')
2428
2429 ################################################################################
2430
2431 class MetadataKey(ORMObject):
2432     def __init__(self, key = None):
2433         self.key = key
2434
2435     def properties(self):
2436         return ['key']
2437
2438     def not_null_constraints(self):
2439         return ['key']
2440
2441 __all__.append('MetadataKey')
2442
2443 @session_wrapper
2444 def get_or_set_metadatakey(keyname, session=None):
2445     """
2446     Returns MetadataKey object for given uidname.
2447
2448     If no matching keyname is found, a row is inserted.
2449
2450     @type uidname: string
2451     @param uidname: The keyname to add
2452
2453     @type session: SQLAlchemy
2454     @param session: Optional SQL session object (a temporary one will be
2455     generated if not supplied).  If not passed, a commit will be performed at
2456     the end of the function, otherwise the caller is responsible for commiting.
2457
2458     @rtype: MetadataKey
2459     @return: the metadatakey object for the given keyname
2460     """
2461
2462     q = session.query(MetadataKey).filter_by(key=keyname)
2463
2464     try:
2465         ret = q.one()
2466     except NoResultFound:
2467         ret = MetadataKey(keyname)
2468         session.add(ret)
2469         session.commit_or_flush()
2470
2471     return ret
2472
2473 __all__.append('get_or_set_metadatakey')
2474
2475 ################################################################################
2476
2477 class BinaryMetadata(ORMObject):
2478     def __init__(self, key = None, value = None, binary = None):
2479         self.key = key
2480         self.value = value
2481         self.binary = binary
2482
2483     def properties(self):
2484         return ['binary', 'key', 'value']
2485
2486     def not_null_constraints(self):
2487         return ['value']
2488
2489 __all__.append('BinaryMetadata')
2490
2491 ################################################################################
2492
2493 class SourceMetadata(ORMObject):
2494     def __init__(self, key = None, value = None, source = None):
2495         self.key = key
2496         self.value = value
2497         self.source = source
2498
2499     def properties(self):
2500         return ['source', 'key', 'value']
2501
2502     def not_null_constraints(self):
2503         return ['value']
2504
2505 __all__.append('SourceMetadata')
2506
2507 ################################################################################
2508
2509 class VersionCheck(ORMObject):
2510     def __init__(self, *args, **kwargs):
2511         pass
2512
2513     def properties(self):
2514         #return ['suite_id', 'check', 'reference_id']
2515         return ['check']
2516
2517     def not_null_constraints(self):
2518         return ['suite', 'check', 'reference']
2519
2520 __all__.append('VersionCheck')
2521
2522 @session_wrapper
2523 def get_version_checks(suite_name, check = None, session = None):
2524     suite = get_suite(suite_name, session)
2525     if not suite:
2526         # Make sure that what we return is iterable so that list comprehensions
2527         # involving this don't cause a traceback
2528         return []
2529     q = session.query(VersionCheck).filter_by(suite=suite)
2530     if check:
2531         q = q.filter_by(check=check)
2532     return q.all()
2533
2534 __all__.append('get_version_checks')
2535
2536 ################################################################################
2537
2538 class DBConn(object):
2539     """
2540     database module init.
2541     """
2542     __shared_state = {}
2543
2544     def __init__(self, *args, **kwargs):
2545         self.__dict__ = self.__shared_state
2546
2547         if not getattr(self, 'initialised', False):
2548             self.initialised = True
2549             self.debug = kwargs.has_key('debug')
2550             self.__createconn()
2551
2552     def __setuptables(self):
2553         tables = (
2554             'architecture',
2555             'archive',
2556             'bin_associations',
2557             'bin_contents',
2558             'binaries',
2559             'binaries_metadata',
2560             'binary_acl',
2561             'binary_acl_map',
2562             'build_queue',
2563             'changelogs_text',
2564             'changes',
2565             'component',
2566             'config',
2567             'dsc_files',
2568             'external_overrides',
2569             'extra_src_references',
2570             'files',
2571             'files_archive_map',
2572             'fingerprint',
2573             'keyrings',
2574             'keyring_acl_map',
2575             'maintainer',
2576             'metadata_keys',
2577             'new_comments',
2578             # TODO: the maintainer column in table override should be removed.
2579             'override',
2580             'override_type',
2581             'policy_queue',
2582             'policy_queue_upload',
2583             'policy_queue_upload_binaries_map',
2584             'policy_queue_byhand_file',
2585             'priority',
2586             'section',
2587             'source',
2588             'source_acl',
2589             'source_metadata',
2590             'src_associations',
2591             'src_contents',
2592             'src_format',
2593             'src_uploaders',
2594             'suite',
2595             'suite_architectures',
2596             'suite_build_queue_copy',
2597             'suite_src_formats',
2598             'uid',
2599             'upload_blocks',
2600             'version_check',
2601         )
2602
2603         views = (
2604             'almost_obsolete_all_associations',
2605             'almost_obsolete_src_associations',
2606             'any_associations_source',
2607             'bin_associations_binaries',
2608             'binaries_suite_arch',
2609             'changelogs',
2610             'file_arch_suite',
2611             'newest_all_associations',
2612             'newest_any_associations',
2613             'newest_source',
2614             'newest_src_association',
2615             'obsolete_all_associations',
2616             'obsolete_any_associations',
2617             'obsolete_any_by_all_associations',
2618             'obsolete_src_associations',
2619             'source_suite',
2620             'src_associations_bin',
2621             'src_associations_src',
2622             'suite_arch_by_name',
2623         )
2624
2625         for table_name in tables:
2626             table = Table(table_name, self.db_meta, \
2627                 autoload=True, useexisting=True)
2628             setattr(self, 'tbl_%s' % table_name, table)
2629
2630         for view_name in views:
2631             view = Table(view_name, self.db_meta, autoload=True)
2632             setattr(self, 'view_%s' % view_name, view)
2633
2634     def __setupmappers(self):
2635         mapper(Architecture, self.tbl_architecture,
2636             properties = dict(arch_id = self.tbl_architecture.c.id,
2637                suites = relation(Suite, secondary=self.tbl_suite_architectures,
2638                    order_by=self.tbl_suite.c.suite_name,
2639                    backref=backref('architectures', order_by=self.tbl_architecture.c.arch_string))),
2640             extension = validator)
2641
2642         mapper(Archive, self.tbl_archive,
2643                properties = dict(archive_id = self.tbl_archive.c.id,
2644                                  archive_name = self.tbl_archive.c.name))
2645
2646         mapper(ArchiveFile, self.tbl_files_archive_map,
2647                properties = dict(archive = relation(Archive, backref='files'),
2648                                  component = relation(Component),
2649                                  file = relation(PoolFile, backref='archives')))
2650
2651         mapper(BuildQueue, self.tbl_build_queue,
2652                properties = dict(queue_id = self.tbl_build_queue.c.id,
2653                                  suite = relation(Suite, primaryjoin=(self.tbl_build_queue.c.suite_id==self.tbl_suite.c.id))))
2654
2655         mapper(DBBinary, self.tbl_binaries,
2656                properties = dict(binary_id = self.tbl_binaries.c.id,
2657                                  package = self.tbl_binaries.c.package,
2658                                  version = self.tbl_binaries.c.version,
2659                                  maintainer_id = self.tbl_binaries.c.maintainer,
2660                                  maintainer = relation(Maintainer),
2661                                  source_id = self.tbl_binaries.c.source,
2662                                  source = relation(DBSource, backref='binaries'),
2663                                  arch_id = self.tbl_binaries.c.architecture,
2664                                  architecture = relation(Architecture),
2665                                  poolfile_id = self.tbl_binaries.c.file,
2666                                  poolfile = relation(PoolFile),
2667                                  binarytype = self.tbl_binaries.c.type,
2668                                  fingerprint_id = self.tbl_binaries.c.sig_fpr,
2669                                  fingerprint = relation(Fingerprint),
2670                                  install_date = self.tbl_binaries.c.install_date,
2671                                  suites = relation(Suite, secondary=self.tbl_bin_associations,
2672                                      backref=backref('binaries', lazy='dynamic')),
2673                                  extra_sources = relation(DBSource, secondary=self.tbl_extra_src_references,
2674                                      backref=backref('extra_binary_references', lazy='dynamic')),
2675                                  key = relation(BinaryMetadata, cascade='all',
2676                                      collection_class=attribute_mapped_collection('key'))),
2677                 extension = validator)
2678
2679         mapper(BinaryACL, self.tbl_binary_acl,
2680                properties = dict(binary_acl_id = self.tbl_binary_acl.c.id))
2681
2682         mapper(BinaryACLMap, self.tbl_binary_acl_map,
2683                properties = dict(binary_acl_map_id = self.tbl_binary_acl_map.c.id,
2684                                  fingerprint = relation(Fingerprint, backref="binary_acl_map"),
2685                                  architecture = relation(Architecture)))
2686
2687         mapper(Component, self.tbl_component,
2688                properties = dict(component_id = self.tbl_component.c.id,
2689                                  component_name = self.tbl_component.c.name),
2690                extension = validator)
2691
2692         mapper(DBConfig, self.tbl_config,
2693                properties = dict(config_id = self.tbl_config.c.id))
2694
2695         mapper(DSCFile, self.tbl_dsc_files,
2696                properties = dict(dscfile_id = self.tbl_dsc_files.c.id,
2697                                  source_id = self.tbl_dsc_files.c.source,
2698                                  source = relation(DBSource),
2699                                  poolfile_id = self.tbl_dsc_files.c.file,
2700                                  poolfile = relation(PoolFile)))
2701
2702         mapper(ExternalOverride, self.tbl_external_overrides,
2703                 properties = dict(
2704                     suite_id = self.tbl_external_overrides.c.suite,
2705                     suite = relation(Suite),
2706                     component_id = self.tbl_external_overrides.c.component,
2707                     component = relation(Component)))
2708
2709         mapper(PoolFile, self.tbl_files,
2710                properties = dict(file_id = self.tbl_files.c.id,
2711                                  filesize = self.tbl_files.c.size),
2712                 extension = validator)
2713
2714         mapper(Fingerprint, self.tbl_fingerprint,
2715                properties = dict(fingerprint_id = self.tbl_fingerprint.c.id,
2716                                  uid_id = self.tbl_fingerprint.c.uid,
2717                                  uid = relation(Uid),
2718                                  keyring_id = self.tbl_fingerprint.c.keyring,
2719                                  keyring = relation(Keyring),
2720                                  source_acl = relation(SourceACL),
2721                                  binary_acl = relation(BinaryACL)),
2722                extension = validator)
2723
2724         mapper(Keyring, self.tbl_keyrings,
2725                properties = dict(keyring_name = self.tbl_keyrings.c.name,
2726                                  keyring_id = self.tbl_keyrings.c.id))
2727
2728         mapper(DBChange, self.tbl_changes,
2729                properties = dict(change_id = self.tbl_changes.c.id,
2730                                  seen = self.tbl_changes.c.seen,
2731                                  source = self.tbl_changes.c.source,
2732                                  binaries = self.tbl_changes.c.binaries,
2733                                  architecture = self.tbl_changes.c.architecture,
2734                                  distribution = self.tbl_changes.c.distribution,
2735                                  urgency = self.tbl_changes.c.urgency,
2736                                  maintainer = self.tbl_changes.c.maintainer,
2737                                  changedby = self.tbl_changes.c.changedby,
2738                                  date = self.tbl_changes.c.date,
2739                                  version = self.tbl_changes.c.version))
2740
2741         mapper(KeyringACLMap, self.tbl_keyring_acl_map,
2742                properties = dict(keyring_acl_map_id = self.tbl_keyring_acl_map.c.id,
2743                                  keyring = relation(Keyring, backref="keyring_acl_map"),
2744                                  architecture = relation(Architecture)))
2745
2746         mapper(Maintainer, self.tbl_maintainer,
2747                properties = dict(maintainer_id = self.tbl_maintainer.c.id,
2748                    maintains_sources = relation(DBSource, backref='maintainer',
2749                        primaryjoin=(self.tbl_maintainer.c.id==self.tbl_source.c.maintainer)),
2750                    changed_sources = relation(DBSource, backref='changedby',
2751                        primaryjoin=(self.tbl_maintainer.c.id==self.tbl_source.c.changedby))),
2752                 extension = validator)
2753
2754         mapper(NewComment, self.tbl_new_comments,
2755                properties = dict(comment_id = self.tbl_new_comments.c.id))
2756
2757         mapper(Override, self.tbl_override,
2758                properties = dict(suite_id = self.tbl_override.c.suite,
2759                                  suite = relation(Suite, \
2760                                     backref=backref('overrides', lazy='dynamic')),
2761                                  package = self.tbl_override.c.package,
2762                                  component_id = self.tbl_override.c.component,
2763                                  component = relation(Component, \
2764                                     backref=backref('overrides', lazy='dynamic')),
2765                                  priority_id = self.tbl_override.c.priority,
2766                                  priority = relation(Priority, \
2767                                     backref=backref('overrides', lazy='dynamic')),
2768                                  section_id = self.tbl_override.c.section,
2769                                  section = relation(Section, \
2770                                     backref=backref('overrides', lazy='dynamic')),
2771                                  overridetype_id = self.tbl_override.c.type,
2772                                  overridetype = relation(OverrideType, \
2773                                     backref=backref('overrides', lazy='dynamic'))))
2774
2775         mapper(OverrideType, self.tbl_override_type,
2776                properties = dict(overridetype = self.tbl_override_type.c.type,
2777                                  overridetype_id = self.tbl_override_type.c.id))
2778
2779         mapper(PolicyQueue, self.tbl_policy_queue,
2780                properties = dict(policy_queue_id = self.tbl_policy_queue.c.id,
2781                                  suite = relation(Suite, primaryjoin=(self.tbl_policy_queue.c.suite_id == self.tbl_suite.c.id))))
2782
2783         mapper(PolicyQueueUpload, self.tbl_policy_queue_upload,
2784                properties = dict(
2785                    changes = relation(DBChange),
2786                    policy_queue = relation(PolicyQueue, backref='uploads'),
2787                    target_suite = relation(Suite),
2788                    source = relation(DBSource),
2789                    binaries = relation(DBBinary, secondary=self.tbl_policy_queue_upload_binaries_map),
2790                 ))
2791
2792         mapper(PolicyQueueByhandFile, self.tbl_policy_queue_byhand_file,
2793                properties = dict(
2794                    upload = relation(PolicyQueueUpload, backref='byhand'),
2795                    )
2796                )
2797
2798         mapper(Priority, self.tbl_priority,
2799                properties = dict(priority_id = self.tbl_priority.c.id))
2800
2801         mapper(Section, self.tbl_section,
2802                properties = dict(section_id = self.tbl_section.c.id,
2803                                  section=self.tbl_section.c.section))
2804
2805         mapper(DBSource, self.tbl_source,
2806                properties = dict(source_id = self.tbl_source.c.id,
2807                                  version = self.tbl_source.c.version,
2808                                  maintainer_id = self.tbl_source.c.maintainer,
2809                                  poolfile_id = self.tbl_source.c.file,
2810                                  poolfile = relation(PoolFile),
2811                                  fingerprint_id = self.tbl_source.c.sig_fpr,
2812                                  fingerprint = relation(Fingerprint),
2813                                  changedby_id = self.tbl_source.c.changedby,
2814                                  srcfiles = relation(DSCFile,
2815                                                      primaryjoin=(self.tbl_source.c.id==self.tbl_dsc_files.c.source)),
2816                                  suites = relation(Suite, secondary=self.tbl_src_associations,
2817                                      backref=backref('sources', lazy='dynamic')),
2818                                  uploaders = relation(Maintainer,
2819                                      secondary=self.tbl_src_uploaders),
2820                                  key = relation(SourceMetadata, cascade='all',
2821                                      collection_class=attribute_mapped_collection('key'))),
2822                extension = validator)
2823
2824         mapper(SourceACL, self.tbl_source_acl,
2825                properties = dict(source_acl_id = self.tbl_source_acl.c.id))
2826
2827         mapper(SrcFormat, self.tbl_src_format,
2828                properties = dict(src_format_id = self.tbl_src_format.c.id,
2829                                  format_name = self.tbl_src_format.c.format_name))
2830
2831         mapper(Suite, self.tbl_suite,
2832                properties = dict(suite_id = self.tbl_suite.c.id,
2833                                  policy_queue = relation(PolicyQueue, primaryjoin=(self.tbl_suite.c.policy_queue_id == self.tbl_policy_queue.c.id)),
2834                                  copy_queues = relation(BuildQueue,
2835                                      secondary=self.tbl_suite_build_queue_copy),
2836                                  srcformats = relation(SrcFormat, secondary=self.tbl_suite_src_formats,
2837                                      backref=backref('suites', lazy='dynamic')),
2838                                  archive = relation(Archive, backref='suites')),
2839                 extension = validator)
2840
2841         mapper(Uid, self.tbl_uid,
2842                properties = dict(uid_id = self.tbl_uid.c.id,
2843                                  fingerprint = relation(Fingerprint)),
2844                extension = validator)
2845
2846         mapper(UploadBlock, self.tbl_upload_blocks,
2847                properties = dict(upload_block_id = self.tbl_upload_blocks.c.id,
2848                                  fingerprint = relation(Fingerprint, backref="uploadblocks"),
2849                                  uid = relation(Uid, backref="uploadblocks")))
2850
2851         mapper(BinContents, self.tbl_bin_contents,
2852             properties = dict(
2853                 binary = relation(DBBinary,
2854                     backref=backref('contents', lazy='dynamic', cascade='all')),
2855                 file = self.tbl_bin_contents.c.file))
2856
2857         mapper(SrcContents, self.tbl_src_contents,
2858             properties = dict(
2859                 source = relation(DBSource,
2860                     backref=backref('contents', lazy='dynamic', cascade='all')),
2861                 file = self.tbl_src_contents.c.file))
2862
2863         mapper(MetadataKey, self.tbl_metadata_keys,
2864             properties = dict(
2865                 key_id = self.tbl_metadata_keys.c.key_id,
2866                 key = self.tbl_metadata_keys.c.key))
2867
2868         mapper(BinaryMetadata, self.tbl_binaries_metadata,
2869             properties = dict(
2870                 binary_id = self.tbl_binaries_metadata.c.bin_id,
2871                 binary = relation(DBBinary),
2872                 key_id = self.tbl_binaries_metadata.c.key_id,
2873                 key = relation(MetadataKey),
2874                 value = self.tbl_binaries_metadata.c.value))
2875
2876         mapper(SourceMetadata, self.tbl_source_metadata,
2877             properties = dict(
2878                 source_id = self.tbl_source_metadata.c.src_id,
2879                 source = relation(DBSource),
2880                 key_id = self.tbl_source_metadata.c.key_id,
2881                 key = relation(MetadataKey),
2882                 value = self.tbl_source_metadata.c.value))
2883
2884         mapper(VersionCheck, self.tbl_version_check,
2885             properties = dict(
2886                 suite_id = self.tbl_version_check.c.suite,
2887                 suite = relation(Suite, primaryjoin=self.tbl_version_check.c.suite==self.tbl_suite.c.id),
2888                 reference_id = self.tbl_version_check.c.reference,
2889                 reference = relation(Suite, primaryjoin=self.tbl_version_check.c.reference==self.tbl_suite.c.id, lazy='joined')))
2890
2891     ## Connection functions
2892     def __createconn(self):
2893         from config import Config
2894         cnf = Config()
2895         if cnf.has_key("DB::Service"):
2896             connstr = "postgresql://service=%s" % cnf["DB::Service"]
2897         elif cnf.has_key("DB::Host"):
2898             # TCP/IP
2899             connstr = "postgresql://%s" % cnf["DB::Host"]
2900             if cnf.has_key("DB::Port") and cnf["DB::Port"] != "-1":
2901                 connstr += ":%s" % cnf["DB::Port"]
2902             connstr += "/%s" % cnf["DB::Name"]
2903         else:
2904             # Unix Socket
2905             connstr = "postgresql:///%s" % cnf["DB::Name"]
2906             if cnf.has_key("DB::Port") and cnf["DB::Port"] != "-1":
2907                 connstr += "?port=%s" % cnf["DB::Port"]
2908
2909         engine_args = { 'echo': self.debug }
2910         if cnf.has_key('DB::PoolSize'):
2911             engine_args['pool_size'] = int(cnf['DB::PoolSize'])
2912         if cnf.has_key('DB::MaxOverflow'):
2913             engine_args['max_overflow'] = int(cnf['DB::MaxOverflow'])
2914         if sa_major_version == '0.6' and cnf.has_key('DB::Unicode') and \
2915             cnf['DB::Unicode'] == 'false':
2916             engine_args['use_native_unicode'] = False
2917
2918         # Monkey patch a new dialect in in order to support service= syntax
2919         import sqlalchemy.dialects.postgresql
2920         from sqlalchemy.dialects.postgresql.psycopg2 import PGDialect_psycopg2
2921         class PGDialect_psycopg2_dak(PGDialect_psycopg2):
2922             def create_connect_args(self, url):
2923                 if str(url).startswith('postgresql://service='):
2924                     # Eww
2925                     servicename = str(url)[21:]
2926                     return (['service=%s' % servicename], {})
2927                 else:
2928                     return PGDialect_psycopg2.create_connect_args(self, url)
2929
2930         sqlalchemy.dialects.postgresql.base.dialect = PGDialect_psycopg2_dak
2931
2932         try:
2933             self.db_pg   = create_engine(connstr, **engine_args)
2934             self.db_meta = MetaData()
2935             self.db_meta.bind = self.db_pg
2936             self.db_smaker = sessionmaker(bind=self.db_pg,
2937                                           autoflush=True,
2938                                           autocommit=False)
2939
2940             self.__setuptables()
2941             self.__setupmappers()
2942
2943         except OperationalError as e:
2944             import utils
2945             utils.fubar("Cannot connect to database (%s)" % str(e))
2946
2947         self.pid = os.getpid()
2948
2949     def session(self, work_mem = 0):
2950         '''
2951         Returns a new session object. If a work_mem parameter is provided a new
2952         transaction is started and the work_mem parameter is set for this
2953         transaction. The work_mem parameter is measured in MB. A default value
2954         will be used if the parameter is not set.
2955         '''
2956         # reinitialize DBConn in new processes
2957         if self.pid != os.getpid():
2958             clear_mappers()
2959             self.__createconn()
2960         session = self.db_smaker()
2961         if work_mem > 0:
2962             session.execute("SET LOCAL work_mem TO '%d MB'" % work_mem)
2963         return session
2964
2965 __all__.append('DBConn')
2966
2967