]> git.decadent.org.uk Git - dak.git/blob - daklib/dbconn.py
make p-u clear out queue information from the tables
[dak.git] / daklib / dbconn.py
1 #!/usr/bin/python
2
3 """ DB access class
4
5 @contact: Debian FTPMaster <ftpmaster@debian.org>
6 @copyright: 2000, 2001, 2002, 2003, 2004, 2006  James Troup <james@nocrew.org>
7 @copyright: 2008-2009  Mark Hymers <mhy@debian.org>
8 @copyright: 2009  Joerg Jaspert <joerg@debian.org>
9 @copyright: 2009  Mike O'Connor <stew@debian.org>
10 @license: GNU General Public License version 2 or later
11 """
12
13 # This program is free software; you can redistribute it and/or modify
14 # it under the terms of the GNU General Public License as published by
15 # the Free Software Foundation; either version 2 of the License, or
16 # (at your option) any later version.
17
18 # This program is distributed in the hope that it will be useful,
19 # but WITHOUT ANY WARRANTY; without even the implied warranty of
20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 # GNU General Public License for more details.
22
23 # You should have received a copy of the GNU General Public License
24 # along with this program; if not, write to the Free Software
25 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26
27 ################################################################################
28
29 # < mhy> I need a funny comment
30 # < sgran> two peanuts were walking down a dark street
31 # < sgran> one was a-salted
32 #  * mhy looks up the definition of "funny"
33
34 ################################################################################
35
36 import os
37 import re
38 import psycopg2
39 import traceback
40 from datetime import datetime, timedelta
41 from errno import ENOENT
42 from tempfile import mkstemp, mkdtemp
43
44 from inspect import getargspec
45
46 import sqlalchemy
47 from sqlalchemy import create_engine, Table, MetaData
48 from sqlalchemy.orm import sessionmaker, mapper, relation
49 from sqlalchemy import types as sqltypes
50
51 # Don't remove this, we re-export the exceptions to scripts which import us
52 from sqlalchemy.exc import *
53 from sqlalchemy.orm.exc import NoResultFound
54
55 from config import Config
56 from textutils import fix_maintainer
57
58 ################################################################################
59
60 # Patch in support for the debversion field type so that it works during
61 # reflection
62
63 class DebVersion(sqltypes.Text):
64     def get_col_spec(self):
65         return "DEBVERSION"
66
67 sa_major_version = sqlalchemy.__version__[0:3]
68 if sa_major_version == "0.5":
69     from sqlalchemy.databases import postgres
70     postgres.ischema_names['debversion'] = DebVersion
71 else:
72     raise Exception("dak isn't ported to SQLA versions != 0.5 yet.  See daklib/dbconn.py")
73
74 ################################################################################
75
76 __all__ = ['IntegrityError', 'SQLAlchemyError']
77
78 ################################################################################
79
80 def session_wrapper(fn):
81     """
82     Wrapper around common ".., session=None):" handling. If the wrapped
83     function is called without passing 'session', we create a local one
84     and destroy it when the function ends.
85
86     Also attaches a commit_or_flush method to the session; if we created a
87     local session, this is a synonym for session.commit(), otherwise it is a
88     synonym for session.flush().
89     """
90
91     def wrapped(*args, **kwargs):
92         private_transaction = False
93
94         # Find the session object
95         session = kwargs.get('session')
96
97         if session is None:
98             if len(args) <= len(getargspec(fn)[0]) - 1:
99                 # No session specified as last argument or in kwargs
100                 private_transaction = True
101                 session = kwargs['session'] = DBConn().session()
102             else:
103                 # Session is last argument in args
104                 session = args[-1]
105                 if session is None:
106                     args = list(args)
107                     session = args[-1] = DBConn().session()
108                     private_transaction = True
109
110         if private_transaction:
111             session.commit_or_flush = session.commit
112         else:
113             session.commit_or_flush = session.flush
114
115         try:
116             return fn(*args, **kwargs)
117         finally:
118             if private_transaction:
119                 # We created a session; close it.
120                 session.close()
121
122     wrapped.__doc__ = fn.__doc__
123     wrapped.func_name = fn.func_name
124
125     return wrapped
126
127 __all__.append('session_wrapper')
128
129 ################################################################################
130
131 class Architecture(object):
132     def __init__(self, *args, **kwargs):
133         pass
134
135     def __eq__(self, val):
136         if isinstance(val, str):
137             return (self.arch_string== val)
138         # This signals to use the normal comparison operator
139         return NotImplemented
140
141     def __ne__(self, val):
142         if isinstance(val, str):
143             return (self.arch_string != val)
144         # This signals to use the normal comparison operator
145         return NotImplemented
146
147     def __repr__(self):
148         return '<Architecture %s>' % self.arch_string
149
150 __all__.append('Architecture')
151
152 @session_wrapper
153 def get_architecture(architecture, session=None):
154     """
155     Returns database id for given C{architecture}.
156
157     @type architecture: string
158     @param architecture: The name of the architecture
159
160     @type session: Session
161     @param session: Optional SQLA session object (a temporary one will be
162     generated if not supplied)
163
164     @rtype: Architecture
165     @return: Architecture object for the given arch (None if not present)
166     """
167
168     q = session.query(Architecture).filter_by(arch_string=architecture)
169
170     try:
171         return q.one()
172     except NoResultFound:
173         return None
174
175 __all__.append('get_architecture')
176
177 @session_wrapper
178 def get_architecture_suites(architecture, session=None):
179     """
180     Returns list of Suite objects for given C{architecture} name
181
182     @type source: str
183     @param source: Architecture name to search for
184
185     @type session: Session
186     @param session: Optional SQL session object (a temporary one will be
187     generated if not supplied)
188
189     @rtype: list
190     @return: list of Suite objects for the given name (may be empty)
191     """
192
193     q = session.query(Suite)
194     q = q.join(SuiteArchitecture)
195     q = q.join(Architecture).filter_by(arch_string=architecture).order_by('suite_name')
196
197     ret = q.all()
198
199     return ret
200
201 __all__.append('get_architecture_suites')
202
203 ################################################################################
204
205 class Archive(object):
206     def __init__(self, *args, **kwargs):
207         pass
208
209     def __repr__(self):
210         return '<Archive %s>' % self.archive_name
211
212 __all__.append('Archive')
213
214 @session_wrapper
215 def get_archive(archive, session=None):
216     """
217     returns database id for given C{archive}.
218
219     @type archive: string
220     @param archive: the name of the arhive
221
222     @type session: Session
223     @param session: Optional SQLA session object (a temporary one will be
224     generated if not supplied)
225
226     @rtype: Archive
227     @return: Archive object for the given name (None if not present)
228
229     """
230     archive = archive.lower()
231
232     q = session.query(Archive).filter_by(archive_name=archive)
233
234     try:
235         return q.one()
236     except NoResultFound:
237         return None
238
239 __all__.append('get_archive')
240
241 ################################################################################
242
243 class BinAssociation(object):
244     def __init__(self, *args, **kwargs):
245         pass
246
247     def __repr__(self):
248         return '<BinAssociation %s (%s, %s)>' % (self.ba_id, self.binary, self.suite)
249
250 __all__.append('BinAssociation')
251
252 ################################################################################
253
254 class BinContents(object):
255     def __init__(self, *args, **kwargs):
256         pass
257
258     def __repr__(self):
259         return '<BinContents (%s, %s)>' % (self.binary, self.filename)
260
261 __all__.append('BinContents')
262
263 ################################################################################
264
265 class DBBinary(object):
266     def __init__(self, *args, **kwargs):
267         pass
268
269     def __repr__(self):
270         return '<DBBinary %s (%s, %s)>' % (self.package, self.version, self.architecture)
271
272 __all__.append('DBBinary')
273
274 @session_wrapper
275 def get_suites_binary_in(package, session=None):
276     """
277     Returns list of Suite objects which given C{package} name is in
278
279     @type source: str
280     @param source: DBBinary package name to search for
281
282     @rtype: list
283     @return: list of Suite objects for the given package
284     """
285
286     return session.query(Suite).join(BinAssociation).join(DBBinary).filter_by(package=package).all()
287
288 __all__.append('get_suites_binary_in')
289
290 @session_wrapper
291 def get_binary_from_id(binary_id, session=None):
292     """
293     Returns DBBinary object for given C{id}
294
295     @type binary_id: int
296     @param binary_id: Id of the required binary
297
298     @type session: Session
299     @param session: Optional SQLA session object (a temporary one will be
300     generated if not supplied)
301
302     @rtype: DBBinary
303     @return: DBBinary object for the given binary (None if not present)
304     """
305
306     q = session.query(DBBinary).filter_by(binary_id=binary_id)
307
308     try:
309         return q.one()
310     except NoResultFound:
311         return None
312
313 __all__.append('get_binary_from_id')
314
315 @session_wrapper
316 def get_binaries_from_name(package, version=None, architecture=None, session=None):
317     """
318     Returns list of DBBinary objects for given C{package} name
319
320     @type package: str
321     @param package: DBBinary package name to search for
322
323     @type version: str or None
324     @param version: Version to search for (or None)
325
326     @type package: str, list or None
327     @param package: Architectures to limit to (or None if no limit)
328
329     @type session: Session
330     @param session: Optional SQL session object (a temporary one will be
331     generated if not supplied)
332
333     @rtype: list
334     @return: list of DBBinary objects for the given name (may be empty)
335     """
336
337     q = session.query(DBBinary).filter_by(package=package)
338
339     if version is not None:
340         q = q.filter_by(version=version)
341
342     if architecture is not None:
343         if not isinstance(architecture, list):
344             architecture = [architecture]
345         q = q.join(Architecture).filter(Architecture.arch_string.in_(architecture))
346
347     ret = q.all()
348
349     return ret
350
351 __all__.append('get_binaries_from_name')
352
353 @session_wrapper
354 def get_binaries_from_source_id(source_id, session=None):
355     """
356     Returns list of DBBinary objects for given C{source_id}
357
358     @type source_id: int
359     @param source_id: source_id to search for
360
361     @type session: Session
362     @param session: Optional SQL session object (a temporary one will be
363     generated if not supplied)
364
365     @rtype: list
366     @return: list of DBBinary objects for the given name (may be empty)
367     """
368
369     return session.query(DBBinary).filter_by(source_id=source_id).all()
370
371 __all__.append('get_binaries_from_source_id')
372
373 @session_wrapper
374 def get_binary_from_name_suite(package, suitename, session=None):
375     ### For dak examine-package
376     ### XXX: Doesn't use object API yet
377
378     sql = """SELECT DISTINCT(b.package), b.version, c.name, su.suite_name
379              FROM binaries b, files fi, location l, component c, bin_associations ba, suite su
380              WHERE b.package=:package
381                AND b.file = fi.id
382                AND fi.location = l.id
383                AND l.component = c.id
384                AND ba.bin=b.id
385                AND ba.suite = su.id
386                AND su.suite_name=:suitename
387           ORDER BY b.version DESC"""
388
389     return session.execute(sql, {'package': package, 'suitename': suitename})
390
391 __all__.append('get_binary_from_name_suite')
392
393 @session_wrapper
394 def get_binary_components(package, suitename, arch, session=None):
395     # Check for packages that have moved from one component to another
396     query = """SELECT c.name FROM binaries b, bin_associations ba, suite s, location l, component c, architecture a, files f
397     WHERE b.package=:package AND s.suite_name=:suitename
398       AND (a.arch_string = :arch OR a.arch_string = 'all')
399       AND ba.bin = b.id AND ba.suite = s.id AND b.architecture = a.id
400       AND f.location = l.id
401       AND l.component = c.id
402       AND b.file = f.id"""
403
404     vals = {'package': package, 'suitename': suitename, 'arch': arch}
405
406     return session.execute(query, vals)
407
408 __all__.append('get_binary_components')
409
410 ################################################################################
411
412 class BinaryACL(object):
413     def __init__(self, *args, **kwargs):
414         pass
415
416     def __repr__(self):
417         return '<BinaryACL %s>' % self.binary_acl_id
418
419 __all__.append('BinaryACL')
420
421 ################################################################################
422
423 class BinaryACLMap(object):
424     def __init__(self, *args, **kwargs):
425         pass
426
427     def __repr__(self):
428         return '<BinaryACLMap %s>' % self.binary_acl_map_id
429
430 __all__.append('BinaryACLMap')
431
432 ################################################################################
433
434 MINIMAL_APT_CONF="""
435 Dir
436 {
437    ArchiveDir "%(archivepath)s";
438    OverrideDir "/srv/ftp.debian.org/scripts/override/";
439    CacheDir "/srv/ftp.debian.org/database/";
440 };
441
442 Default
443 {
444    Packages::Compress ". bzip2 gzip";
445    Sources::Compress ". bzip2 gzip";
446    DeLinkLimit 0;
447    FileMode 0664;
448 }
449
450 bindirectory "incoming"
451 {
452    Packages "Packages";
453    Contents " ";
454
455    BinOverride "override.sid.all3";
456    BinCacheDB "packages-accepted.db";
457
458    FileList "%(filelist)s";
459
460    PathPrefix "";
461    Packages::Extensions ".deb .udeb";
462 };
463
464 bindirectory "incoming/"
465 {
466    Sources "Sources";
467    BinOverride "override.sid.all3";
468    SrcOverride "override.sid.all3.src";
469    FileList "%(filelist)s";
470 };
471 """
472
473 class BuildQueue(object):
474     def __init__(self, *args, **kwargs):
475         pass
476
477     def __repr__(self):
478         return '<BuildQueue %s>' % self.queue_name
479
480     def write_metadata(self, starttime, force=False):
481         # Do we write out metafiles?
482         if not (force or self.generate_metadata):
483             return
484
485         session = DBConn().session().object_session(self)
486
487         fl_fd = fl_name = ac_fd = ac_name = None
488         tempdir = None
489         arches = " ".join([ a.arch_string for a in session.query(Architecture).all() if a.arch_string != 'source' ])
490         startdir = os.getcwd()
491
492         try:
493             # Grab files we want to include
494             newer = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter(BuildQueueFile.lastused + timedelta(seconds=self.stay_of_execution) > starttime).all()
495             # Write file list with newer files
496             (fl_fd, fl_name) = mkstemp()
497             for n in newer:
498                 os.write(fl_fd, '%s\n' % n.fullpath)
499             os.close(fl_fd)
500
501             # Write minimal apt.conf
502             # TODO: Remove hardcoding from template
503             (ac_fd, ac_name) = mkstemp()
504             os.write(ac_fd, MINIMAL_APT_CONF % {'archivepath': self.path,
505                                                 'filelist': fl_name})
506             os.close(ac_fd)
507
508             # Run apt-ftparchive generate
509             os.chdir(os.path.dirname(ac_name))
510             os.system('apt-ftparchive -qq -o APT::FTPArchive::Contents=off generate %s' % os.path.basename(ac_name))
511
512             # Run apt-ftparchive release
513             # TODO: Eww - fix this
514             bname = os.path.basename(self.path)
515             os.chdir(self.path)
516             os.chdir('..')
517
518             # We have to remove the Release file otherwise it'll be included in the
519             # new one
520             try:
521                 os.unlink(os.path.join(bname, 'Release'))
522             except OSError:
523                 pass
524
525             os.system("""apt-ftparchive -qq -o APT::FTPArchive::Release::Origin="%s" -o APT::FTPArchive::Release::Label="%s" -o APT::FTPArchive::Release::Description="%s" -o APT::FTPArchive::Release::Architectures="%s" release %s > Release""" % (self.origin, self.label, self.releasedescription, arches, bname))
526
527             # Sign if necessary
528             if self.signingkey:
529                 cnf = Config()
530                 keyring = "--secret-keyring \"%s\"" % cnf["Dinstall::SigningKeyring"]
531                 if cnf.has_key("Dinstall::SigningPubKeyring"):
532                     keyring += " --keyring \"%s\"" % cnf["Dinstall::SigningPubKeyring"]
533
534                 os.system("gpg %s --no-options --batch --no-tty --armour --default-key %s --detach-sign -o Release.gpg Release""" % (keyring, self.signingkey))
535
536             # Move the files if we got this far
537             os.rename('Release', os.path.join(bname, 'Release'))
538             if self.signingkey:
539                 os.rename('Release.gpg', os.path.join(bname, 'Release.gpg'))
540
541         # Clean up any left behind files
542         finally:
543             os.chdir(startdir)
544             if fl_fd:
545                 try:
546                     os.close(fl_fd)
547                 except OSError:
548                     pass
549
550             if fl_name:
551                 try:
552                     os.unlink(fl_name)
553                 except OSError:
554                     pass
555
556             if ac_fd:
557                 try:
558                     os.close(ac_fd)
559                 except OSError:
560                     pass
561
562             if ac_name:
563                 try:
564                     os.unlink(ac_name)
565                 except OSError:
566                     pass
567
568     def clean_and_update(self, starttime, Logger, dryrun=False):
569         """WARNING: This routine commits for you"""
570         session = DBConn().session().object_session(self)
571
572         if self.generate_metadata and not dryrun:
573             self.write_metadata(starttime)
574
575         # Grab files older than our execution time
576         older = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter(BuildQueueFile.lastused + timedelta(seconds=self.stay_of_execution) <= starttime).all()
577
578         for o in older:
579             killdb = False
580             try:
581                 if dryrun:
582                     Logger.log(["I: Would have removed %s from the queue" % o.fullpath])
583                 else:
584                     Logger.log(["I: Removing %s from the queue" % o.fullpath])
585                     os.unlink(o.fullpath)
586                     killdb = True
587             except OSError, e:
588                 # If it wasn't there, don't worry
589                 if e.errno == ENOENT:
590                     killdb = True
591                 else:
592                     # TODO: Replace with proper logging call
593                     Logger.log(["E: Could not remove %s" % o.fullpath])
594
595             if killdb:
596                 session.delete(o)
597
598         session.commit()
599
600         for f in os.listdir(self.path):
601             if f.startswith('Packages') or f.startswith('Source') or f.startswith('Release'):
602                 continue
603
604             try:
605                 r = session.query(BuildQueueFile).filter_by(build_queue_id = self.queue_id).filter_by(filename = f).one()
606             except NoResultFound:
607                 fp = os.path.join(self.path, f)
608                 if dryrun:
609                     Logger.log(["I: Would remove unused link %s" % fp])
610                 else:
611                     Logger.log(["I: Removing unused link %s" % fp])
612                     try:
613                         os.unlink(fp)
614                     except OSError:
615                         Logger.log(["E: Failed to unlink unreferenced file %s" % r.fullpath])
616
617     def add_file_from_pool(self, poolfile):
618         """Copies a file into the pool.  Assumes that the PoolFile object is
619         attached to the same SQLAlchemy session as the Queue object is.
620
621         The caller is responsible for committing after calling this function."""
622         poolfile_basename = poolfile.filename[poolfile.filename.rindex(os.sep)+1:]
623
624         # Check if we have a file of this name or this ID already
625         for f in self.queuefiles:
626             if f.fileid is not None and f.fileid == poolfile.file_id or \
627                f.poolfile.filename == poolfile_basename:
628                    # In this case, update the BuildQueueFile entry so we
629                    # don't remove it too early
630                    f.lastused = datetime.now()
631                    DBConn().session().object_session(poolfile).add(f)
632                    return f
633
634         # Prepare BuildQueueFile object
635         qf = BuildQueueFile()
636         qf.build_queue_id = self.queue_id
637         qf.lastused = datetime.now()
638         qf.filename = poolfile_basename
639
640         targetpath = poolfile.fullpath
641         queuepath = os.path.join(self.path, poolfile_basename)
642
643         try:
644             if self.copy_files:
645                 # We need to copy instead of symlink
646                 import utils
647                 utils.copy(targetpath, queuepath)
648                 # NULL in the fileid field implies a copy
649                 qf.fileid = None
650             else:
651                 os.symlink(targetpath, queuepath)
652                 qf.fileid = poolfile.file_id
653         except OSError:
654             return None
655
656         # Get the same session as the PoolFile is using and add the qf to it
657         DBConn().session().object_session(poolfile).add(qf)
658
659         return qf
660
661
662 __all__.append('BuildQueue')
663
664 @session_wrapper
665 def get_build_queue(queuename, session=None):
666     """
667     Returns BuildQueue object for given C{queue name}, creating it if it does not
668     exist.
669
670     @type queuename: string
671     @param queuename: The name of the queue
672
673     @type session: Session
674     @param session: Optional SQLA session object (a temporary one will be
675     generated if not supplied)
676
677     @rtype: BuildQueue
678     @return: BuildQueue object for the given queue
679     """
680
681     q = session.query(BuildQueue).filter_by(queue_name=queuename)
682
683     try:
684         return q.one()
685     except NoResultFound:
686         return None
687
688 __all__.append('get_build_queue')
689
690 ################################################################################
691
692 class BuildQueueFile(object):
693     def __init__(self, *args, **kwargs):
694         pass
695
696     def __repr__(self):
697         return '<BuildQueueFile %s (%s)>' % (self.filename, self.build_queue_id)
698
699     @property
700     def fullpath(self):
701         return os.path.join(self.buildqueue.path, self.filename)
702
703
704 __all__.append('BuildQueueFile')
705
706 ################################################################################
707
708 class ChangePendingBinary(object):
709     def __init__(self, *args, **kwargs):
710         pass
711
712     def __repr__(self):
713         return '<ChangePendingBinary %s>' % self.change_pending_binary_id
714
715 __all__.append('ChangePendingBinary')
716
717 ################################################################################
718
719 class ChangePendingFile(object):
720     def __init__(self, *args, **kwargs):
721         pass
722
723     def __repr__(self):
724         return '<ChangePendingFile %s>' % self.change_pending_file_id
725
726 __all__.append('ChangePendingFile')
727
728 ################################################################################
729
730 class ChangePendingSource(object):
731     def __init__(self, *args, **kwargs):
732         pass
733
734     def __repr__(self):
735         return '<ChangePendingSource %s>' % self.change_pending_source_id
736
737 __all__.append('ChangePendingSource')
738
739 ################################################################################
740
741 class Component(object):
742     def __init__(self, *args, **kwargs):
743         pass
744
745     def __eq__(self, val):
746         if isinstance(val, str):
747             return (self.component_name == val)
748         # This signals to use the normal comparison operator
749         return NotImplemented
750
751     def __ne__(self, val):
752         if isinstance(val, str):
753             return (self.component_name != val)
754         # This signals to use the normal comparison operator
755         return NotImplemented
756
757     def __repr__(self):
758         return '<Component %s>' % self.component_name
759
760
761 __all__.append('Component')
762
763 @session_wrapper
764 def get_component(component, session=None):
765     """
766     Returns database id for given C{component}.
767
768     @type component: string
769     @param component: The name of the override type
770
771     @rtype: int
772     @return: the database id for the given component
773
774     """
775     component = component.lower()
776
777     q = session.query(Component).filter_by(component_name=component)
778
779     try:
780         return q.one()
781     except NoResultFound:
782         return None
783
784 __all__.append('get_component')
785
786 ################################################################################
787
788 class DBConfig(object):
789     def __init__(self, *args, **kwargs):
790         pass
791
792     def __repr__(self):
793         return '<DBConfig %s>' % self.name
794
795 __all__.append('DBConfig')
796
797 ################################################################################
798
799 @session_wrapper
800 def get_or_set_contents_file_id(filename, session=None):
801     """
802     Returns database id for given filename.
803
804     If no matching file is found, a row is inserted.
805
806     @type filename: string
807     @param filename: The filename
808     @type session: SQLAlchemy
809     @param session: Optional SQL session object (a temporary one will be
810     generated if not supplied).  If not passed, a commit will be performed at
811     the end of the function, otherwise the caller is responsible for commiting.
812
813     @rtype: int
814     @return: the database id for the given component
815     """
816
817     q = session.query(ContentFilename).filter_by(filename=filename)
818
819     try:
820         ret = q.one().cafilename_id
821     except NoResultFound:
822         cf = ContentFilename()
823         cf.filename = filename
824         session.add(cf)
825         session.commit_or_flush()
826         ret = cf.cafilename_id
827
828     return ret
829
830 __all__.append('get_or_set_contents_file_id')
831
832 @session_wrapper
833 def get_contents(suite, overridetype, section=None, session=None):
834     """
835     Returns contents for a suite / overridetype combination, limiting
836     to a section if not None.
837
838     @type suite: Suite
839     @param suite: Suite object
840
841     @type overridetype: OverrideType
842     @param overridetype: OverrideType object
843
844     @type section: Section
845     @param section: Optional section object to limit results to
846
847     @type session: SQLAlchemy
848     @param session: Optional SQL session object (a temporary one will be
849     generated if not supplied)
850
851     @rtype: ResultsProxy
852     @return: ResultsProxy object set up to return tuples of (filename, section,
853     package, arch_id)
854     """
855
856     # find me all of the contents for a given suite
857     contents_q = """SELECT (p.path||'/'||n.file) AS fn,
858                             s.section,
859                             b.package,
860                             b.architecture
861                    FROM content_associations c join content_file_paths p ON (c.filepath=p.id)
862                    JOIN content_file_names n ON (c.filename=n.id)
863                    JOIN binaries b ON (b.id=c.binary_pkg)
864                    JOIN override o ON (o.package=b.package)
865                    JOIN section s ON (s.id=o.section)
866                    WHERE o.suite = :suiteid AND o.type = :overridetypeid
867                    AND b.type=:overridetypename"""
868
869     vals = {'suiteid': suite.suite_id,
870             'overridetypeid': overridetype.overridetype_id,
871             'overridetypename': overridetype.overridetype}
872
873     if section is not None:
874         contents_q += " AND s.id = :sectionid"
875         vals['sectionid'] = section.section_id
876
877     contents_q += " ORDER BY fn"
878
879     return session.execute(contents_q, vals)
880
881 __all__.append('get_contents')
882
883 ################################################################################
884
885 class ContentFilepath(object):
886     def __init__(self, *args, **kwargs):
887         pass
888
889     def __repr__(self):
890         return '<ContentFilepath %s>' % self.filepath
891
892 __all__.append('ContentFilepath')
893
894 @session_wrapper
895 def get_or_set_contents_path_id(filepath, session=None):
896     """
897     Returns database id for given path.
898
899     If no matching file is found, a row is inserted.
900
901     @type filename: string
902     @param filename: The filepath
903     @type session: SQLAlchemy
904     @param session: Optional SQL session object (a temporary one will be
905     generated if not supplied).  If not passed, a commit will be performed at
906     the end of the function, otherwise the caller is responsible for commiting.
907
908     @rtype: int
909     @return: the database id for the given path
910     """
911
912     q = session.query(ContentFilepath).filter_by(filepath=filepath)
913
914     try:
915         ret = q.one().cafilepath_id
916     except NoResultFound:
917         cf = ContentFilepath()
918         cf.filepath = filepath
919         session.add(cf)
920         session.commit_or_flush()
921         ret = cf.cafilepath_id
922
923     return ret
924
925 __all__.append('get_or_set_contents_path_id')
926
927 ################################################################################
928
929 class ContentAssociation(object):
930     def __init__(self, *args, **kwargs):
931         pass
932
933     def __repr__(self):
934         return '<ContentAssociation %s>' % self.ca_id
935
936 __all__.append('ContentAssociation')
937
938 def insert_content_paths(binary_id, fullpaths, session=None):
939     """
940     Make sure given path is associated with given binary id
941
942     @type binary_id: int
943     @param binary_id: the id of the binary
944     @type fullpaths: list
945     @param fullpaths: the list of paths of the file being associated with the binary
946     @type session: SQLAlchemy session
947     @param session: Optional SQLAlchemy session.  If this is passed, the caller
948     is responsible for ensuring a transaction has begun and committing the
949     results or rolling back based on the result code.  If not passed, a commit
950     will be performed at the end of the function, otherwise the caller is
951     responsible for commiting.
952
953     @return: True upon success
954     """
955
956     privatetrans = False
957     if session is None:
958         session = DBConn().session()
959         privatetrans = True
960
961     try:
962         # Insert paths
963         pathcache = {}
964         for fullpath in fullpaths:
965             if fullpath.startswith( './' ):
966                 fullpath = fullpath[2:]
967
968             session.execute( "INSERT INTO bin_contents ( file, binary_id ) VALUES ( :filename, :id )", { 'filename': fullpath, 'id': binary_id}  )
969
970         session.commit()
971         if privatetrans:
972             session.close()
973         return True
974
975     except:
976         traceback.print_exc()
977
978         # Only rollback if we set up the session ourself
979         if privatetrans:
980             session.rollback()
981             session.close()
982
983         return False
984
985 __all__.append('insert_content_paths')
986
987 ################################################################################
988
989 class DSCFile(object):
990     def __init__(self, *args, **kwargs):
991         pass
992
993     def __repr__(self):
994         return '<DSCFile %s>' % self.dscfile_id
995
996 __all__.append('DSCFile')
997
998 @session_wrapper
999 def get_dscfiles(dscfile_id=None, source_id=None, poolfile_id=None, session=None):
1000     """
1001     Returns a list of DSCFiles which may be empty
1002
1003     @type dscfile_id: int (optional)
1004     @param dscfile_id: the dscfile_id of the DSCFiles to find
1005
1006     @type source_id: int (optional)
1007     @param source_id: the source id related to the DSCFiles to find
1008
1009     @type poolfile_id: int (optional)
1010     @param poolfile_id: the poolfile id related to the DSCFiles to find
1011
1012     @rtype: list
1013     @return: Possibly empty list of DSCFiles
1014     """
1015
1016     q = session.query(DSCFile)
1017
1018     if dscfile_id is not None:
1019         q = q.filter_by(dscfile_id=dscfile_id)
1020
1021     if source_id is not None:
1022         q = q.filter_by(source_id=source_id)
1023
1024     if poolfile_id is not None:
1025         q = q.filter_by(poolfile_id=poolfile_id)
1026
1027     return q.all()
1028
1029 __all__.append('get_dscfiles')
1030
1031 ################################################################################
1032
1033 class PoolFile(object):
1034     def __init__(self, *args, **kwargs):
1035         pass
1036
1037     def __repr__(self):
1038         return '<PoolFile %s>' % self.filename
1039
1040     @property
1041     def fullpath(self):
1042         return os.path.join(self.location.path, self.filename)
1043
1044 __all__.append('PoolFile')
1045
1046 @session_wrapper
1047 def check_poolfile(filename, filesize, md5sum, location_id, session=None):
1048     """
1049     Returns a tuple:
1050      (ValidFileFound [boolean or None], PoolFile object or None)
1051
1052     @type filename: string
1053     @param filename: the filename of the file to check against the DB
1054
1055     @type filesize: int
1056     @param filesize: the size of the file to check against the DB
1057
1058     @type md5sum: string
1059     @param md5sum: the md5sum of the file to check against the DB
1060
1061     @type location_id: int
1062     @param location_id: the id of the location to look in
1063
1064     @rtype: tuple
1065     @return: Tuple of length 2.
1066              If more than one file found with that name:
1067                     (None,  None)
1068              If valid pool file found: (True, PoolFile object)
1069              If valid pool file not found:
1070                     (False, None) if no file found
1071                     (False, PoolFile object) if file found with size/md5sum mismatch
1072     """
1073
1074     q = session.query(PoolFile).filter_by(filename=filename)
1075     q = q.join(Location).filter_by(location_id=location_id)
1076
1077     ret = None
1078
1079     if q.count() > 1:
1080         ret = (None, None)
1081     elif q.count() < 1:
1082         ret = (False, None)
1083     else:
1084         obj = q.one()
1085         if obj.md5sum != md5sum or obj.filesize != int(filesize):
1086             ret = (False, obj)
1087
1088     if ret is None:
1089         ret = (True, obj)
1090
1091     return ret
1092
1093 __all__.append('check_poolfile')
1094
1095 @session_wrapper
1096 def get_poolfile_by_id(file_id, session=None):
1097     """
1098     Returns a PoolFile objects or None for the given id
1099
1100     @type file_id: int
1101     @param file_id: the id of the file to look for
1102
1103     @rtype: PoolFile or None
1104     @return: either the PoolFile object or None
1105     """
1106
1107     q = session.query(PoolFile).filter_by(file_id=file_id)
1108
1109     try:
1110         return q.one()
1111     except NoResultFound:
1112         return None
1113
1114 __all__.append('get_poolfile_by_id')
1115
1116
1117 @session_wrapper
1118 def get_poolfile_by_name(filename, location_id=None, session=None):
1119     """
1120     Returns an array of PoolFile objects for the given filename and
1121     (optionally) location_id
1122
1123     @type filename: string
1124     @param filename: the filename of the file to check against the DB
1125
1126     @type location_id: int
1127     @param location_id: the id of the location to look in (optional)
1128
1129     @rtype: array
1130     @return: array of PoolFile objects
1131     """
1132
1133     q = session.query(PoolFile).filter_by(filename=filename)
1134
1135     if location_id is not None:
1136         q = q.join(Location).filter_by(location_id=location_id)
1137
1138     return q.all()
1139
1140 __all__.append('get_poolfile_by_name')
1141
1142 @session_wrapper
1143 def get_poolfile_like_name(filename, session=None):
1144     """
1145     Returns an array of PoolFile objects which are like the given name
1146
1147     @type filename: string
1148     @param filename: the filename of the file to check against the DB
1149
1150     @rtype: array
1151     @return: array of PoolFile objects
1152     """
1153
1154     # TODO: There must be a way of properly using bind parameters with %FOO%
1155     q = session.query(PoolFile).filter(PoolFile.filename.like('%%/%s' % filename))
1156
1157     return q.all()
1158
1159 __all__.append('get_poolfile_like_name')
1160
1161 @session_wrapper
1162 def add_poolfile(filename, datadict, location_id, session=None):
1163     """
1164     Add a new file to the pool
1165
1166     @type filename: string
1167     @param filename: filename
1168
1169     @type datadict: dict
1170     @param datadict: dict with needed data
1171
1172     @type location_id: int
1173     @param location_id: database id of the location
1174
1175     @rtype: PoolFile
1176     @return: the PoolFile object created
1177     """
1178     poolfile = PoolFile()
1179     poolfile.filename = filename
1180     poolfile.filesize = datadict["size"]
1181     poolfile.md5sum = datadict["md5sum"]
1182     poolfile.sha1sum = datadict["sha1sum"]
1183     poolfile.sha256sum = datadict["sha256sum"]
1184     poolfile.location_id = location_id
1185
1186     session.add(poolfile)
1187     # Flush to get a file id (NB: This is not a commit)
1188     session.flush()
1189
1190     return poolfile
1191
1192 __all__.append('add_poolfile')
1193
1194 ################################################################################
1195
1196 class Fingerprint(object):
1197     def __init__(self, *args, **kwargs):
1198         pass
1199
1200     def __repr__(self):
1201         return '<Fingerprint %s>' % self.fingerprint
1202
1203 __all__.append('Fingerprint')
1204
1205 @session_wrapper
1206 def get_fingerprint(fpr, session=None):
1207     """
1208     Returns Fingerprint object for given fpr.
1209
1210     @type fpr: string
1211     @param fpr: The fpr to find / add
1212
1213     @type session: SQLAlchemy
1214     @param session: Optional SQL session object (a temporary one will be
1215     generated if not supplied).
1216
1217     @rtype: Fingerprint
1218     @return: the Fingerprint object for the given fpr or None
1219     """
1220
1221     q = session.query(Fingerprint).filter_by(fingerprint=fpr)
1222
1223     try:
1224         ret = q.one()
1225     except NoResultFound:
1226         ret = None
1227
1228     return ret
1229
1230 __all__.append('get_fingerprint')
1231
1232 @session_wrapper
1233 def get_or_set_fingerprint(fpr, session=None):
1234     """
1235     Returns Fingerprint object for given fpr.
1236
1237     If no matching fpr is found, a row is inserted.
1238
1239     @type fpr: string
1240     @param fpr: The fpr to find / add
1241
1242     @type session: SQLAlchemy
1243     @param session: Optional SQL session object (a temporary one will be
1244     generated if not supplied).  If not passed, a commit will be performed at
1245     the end of the function, otherwise the caller is responsible for commiting.
1246     A flush will be performed either way.
1247
1248     @rtype: Fingerprint
1249     @return: the Fingerprint object for the given fpr
1250     """
1251
1252     q = session.query(Fingerprint).filter_by(fingerprint=fpr)
1253
1254     try:
1255         ret = q.one()
1256     except NoResultFound:
1257         fingerprint = Fingerprint()
1258         fingerprint.fingerprint = fpr
1259         session.add(fingerprint)
1260         session.commit_or_flush()
1261         ret = fingerprint
1262
1263     return ret
1264
1265 __all__.append('get_or_set_fingerprint')
1266
1267 ################################################################################
1268
1269 # Helper routine for Keyring class
1270 def get_ldap_name(entry):
1271     name = []
1272     for k in ["cn", "mn", "sn"]:
1273         ret = entry.get(k)
1274         if ret and ret[0] != "" and ret[0] != "-":
1275             name.append(ret[0])
1276     return " ".join(name)
1277
1278 ################################################################################
1279
1280 class Keyring(object):
1281     gpg_invocation = "gpg --no-default-keyring --keyring %s" +\
1282                      " --with-colons --fingerprint --fingerprint"
1283
1284     keys = {}
1285     fpr_lookup = {}
1286
1287     def __init__(self, *args, **kwargs):
1288         pass
1289
1290     def __repr__(self):
1291         return '<Keyring %s>' % self.keyring_name
1292
1293     def de_escape_gpg_str(self, txt):
1294         esclist = re.split(r'(\\x..)', txt)
1295         for x in range(1,len(esclist),2):
1296             esclist[x] = "%c" % (int(esclist[x][2:],16))
1297         return "".join(esclist)
1298
1299     def load_keys(self, keyring):
1300         import email.Utils
1301
1302         if not self.keyring_id:
1303             raise Exception('Must be initialized with database information')
1304
1305         k = os.popen(self.gpg_invocation % keyring, "r")
1306         key = None
1307         signingkey = False
1308
1309         for line in k.xreadlines():
1310             field = line.split(":")
1311             if field[0] == "pub":
1312                 key = field[4]
1313                 (name, addr) = email.Utils.parseaddr(field[9])
1314                 name = re.sub(r"\s*[(].*[)]", "", name)
1315                 if name == "" or addr == "" or "@" not in addr:
1316                     name = field[9]
1317                     addr = "invalid-uid"
1318                 name = self.de_escape_gpg_str(name)
1319                 self.keys[key] = {"email": addr}
1320                 if name != "":
1321                     self.keys[key]["name"] = name
1322                 self.keys[key]["aliases"] = [name]
1323                 self.keys[key]["fingerprints"] = []
1324                 signingkey = True
1325             elif key and field[0] == "sub" and len(field) >= 12:
1326                 signingkey = ("s" in field[11])
1327             elif key and field[0] == "uid":
1328                 (name, addr) = email.Utils.parseaddr(field[9])
1329                 if name and name not in self.keys[key]["aliases"]:
1330                     self.keys[key]["aliases"].append(name)
1331             elif signingkey and field[0] == "fpr":
1332                 self.keys[key]["fingerprints"].append(field[9])
1333                 self.fpr_lookup[field[9]] = key
1334
1335     def import_users_from_ldap(self, session):
1336         import ldap
1337         cnf = Config()
1338
1339         LDAPDn = cnf["Import-LDAP-Fingerprints::LDAPDn"]
1340         LDAPServer = cnf["Import-LDAP-Fingerprints::LDAPServer"]
1341
1342         l = ldap.open(LDAPServer)
1343         l.simple_bind_s("","")
1344         Attrs = l.search_s(LDAPDn, ldap.SCOPE_ONELEVEL,
1345                "(&(keyfingerprint=*)(gidnumber=%s))" % (cnf["Import-Users-From-Passwd::ValidGID"]),
1346                ["uid", "keyfingerprint", "cn", "mn", "sn"])
1347
1348         ldap_fin_uid_id = {}
1349
1350         byuid = {}
1351         byname = {}
1352
1353         for i in Attrs:
1354             entry = i[1]
1355             uid = entry["uid"][0]
1356             name = get_ldap_name(entry)
1357             fingerprints = entry["keyFingerPrint"]
1358             keyid = None
1359             for f in fingerprints:
1360                 key = self.fpr_lookup.get(f, None)
1361                 if key not in self.keys:
1362                     continue
1363                 self.keys[key]["uid"] = uid
1364
1365                 if keyid != None:
1366                     continue
1367                 keyid = get_or_set_uid(uid, session).uid_id
1368                 byuid[keyid] = (uid, name)
1369                 byname[uid] = (keyid, name)
1370
1371         return (byname, byuid)
1372
1373     def generate_users_from_keyring(self, format, session):
1374         byuid = {}
1375         byname = {}
1376         any_invalid = False
1377         for x in self.keys.keys():
1378             if self.keys[x]["email"] == "invalid-uid":
1379                 any_invalid = True
1380                 self.keys[x]["uid"] = format % "invalid-uid"
1381             else:
1382                 uid = format % self.keys[x]["email"]
1383                 keyid = get_or_set_uid(uid, session).uid_id
1384                 byuid[keyid] = (uid, self.keys[x]["name"])
1385                 byname[uid] = (keyid, self.keys[x]["name"])
1386                 self.keys[x]["uid"] = uid
1387
1388         if any_invalid:
1389             uid = format % "invalid-uid"
1390             keyid = get_or_set_uid(uid, session).uid_id
1391             byuid[keyid] = (uid, "ungeneratable user id")
1392             byname[uid] = (keyid, "ungeneratable user id")
1393
1394         return (byname, byuid)
1395
1396 __all__.append('Keyring')
1397
1398 @session_wrapper
1399 def get_keyring(keyring, session=None):
1400     """
1401     If C{keyring} does not have an entry in the C{keyrings} table yet, return None
1402     If C{keyring} already has an entry, simply return the existing Keyring
1403
1404     @type keyring: string
1405     @param keyring: the keyring name
1406
1407     @rtype: Keyring
1408     @return: the Keyring object for this keyring
1409     """
1410
1411     q = session.query(Keyring).filter_by(keyring_name=keyring)
1412
1413     try:
1414         return q.one()
1415     except NoResultFound:
1416         return None
1417
1418 __all__.append('get_keyring')
1419
1420 ################################################################################
1421
1422 class KeyringACLMap(object):
1423     def __init__(self, *args, **kwargs):
1424         pass
1425
1426     def __repr__(self):
1427         return '<KeyringACLMap %s>' % self.keyring_acl_map_id
1428
1429 __all__.append('KeyringACLMap')
1430
1431 ################################################################################
1432
1433 class DBChange(object):
1434     def __init__(self, *args, **kwargs):
1435         pass
1436
1437     def __repr__(self):
1438         return '<DBChange %s>' % self.changesname
1439
1440     def clean_from_queue(self):
1441         session = DBConn().session().object_session(self)
1442
1443         # Remove changes_pool_files entries
1444         for pf in self.poolfiles:
1445             self.poolfiles.remove(pf)
1446
1447         # Remove change
1448         for cf in self.files:
1449             self.files.remove(cf)
1450
1451         # Clear out of queue
1452         self.in_queue = None
1453         self.approved_for_id = None
1454
1455 __all__.append('DBChange')
1456
1457 @session_wrapper
1458 def get_dbchange(filename, session=None):
1459     """
1460     returns DBChange object for given C{filename}.
1461
1462     @type archive: string
1463     @param archive: the name of the arhive
1464
1465     @type session: Session
1466     @param session: Optional SQLA session object (a temporary one will be
1467     generated if not supplied)
1468
1469     @rtype: Archive
1470     @return: Archive object for the given name (None if not present)
1471
1472     """
1473     q = session.query(DBChange).filter_by(changesname=filename)
1474
1475     try:
1476         return q.one()
1477     except NoResultFound:
1478         return None
1479
1480 __all__.append('get_dbchange')
1481
1482 ################################################################################
1483
1484 class Location(object):
1485     def __init__(self, *args, **kwargs):
1486         pass
1487
1488     def __repr__(self):
1489         return '<Location %s (%s)>' % (self.path, self.location_id)
1490
1491 __all__.append('Location')
1492
1493 @session_wrapper
1494 def get_location(location, component=None, archive=None, session=None):
1495     """
1496     Returns Location object for the given combination of location, component
1497     and archive
1498
1499     @type location: string
1500     @param location: the path of the location, e.g. I{/srv/ftp.debian.org/ftp/pool/}
1501
1502     @type component: string
1503     @param component: the component name (if None, no restriction applied)
1504
1505     @type archive: string
1506     @param archive_id: the archive name (if None, no restriction applied)
1507
1508     @rtype: Location / None
1509     @return: Either a Location object or None if one can't be found
1510     """
1511
1512     q = session.query(Location).filter_by(path=location)
1513
1514     if archive is not None:
1515         q = q.join(Archive).filter_by(archive_name=archive)
1516
1517     if component is not None:
1518         q = q.join(Component).filter_by(component_name=component)
1519
1520     try:
1521         return q.one()
1522     except NoResultFound:
1523         return None
1524
1525 __all__.append('get_location')
1526
1527 ################################################################################
1528
1529 class Maintainer(object):
1530     def __init__(self, *args, **kwargs):
1531         pass
1532
1533     def __repr__(self):
1534         return '''<Maintainer '%s' (%s)>''' % (self.name, self.maintainer_id)
1535
1536     def get_split_maintainer(self):
1537         if not hasattr(self, 'name') or self.name is None:
1538             return ('', '', '', '')
1539
1540         return fix_maintainer(self.name.strip())
1541
1542 __all__.append('Maintainer')
1543
1544 @session_wrapper
1545 def get_or_set_maintainer(name, session=None):
1546     """
1547     Returns Maintainer object for given maintainer name.
1548
1549     If no matching maintainer name is found, a row is inserted.
1550
1551     @type name: string
1552     @param name: The maintainer name to add
1553
1554     @type session: SQLAlchemy
1555     @param session: Optional SQL session object (a temporary one will be
1556     generated if not supplied).  If not passed, a commit will be performed at
1557     the end of the function, otherwise the caller is responsible for commiting.
1558     A flush will be performed either way.
1559
1560     @rtype: Maintainer
1561     @return: the Maintainer object for the given maintainer
1562     """
1563
1564     q = session.query(Maintainer).filter_by(name=name)
1565     try:
1566         ret = q.one()
1567     except NoResultFound:
1568         maintainer = Maintainer()
1569         maintainer.name = name
1570         session.add(maintainer)
1571         session.commit_or_flush()
1572         ret = maintainer
1573
1574     return ret
1575
1576 __all__.append('get_or_set_maintainer')
1577
1578 @session_wrapper
1579 def get_maintainer(maintainer_id, session=None):
1580     """
1581     Return the name of the maintainer behind C{maintainer_id} or None if that
1582     maintainer_id is invalid.
1583
1584     @type maintainer_id: int
1585     @param maintainer_id: the id of the maintainer
1586
1587     @rtype: Maintainer
1588     @return: the Maintainer with this C{maintainer_id}
1589     """
1590
1591     return session.query(Maintainer).get(maintainer_id)
1592
1593 __all__.append('get_maintainer')
1594
1595 ################################################################################
1596
1597 class NewComment(object):
1598     def __init__(self, *args, **kwargs):
1599         pass
1600
1601     def __repr__(self):
1602         return '''<NewComment for '%s %s' (%s)>''' % (self.package, self.version, self.comment_id)
1603
1604 __all__.append('NewComment')
1605
1606 @session_wrapper
1607 def has_new_comment(package, version, session=None):
1608     """
1609     Returns true if the given combination of C{package}, C{version} has a comment.
1610
1611     @type package: string
1612     @param package: name of the package
1613
1614     @type version: string
1615     @param version: package version
1616
1617     @type session: Session
1618     @param session: Optional SQLA session object (a temporary one will be
1619     generated if not supplied)
1620
1621     @rtype: boolean
1622     @return: true/false
1623     """
1624
1625     q = session.query(NewComment)
1626     q = q.filter_by(package=package)
1627     q = q.filter_by(version=version)
1628
1629     return bool(q.count() > 0)
1630
1631 __all__.append('has_new_comment')
1632
1633 @session_wrapper
1634 def get_new_comments(package=None, version=None, comment_id=None, session=None):
1635     """
1636     Returns (possibly empty) list of NewComment objects for the given
1637     parameters
1638
1639     @type package: string (optional)
1640     @param package: name of the package
1641
1642     @type version: string (optional)
1643     @param version: package version
1644
1645     @type comment_id: int (optional)
1646     @param comment_id: An id of a comment
1647
1648     @type session: Session
1649     @param session: Optional SQLA session object (a temporary one will be
1650     generated if not supplied)
1651
1652     @rtype: list
1653     @return: A (possibly empty) list of NewComment objects will be returned
1654     """
1655
1656     q = session.query(NewComment)
1657     if package is not None: q = q.filter_by(package=package)
1658     if version is not None: q = q.filter_by(version=version)
1659     if comment_id is not None: q = q.filter_by(comment_id=comment_id)
1660
1661     return q.all()
1662
1663 __all__.append('get_new_comments')
1664
1665 ################################################################################
1666
1667 class Override(object):
1668     def __init__(self, *args, **kwargs):
1669         pass
1670
1671     def __repr__(self):
1672         return '<Override %s (%s)>' % (self.package, self.suite_id)
1673
1674 __all__.append('Override')
1675
1676 @session_wrapper
1677 def get_override(package, suite=None, component=None, overridetype=None, session=None):
1678     """
1679     Returns Override object for the given parameters
1680
1681     @type package: string
1682     @param package: The name of the package
1683
1684     @type suite: string, list or None
1685     @param suite: The name of the suite (or suites if a list) to limit to.  If
1686                   None, don't limit.  Defaults to None.
1687
1688     @type component: string, list or None
1689     @param component: The name of the component (or components if a list) to
1690                       limit to.  If None, don't limit.  Defaults to None.
1691
1692     @type overridetype: string, list or None
1693     @param overridetype: The name of the overridetype (or overridetypes if a list) to
1694                          limit to.  If None, don't limit.  Defaults to None.
1695
1696     @type session: Session
1697     @param session: Optional SQLA session object (a temporary one will be
1698     generated if not supplied)
1699
1700     @rtype: list
1701     @return: A (possibly empty) list of Override objects will be returned
1702     """
1703
1704     q = session.query(Override)
1705     q = q.filter_by(package=package)
1706
1707     if suite is not None:
1708         if not isinstance(suite, list): suite = [suite]
1709         q = q.join(Suite).filter(Suite.suite_name.in_(suite))
1710
1711     if component is not None:
1712         if not isinstance(component, list): component = [component]
1713         q = q.join(Component).filter(Component.component_name.in_(component))
1714
1715     if overridetype is not None:
1716         if not isinstance(overridetype, list): overridetype = [overridetype]
1717         q = q.join(OverrideType).filter(OverrideType.overridetype.in_(overridetype))
1718
1719     return q.all()
1720
1721 __all__.append('get_override')
1722
1723
1724 ################################################################################
1725
1726 class OverrideType(object):
1727     def __init__(self, *args, **kwargs):
1728         pass
1729
1730     def __repr__(self):
1731         return '<OverrideType %s>' % self.overridetype
1732
1733 __all__.append('OverrideType')
1734
1735 @session_wrapper
1736 def get_override_type(override_type, session=None):
1737     """
1738     Returns OverrideType object for given C{override type}.
1739
1740     @type override_type: string
1741     @param override_type: The name of the override type
1742
1743     @type session: Session
1744     @param session: Optional SQLA session object (a temporary one will be
1745     generated if not supplied)
1746
1747     @rtype: int
1748     @return: the database id for the given override type
1749     """
1750
1751     q = session.query(OverrideType).filter_by(overridetype=override_type)
1752
1753     try:
1754         return q.one()
1755     except NoResultFound:
1756         return None
1757
1758 __all__.append('get_override_type')
1759
1760 ################################################################################
1761
1762 class PendingContentAssociation(object):
1763     def __init__(self, *args, **kwargs):
1764         pass
1765
1766     def __repr__(self):
1767         return '<PendingContentAssociation %s>' % self.pca_id
1768
1769 __all__.append('PendingContentAssociation')
1770
1771 def insert_pending_content_paths(package, fullpaths, session=None):
1772     """
1773     Make sure given paths are temporarily associated with given
1774     package
1775
1776     @type package: dict
1777     @param package: the package to associate with should have been read in from the binary control file
1778     @type fullpaths: list
1779     @param fullpaths: the list of paths of the file being associated with the binary
1780     @type session: SQLAlchemy session
1781     @param session: Optional SQLAlchemy session.  If this is passed, the caller
1782     is responsible for ensuring a transaction has begun and committing the
1783     results or rolling back based on the result code.  If not passed, a commit
1784     will be performed at the end of the function
1785
1786     @return: True upon success, False if there is a problem
1787     """
1788
1789     privatetrans = False
1790
1791     if session is None:
1792         session = DBConn().session()
1793         privatetrans = True
1794
1795     try:
1796         arch = get_architecture(package['Architecture'], session)
1797         arch_id = arch.arch_id
1798
1799         # Remove any already existing recorded files for this package
1800         q = session.query(PendingContentAssociation)
1801         q = q.filter_by(package=package['Package'])
1802         q = q.filter_by(version=package['Version'])
1803         q = q.filter_by(architecture=arch_id)
1804         q.delete()
1805
1806         # Insert paths
1807         pathcache = {}
1808         for fullpath in fullpaths:
1809             (path, filename) = os.path.split(fullpath)
1810
1811             if path.startswith( "./" ):
1812                 path = path[2:]
1813
1814             filepath_id = get_or_set_contents_path_id(path, session)
1815             filename_id = get_or_set_contents_file_id(filename, session)
1816
1817             pathcache[fullpath] = (filepath_id, filename_id)
1818
1819         for fullpath, dat in pathcache.items():
1820             pca = PendingContentAssociation()
1821             pca.package = package['Package']
1822             pca.version = package['Version']
1823             pca.filepath_id = dat[0]
1824             pca.filename_id = dat[1]
1825             pca.architecture = arch_id
1826             session.add(pca)
1827
1828         # Only commit if we set up the session ourself
1829         if privatetrans:
1830             session.commit()
1831             session.close()
1832         else:
1833             session.flush()
1834
1835         return True
1836     except Exception, e:
1837         traceback.print_exc()
1838
1839         # Only rollback if we set up the session ourself
1840         if privatetrans:
1841             session.rollback()
1842             session.close()
1843
1844         return False
1845
1846 __all__.append('insert_pending_content_paths')
1847
1848 ################################################################################
1849
1850 class PolicyQueue(object):
1851     def __init__(self, *args, **kwargs):
1852         pass
1853
1854     def __repr__(self):
1855         return '<PolicyQueue %s>' % self.queue_name
1856
1857 __all__.append('PolicyQueue')
1858
1859 @session_wrapper
1860 def get_policy_queue(queuename, session=None):
1861     """
1862     Returns PolicyQueue object for given C{queue name}
1863
1864     @type queuename: string
1865     @param queuename: The name of the queue
1866
1867     @type session: Session
1868     @param session: Optional SQLA session object (a temporary one will be
1869     generated if not supplied)
1870
1871     @rtype: PolicyQueue
1872     @return: PolicyQueue object for the given queue
1873     """
1874
1875     q = session.query(PolicyQueue).filter_by(queue_name=queuename)
1876
1877     try:
1878         return q.one()
1879     except NoResultFound:
1880         return None
1881
1882 __all__.append('get_policy_queue')
1883
1884 ################################################################################
1885
1886 class Priority(object):
1887     def __init__(self, *args, **kwargs):
1888         pass
1889
1890     def __eq__(self, val):
1891         if isinstance(val, str):
1892             return (self.priority == val)
1893         # This signals to use the normal comparison operator
1894         return NotImplemented
1895
1896     def __ne__(self, val):
1897         if isinstance(val, str):
1898             return (self.priority != val)
1899         # This signals to use the normal comparison operator
1900         return NotImplemented
1901
1902     def __repr__(self):
1903         return '<Priority %s (%s)>' % (self.priority, self.priority_id)
1904
1905 __all__.append('Priority')
1906
1907 @session_wrapper
1908 def get_priority(priority, session=None):
1909     """
1910     Returns Priority object for given C{priority name}.
1911
1912     @type priority: string
1913     @param priority: The name of the priority
1914
1915     @type session: Session
1916     @param session: Optional SQLA session object (a temporary one will be
1917     generated if not supplied)
1918
1919     @rtype: Priority
1920     @return: Priority object for the given priority
1921     """
1922
1923     q = session.query(Priority).filter_by(priority=priority)
1924
1925     try:
1926         return q.one()
1927     except NoResultFound:
1928         return None
1929
1930 __all__.append('get_priority')
1931
1932 @session_wrapper
1933 def get_priorities(session=None):
1934     """
1935     Returns dictionary of priority names -> id mappings
1936
1937     @type session: Session
1938     @param session: Optional SQL session object (a temporary one will be
1939     generated if not supplied)
1940
1941     @rtype: dictionary
1942     @return: dictionary of priority names -> id mappings
1943     """
1944
1945     ret = {}
1946     q = session.query(Priority)
1947     for x in q.all():
1948         ret[x.priority] = x.priority_id
1949
1950     return ret
1951
1952 __all__.append('get_priorities')
1953
1954 ################################################################################
1955
1956 class Section(object):
1957     def __init__(self, *args, **kwargs):
1958         pass
1959
1960     def __eq__(self, val):
1961         if isinstance(val, str):
1962             return (self.section == val)
1963         # This signals to use the normal comparison operator
1964         return NotImplemented
1965
1966     def __ne__(self, val):
1967         if isinstance(val, str):
1968             return (self.section != val)
1969         # This signals to use the normal comparison operator
1970         return NotImplemented
1971
1972     def __repr__(self):
1973         return '<Section %s>' % self.section
1974
1975 __all__.append('Section')
1976
1977 @session_wrapper
1978 def get_section(section, session=None):
1979     """
1980     Returns Section object for given C{section name}.
1981
1982     @type section: string
1983     @param section: The name of the section
1984
1985     @type session: Session
1986     @param session: Optional SQLA session object (a temporary one will be
1987     generated if not supplied)
1988
1989     @rtype: Section
1990     @return: Section object for the given section name
1991     """
1992
1993     q = session.query(Section).filter_by(section=section)
1994
1995     try:
1996         return q.one()
1997     except NoResultFound:
1998         return None
1999
2000 __all__.append('get_section')
2001
2002 @session_wrapper
2003 def get_sections(session=None):
2004     """
2005     Returns dictionary of section names -> id mappings
2006
2007     @type session: Session
2008     @param session: Optional SQL session object (a temporary one will be
2009     generated if not supplied)
2010
2011     @rtype: dictionary
2012     @return: dictionary of section names -> id mappings
2013     """
2014
2015     ret = {}
2016     q = session.query(Section)
2017     for x in q.all():
2018         ret[x.section] = x.section_id
2019
2020     return ret
2021
2022 __all__.append('get_sections')
2023
2024 ################################################################################
2025
2026 class DBSource(object):
2027     def __init__(self, *args, **kwargs):
2028         pass
2029
2030     def __repr__(self):
2031         return '<DBSource %s (%s)>' % (self.source, self.version)
2032
2033 __all__.append('DBSource')
2034
2035 @session_wrapper
2036 def source_exists(source, source_version, suites = ["any"], session=None):
2037     """
2038     Ensure that source exists somewhere in the archive for the binary
2039     upload being processed.
2040       1. exact match     => 1.0-3
2041       2. bin-only NMU    => 1.0-3+b1 , 1.0-3.1+b1
2042
2043     @type package: string
2044     @param package: package source name
2045
2046     @type source_version: string
2047     @param source_version: expected source version
2048
2049     @type suites: list
2050     @param suites: list of suites to check in, default I{any}
2051
2052     @type session: Session
2053     @param session: Optional SQLA session object (a temporary one will be
2054     generated if not supplied)
2055
2056     @rtype: int
2057     @return: returns 1 if a source with expected version is found, otherwise 0
2058
2059     """
2060
2061     cnf = Config()
2062     ret = 1
2063
2064     for suite in suites:
2065         q = session.query(DBSource).filter_by(source=source)
2066         if suite != "any":
2067             # source must exist in suite X, or in some other suite that's
2068             # mapped to X, recursively... silent-maps are counted too,
2069             # unreleased-maps aren't.
2070             maps = cnf.ValueList("SuiteMappings")[:]
2071             maps.reverse()
2072             maps = [ m.split() for m in maps ]
2073             maps = [ (x[1], x[2]) for x in maps
2074                             if x[0] == "map" or x[0] == "silent-map" ]
2075             s = [suite]
2076             for x in maps:
2077                 if x[1] in s and x[0] not in s:
2078                     s.append(x[0])
2079
2080             q = q.join(SrcAssociation).join(Suite)
2081             q = q.filter(Suite.suite_name.in_(s))
2082
2083         # Reduce the query results to a list of version numbers
2084         ql = [ j.version for j in q.all() ]
2085
2086         # Try (1)
2087         if source_version in ql:
2088             continue
2089
2090         # Try (2)
2091         from daklib.regexes import re_bin_only_nmu
2092         orig_source_version = re_bin_only_nmu.sub('', source_version)
2093         if orig_source_version in ql:
2094             continue
2095
2096         # No source found so return not ok
2097         ret = 0
2098
2099     return ret
2100
2101 __all__.append('source_exists')
2102
2103 @session_wrapper
2104 def get_suites_source_in(source, session=None):
2105     """
2106     Returns list of Suite objects which given C{source} name is in
2107
2108     @type source: str
2109     @param source: DBSource package name to search for
2110
2111     @rtype: list
2112     @return: list of Suite objects for the given source
2113     """
2114
2115     return session.query(Suite).join(SrcAssociation).join(DBSource).filter_by(source=source).all()
2116
2117 __all__.append('get_suites_source_in')
2118
2119 @session_wrapper
2120 def get_sources_from_name(source, version=None, dm_upload_allowed=None, session=None):
2121     """
2122     Returns list of DBSource objects for given C{source} name and other parameters
2123
2124     @type source: str
2125     @param source: DBSource package name to search for
2126
2127     @type source: str or None
2128     @param source: DBSource version name to search for or None if not applicable
2129
2130     @type dm_upload_allowed: bool
2131     @param dm_upload_allowed: If None, no effect.  If True or False, only
2132     return packages with that dm_upload_allowed setting
2133
2134     @type session: Session
2135     @param session: Optional SQL session object (a temporary one will be
2136     generated if not supplied)
2137
2138     @rtype: list
2139     @return: list of DBSource objects for the given name (may be empty)
2140     """
2141
2142     q = session.query(DBSource).filter_by(source=source)
2143
2144     if version is not None:
2145         q = q.filter_by(version=version)
2146
2147     if dm_upload_allowed is not None:
2148         q = q.filter_by(dm_upload_allowed=dm_upload_allowed)
2149
2150     return q.all()
2151
2152 __all__.append('get_sources_from_name')
2153
2154 @session_wrapper
2155 def get_source_in_suite(source, suite, session=None):
2156     """
2157     Returns list of DBSource objects for a combination of C{source} and C{suite}.
2158
2159       - B{source} - source package name, eg. I{mailfilter}, I{bbdb}, I{glibc}
2160       - B{suite} - a suite name, eg. I{unstable}
2161
2162     @type source: string
2163     @param source: source package name
2164
2165     @type suite: string
2166     @param suite: the suite name
2167
2168     @rtype: string
2169     @return: the version for I{source} in I{suite}
2170
2171     """
2172
2173     q = session.query(SrcAssociation)
2174     q = q.join('source').filter_by(source=source)
2175     q = q.join('suite').filter_by(suite_name=suite)
2176
2177     try:
2178         return q.one().source
2179     except NoResultFound:
2180         return None
2181
2182 __all__.append('get_source_in_suite')
2183
2184 ################################################################################
2185
2186 @session_wrapper
2187 def add_dsc_to_db(u, filename, session=None):
2188     entry = u.pkg.files[filename]
2189     source = DBSource()
2190     pfs = []
2191
2192     source.source = u.pkg.dsc["source"]
2193     source.version = u.pkg.dsc["version"] # NB: not files[file]["version"], that has no epoch
2194     source.maintainer_id = get_or_set_maintainer(u.pkg.dsc["maintainer"], session).maintainer_id
2195     source.changedby_id = get_or_set_maintainer(u.pkg.changes["changed-by"], session).maintainer_id
2196     source.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
2197     source.install_date = datetime.now().date()
2198
2199     dsc_component = entry["component"]
2200     dsc_location_id = entry["location id"]
2201
2202     source.dm_upload_allowed = (u.pkg.dsc.get("dm-upload-allowed", '') == "yes")
2203
2204     # Set up a new poolfile if necessary
2205     if not entry.has_key("files id") or not entry["files id"]:
2206         filename = entry["pool name"] + filename
2207         poolfile = add_poolfile(filename, entry, dsc_location_id, session)
2208         session.flush()
2209         pfs.append(poolfile)
2210         entry["files id"] = poolfile.file_id
2211
2212     source.poolfile_id = entry["files id"]
2213     session.add(source)
2214     session.flush()
2215
2216     for suite_name in u.pkg.changes["distribution"].keys():
2217         sa = SrcAssociation()
2218         sa.source_id = source.source_id
2219         sa.suite_id = get_suite(suite_name).suite_id
2220         session.add(sa)
2221
2222     session.flush()
2223
2224     # Add the source files to the DB (files and dsc_files)
2225     dscfile = DSCFile()
2226     dscfile.source_id = source.source_id
2227     dscfile.poolfile_id = entry["files id"]
2228     session.add(dscfile)
2229
2230     for dsc_file, dentry in u.pkg.dsc_files.items():
2231         df = DSCFile()
2232         df.source_id = source.source_id
2233
2234         # If the .orig tarball is already in the pool, it's
2235         # files id is stored in dsc_files by check_dsc().
2236         files_id = dentry.get("files id", None)
2237
2238         # Find the entry in the files hash
2239         # TODO: Bail out here properly
2240         dfentry = None
2241         for f, e in u.pkg.files.items():
2242             if f == dsc_file:
2243                 dfentry = e
2244                 break
2245
2246         if files_id is None:
2247             filename = dfentry["pool name"] + dsc_file
2248
2249             (found, obj) = check_poolfile(filename, dentry["size"], dentry["md5sum"], dsc_location_id)
2250             # FIXME: needs to check for -1/-2 and or handle exception
2251             if found and obj is not None:
2252                 files_id = obj.file_id
2253                 pfs.append(obj)
2254
2255             # If still not found, add it
2256             if files_id is None:
2257                 # HACK: Force sha1sum etc into dentry
2258                 dentry["sha1sum"] = dfentry["sha1sum"]
2259                 dentry["sha256sum"] = dfentry["sha256sum"]
2260                 poolfile = add_poolfile(filename, dentry, dsc_location_id, session)
2261                 pfs.append(poolfile)
2262                 files_id = poolfile.file_id
2263         else:
2264             poolfile = get_poolfile_by_id(files_id, session)
2265             if poolfile is None:
2266                 utils.fubar("INTERNAL ERROR. Found no poolfile with id %d" % files_id)
2267             pfs.append(poolfile)
2268
2269         df.poolfile_id = files_id
2270         session.add(df)
2271
2272     session.flush()
2273
2274     # Add the src_uploaders to the DB
2275     uploader_ids = [source.maintainer_id]
2276     if u.pkg.dsc.has_key("uploaders"):
2277         for up in u.pkg.dsc["uploaders"].split(","):
2278             up = up.strip()
2279             uploader_ids.append(get_or_set_maintainer(up, session).maintainer_id)
2280
2281     added_ids = {}
2282     for up in uploader_ids:
2283         if added_ids.has_key(up):
2284             utils.warn("Already saw uploader %s for source %s" % (up, source.source))
2285             continue
2286
2287         added_ids[u]=1
2288
2289         su = SrcUploader()
2290         su.maintainer_id = up
2291         su.source_id = source.source_id
2292         session.add(su)
2293
2294     session.flush()
2295
2296     return dsc_component, dsc_location_id, pfs
2297
2298 __all__.append('add_dsc_to_db')
2299
2300 @session_wrapper
2301 def add_deb_to_db(u, filename, session=None):
2302     """
2303     Contrary to what you might expect, this routine deals with both
2304     debs and udebs.  That info is in 'dbtype', whilst 'type' is
2305     'deb' for both of them
2306     """
2307     cnf = Config()
2308     entry = u.pkg.files[filename]
2309
2310     bin = DBBinary()
2311     bin.package = entry["package"]
2312     bin.version = entry["version"]
2313     bin.maintainer_id = get_or_set_maintainer(entry["maintainer"], session).maintainer_id
2314     bin.fingerprint_id = get_or_set_fingerprint(u.pkg.changes["fingerprint"], session).fingerprint_id
2315     bin.arch_id = get_architecture(entry["architecture"], session).arch_id
2316     bin.binarytype = entry["dbtype"]
2317
2318     # Find poolfile id
2319     filename = entry["pool name"] + filename
2320     fullpath = os.path.join(cnf["Dir::Pool"], filename)
2321     if not entry.get("location id", None):
2322         entry["location id"] = get_location(cnf["Dir::Pool"], entry["component"], session=session).location_id
2323
2324     if entry.get("files id", None):
2325         poolfile = get_poolfile_by_id(bin.poolfile_id)
2326         bin.poolfile_id = entry["files id"]
2327     else:
2328         poolfile = add_poolfile(filename, entry, entry["location id"], session)
2329         bin.poolfile_id = entry["files id"] = poolfile.file_id
2330
2331     # Find source id
2332     bin_sources = get_sources_from_name(entry["source package"], entry["source version"], session=session)
2333     if len(bin_sources) != 1:
2334         raise NoSourceFieldError, "Unable to find a unique source id for %s (%s), %s, file %s, type %s, signed by %s" % \
2335                                   (bin.package, bin.version, bin.architecture.arch_string,
2336                                    filename, bin.binarytype, u.pkg.changes["fingerprint"])
2337
2338     bin.source_id = bin_sources[0].source_id
2339
2340     # Add and flush object so it has an ID
2341     session.add(bin)
2342     session.flush()
2343
2344     # Add BinAssociations
2345     for suite_name in u.pkg.changes["distribution"].keys():
2346         ba = BinAssociation()
2347         ba.binary_id = bin.binary_id
2348         ba.suite_id = get_suite(suite_name).suite_id
2349         session.add(ba)
2350
2351     session.flush()
2352
2353     # Deal with contents - disabled for now
2354     #contents = copy_temporary_contents(bin.package, bin.version, bin.architecture.arch_string, os.path.basename(filename), None, session)
2355     #if not contents:
2356     #    print "REJECT\nCould not determine contents of package %s" % bin.package
2357     #    session.rollback()
2358     #    raise MissingContents, "No contents stored for package %s, and couldn't determine contents of %s" % (bin.package, filename)
2359
2360     return poolfile
2361
2362 __all__.append('add_deb_to_db')
2363
2364 ################################################################################
2365
2366 class SourceACL(object):
2367     def __init__(self, *args, **kwargs):
2368         pass
2369
2370     def __repr__(self):
2371         return '<SourceACL %s>' % self.source_acl_id
2372
2373 __all__.append('SourceACL')
2374
2375 ################################################################################
2376
2377 class SrcAssociation(object):
2378     def __init__(self, *args, **kwargs):
2379         pass
2380
2381     def __repr__(self):
2382         return '<SrcAssociation %s (%s, %s)>' % (self.sa_id, self.source, self.suite)
2383
2384 __all__.append('SrcAssociation')
2385
2386 ################################################################################
2387
2388 class SrcFormat(object):
2389     def __init__(self, *args, **kwargs):
2390         pass
2391
2392     def __repr__(self):
2393         return '<SrcFormat %s>' % (self.format_name)
2394
2395 __all__.append('SrcFormat')
2396
2397 ################################################################################
2398
2399 class SrcUploader(object):
2400     def __init__(self, *args, **kwargs):
2401         pass
2402
2403     def __repr__(self):
2404         return '<SrcUploader %s>' % self.uploader_id
2405
2406 __all__.append('SrcUploader')
2407
2408 ################################################################################
2409
2410 SUITE_FIELDS = [ ('SuiteName', 'suite_name'),
2411                  ('SuiteID', 'suite_id'),
2412                  ('Version', 'version'),
2413                  ('Origin', 'origin'),
2414                  ('Label', 'label'),
2415                  ('Description', 'description'),
2416                  ('Untouchable', 'untouchable'),
2417                  ('Announce', 'announce'),
2418                  ('Codename', 'codename'),
2419                  ('OverrideCodename', 'overridecodename'),
2420                  ('ValidTime', 'validtime'),
2421                  ('Priority', 'priority'),
2422                  ('NotAutomatic', 'notautomatic'),
2423                  ('CopyChanges', 'copychanges'),
2424                  ('CopyDotDak', 'copydotdak'),
2425                  ('CommentsDir', 'commentsdir'),
2426                  ('OverrideSuite', 'overridesuite'),
2427                  ('ChangelogBase', 'changelogbase')]
2428
2429
2430 class Suite(object):
2431     def __init__(self, *args, **kwargs):
2432         pass
2433
2434     def __repr__(self):
2435         return '<Suite %s>' % self.suite_name
2436
2437     def __eq__(self, val):
2438         if isinstance(val, str):
2439             return (self.suite_name == val)
2440         # This signals to use the normal comparison operator
2441         return NotImplemented
2442
2443     def __ne__(self, val):
2444         if isinstance(val, str):
2445             return (self.suite_name != val)
2446         # This signals to use the normal comparison operator
2447         return NotImplemented
2448
2449     def details(self):
2450         ret = []
2451         for disp, field in SUITE_FIELDS:
2452             val = getattr(self, field, None)
2453             if val is not None:
2454                 ret.append("%s: %s" % (disp, val))
2455
2456         return "\n".join(ret)
2457
2458 __all__.append('Suite')
2459
2460 @session_wrapper
2461 def get_suite_architecture(suite, architecture, session=None):
2462     """
2463     Returns a SuiteArchitecture object given C{suite} and ${arch} or None if it
2464     doesn't exist
2465
2466     @type suite: str
2467     @param suite: Suite name to search for
2468
2469     @type architecture: str
2470     @param architecture: Architecture name to search for
2471
2472     @type session: Session
2473     @param session: Optional SQL session object (a temporary one will be
2474     generated if not supplied)
2475
2476     @rtype: SuiteArchitecture
2477     @return: the SuiteArchitecture object or None
2478     """
2479
2480     q = session.query(SuiteArchitecture)
2481     q = q.join(Architecture).filter_by(arch_string=architecture)
2482     q = q.join(Suite).filter_by(suite_name=suite)
2483
2484     try:
2485         return q.one()
2486     except NoResultFound:
2487         return None
2488
2489 __all__.append('get_suite_architecture')
2490
2491 @session_wrapper
2492 def get_suite(suite, session=None):
2493     """
2494     Returns Suite object for given C{suite name}.
2495
2496     @type suite: string
2497     @param suite: The name of the suite
2498
2499     @type session: Session
2500     @param session: Optional SQLA session object (a temporary one will be
2501     generated if not supplied)
2502
2503     @rtype: Suite
2504     @return: Suite object for the requested suite name (None if not present)
2505     """
2506
2507     q = session.query(Suite).filter_by(suite_name=suite)
2508
2509     try:
2510         return q.one()
2511     except NoResultFound:
2512         return None
2513
2514 __all__.append('get_suite')
2515
2516 ################################################################################
2517
2518 class SuiteArchitecture(object):
2519     def __init__(self, *args, **kwargs):
2520         pass
2521
2522     def __repr__(self):
2523         return '<SuiteArchitecture (%s, %s)>' % (self.suite_id, self.arch_id)
2524
2525 __all__.append('SuiteArchitecture')
2526
2527 @session_wrapper
2528 def get_suite_architectures(suite, skipsrc=False, skipall=False, session=None):
2529     """
2530     Returns list of Architecture objects for given C{suite} name
2531
2532     @type source: str
2533     @param source: Suite name to search for
2534
2535     @type skipsrc: boolean
2536     @param skipsrc: Whether to skip returning the 'source' architecture entry
2537     (Default False)
2538
2539     @type skipall: boolean
2540     @param skipall: Whether to skip returning the 'all' architecture entry
2541     (Default False)
2542
2543     @type session: Session
2544     @param session: Optional SQL session object (a temporary one will be
2545     generated if not supplied)
2546
2547     @rtype: list
2548     @return: list of Architecture objects for the given name (may be empty)
2549     """
2550
2551     q = session.query(Architecture)
2552     q = q.join(SuiteArchitecture)
2553     q = q.join(Suite).filter_by(suite_name=suite)
2554
2555     if skipsrc:
2556         q = q.filter(Architecture.arch_string != 'source')
2557
2558     if skipall:
2559         q = q.filter(Architecture.arch_string != 'all')
2560
2561     q = q.order_by('arch_string')
2562
2563     return q.all()
2564
2565 __all__.append('get_suite_architectures')
2566
2567 ################################################################################
2568
2569 class SuiteSrcFormat(object):
2570     def __init__(self, *args, **kwargs):
2571         pass
2572
2573     def __repr__(self):
2574         return '<SuiteSrcFormat (%s, %s)>' % (self.suite_id, self.src_format_id)
2575
2576 __all__.append('SuiteSrcFormat')
2577
2578 @session_wrapper
2579 def get_suite_src_formats(suite, session=None):
2580     """
2581     Returns list of allowed SrcFormat for C{suite}.
2582
2583     @type suite: str
2584     @param suite: Suite name to search for
2585
2586     @type session: Session
2587     @param session: Optional SQL session object (a temporary one will be
2588     generated if not supplied)
2589
2590     @rtype: list
2591     @return: the list of allowed source formats for I{suite}
2592     """
2593
2594     q = session.query(SrcFormat)
2595     q = q.join(SuiteSrcFormat)
2596     q = q.join(Suite).filter_by(suite_name=suite)
2597     q = q.order_by('format_name')
2598
2599     return q.all()
2600
2601 __all__.append('get_suite_src_formats')
2602
2603 ################################################################################
2604
2605 class Uid(object):
2606     def __init__(self, *args, **kwargs):
2607         pass
2608
2609     def __eq__(self, val):
2610         if isinstance(val, str):
2611             return (self.uid == val)
2612         # This signals to use the normal comparison operator
2613         return NotImplemented
2614
2615     def __ne__(self, val):
2616         if isinstance(val, str):
2617             return (self.uid != val)
2618         # This signals to use the normal comparison operator
2619         return NotImplemented
2620
2621     def __repr__(self):
2622         return '<Uid %s (%s)>' % (self.uid, self.name)
2623
2624 __all__.append('Uid')
2625
2626 @session_wrapper
2627 def add_database_user(uidname, session=None):
2628     """
2629     Adds a database user
2630
2631     @type uidname: string
2632     @param uidname: The uid of the user to add
2633
2634     @type session: SQLAlchemy
2635     @param session: Optional SQL session object (a temporary one will be
2636     generated if not supplied).  If not passed, a commit will be performed at
2637     the end of the function, otherwise the caller is responsible for commiting.
2638
2639     @rtype: Uid
2640     @return: the uid object for the given uidname
2641     """
2642
2643     session.execute("CREATE USER :uid", {'uid': uidname})
2644     session.commit_or_flush()
2645
2646 __all__.append('add_database_user')
2647
2648 @session_wrapper
2649 def get_or_set_uid(uidname, session=None):
2650     """
2651     Returns uid object for given uidname.
2652
2653     If no matching uidname is found, a row is inserted.
2654
2655     @type uidname: string
2656     @param uidname: The uid to add
2657
2658     @type session: SQLAlchemy
2659     @param session: Optional SQL session object (a temporary one will be
2660     generated if not supplied).  If not passed, a commit will be performed at
2661     the end of the function, otherwise the caller is responsible for commiting.
2662
2663     @rtype: Uid
2664     @return: the uid object for the given uidname
2665     """
2666
2667     q = session.query(Uid).filter_by(uid=uidname)
2668
2669     try:
2670         ret = q.one()
2671     except NoResultFound:
2672         uid = Uid()
2673         uid.uid = uidname
2674         session.add(uid)
2675         session.commit_or_flush()
2676         ret = uid
2677
2678     return ret
2679
2680 __all__.append('get_or_set_uid')
2681
2682 @session_wrapper
2683 def get_uid_from_fingerprint(fpr, session=None):
2684     q = session.query(Uid)
2685     q = q.join(Fingerprint).filter_by(fingerprint=fpr)
2686
2687     try:
2688         return q.one()
2689     except NoResultFound:
2690         return None
2691
2692 __all__.append('get_uid_from_fingerprint')
2693
2694 ################################################################################
2695
2696 class UploadBlock(object):
2697     def __init__(self, *args, **kwargs):
2698         pass
2699
2700     def __repr__(self):
2701         return '<UploadBlock %s (%s)>' % (self.source, self.upload_block_id)
2702
2703 __all__.append('UploadBlock')
2704
2705 ################################################################################
2706
2707 class DBConn(object):
2708     """
2709     database module init.
2710     """
2711     __shared_state = {}
2712
2713     def __init__(self, *args, **kwargs):
2714         self.__dict__ = self.__shared_state
2715
2716         if not getattr(self, 'initialised', False):
2717             self.initialised = True
2718             self.debug = kwargs.has_key('debug')
2719             self.__createconn()
2720
2721     def __setuptables(self):
2722         tables = (
2723             'architecture',
2724             'archive',
2725             'bin_associations',
2726             'binaries',
2727             'binary_acl',
2728             'binary_acl_map',
2729             'build_queue',
2730             'build_queue_files',
2731             'component',
2732             'config',
2733             'content_associations',
2734             'content_file_names',
2735             'content_file_paths',
2736             'changes_pending_binaries',
2737             'changes_pending_files',
2738             'changes_pending_files_map',
2739             'changes_pending_source',
2740             'changes_pending_source_files',
2741             'changes_pool_files',
2742             'dsc_files',
2743             'files',
2744             'fingerprint',
2745             'keyrings',
2746             'changes',
2747             'keyring_acl_map',
2748             'location',
2749             'maintainer',
2750             'new_comments',
2751             'override',
2752             'override_type',
2753             'pending_content_associations',
2754             'policy_queue',
2755             'priority',
2756             'section',
2757             'source',
2758             'source_acl',
2759             'src_associations',
2760             'src_format',
2761             'src_uploaders',
2762             'suite',
2763             'suite_architectures',
2764             'suite_src_formats',
2765             'suite_build_queue_copy',
2766             'uid',
2767             'upload_blocks',
2768         )
2769
2770         for table_name in tables:
2771             table = Table(table_name, self.db_meta, autoload=True)
2772             setattr(self, 'tbl_%s' % table_name, table)
2773
2774     def __setupmappers(self):
2775         mapper(Architecture, self.tbl_architecture,
2776                properties = dict(arch_id = self.tbl_architecture.c.id))
2777
2778         mapper(Archive, self.tbl_archive,
2779                properties = dict(archive_id = self.tbl_archive.c.id,
2780                                  archive_name = self.tbl_archive.c.name))
2781
2782         mapper(BinAssociation, self.tbl_bin_associations,
2783                properties = dict(ba_id = self.tbl_bin_associations.c.id,
2784                                  suite_id = self.tbl_bin_associations.c.suite,
2785                                  suite = relation(Suite),
2786                                  binary_id = self.tbl_bin_associations.c.bin,
2787                                  binary = relation(DBBinary)))
2788
2789         mapper(BuildQueue, self.tbl_build_queue,
2790                properties = dict(queue_id = self.tbl_build_queue.c.id))
2791
2792         mapper(BuildQueueFile, self.tbl_build_queue_files,
2793                properties = dict(buildqueue = relation(BuildQueue, backref='queuefiles'),
2794                                  poolfile = relation(PoolFile, backref='buildqueueinstances')))
2795
2796         mapper(DBBinary, self.tbl_binaries,
2797                properties = dict(binary_id = self.tbl_binaries.c.id,
2798                                  package = self.tbl_binaries.c.package,
2799                                  version = self.tbl_binaries.c.version,
2800                                  maintainer_id = self.tbl_binaries.c.maintainer,
2801                                  maintainer = relation(Maintainer),
2802                                  source_id = self.tbl_binaries.c.source,
2803                                  source = relation(DBSource),
2804                                  arch_id = self.tbl_binaries.c.architecture,
2805                                  architecture = relation(Architecture),
2806                                  poolfile_id = self.tbl_binaries.c.file,
2807                                  poolfile = relation(PoolFile),
2808                                  binarytype = self.tbl_binaries.c.type,
2809                                  fingerprint_id = self.tbl_binaries.c.sig_fpr,
2810                                  fingerprint = relation(Fingerprint),
2811                                  install_date = self.tbl_binaries.c.install_date,
2812                                  binassociations = relation(BinAssociation,
2813                                                             primaryjoin=(self.tbl_binaries.c.id==self.tbl_bin_associations.c.bin))))
2814
2815         mapper(BinaryACL, self.tbl_binary_acl,
2816                properties = dict(binary_acl_id = self.tbl_binary_acl.c.id))
2817
2818         mapper(BinaryACLMap, self.tbl_binary_acl_map,
2819                properties = dict(binary_acl_map_id = self.tbl_binary_acl_map.c.id,
2820                                  fingerprint = relation(Fingerprint, backref="binary_acl_map"),
2821                                  architecture = relation(Architecture)))
2822
2823         mapper(Component, self.tbl_component,
2824                properties = dict(component_id = self.tbl_component.c.id,
2825                                  component_name = self.tbl_component.c.name))
2826
2827         mapper(DBConfig, self.tbl_config,
2828                properties = dict(config_id = self.tbl_config.c.id))
2829
2830         mapper(DSCFile, self.tbl_dsc_files,
2831                properties = dict(dscfile_id = self.tbl_dsc_files.c.id,
2832                                  source_id = self.tbl_dsc_files.c.source,
2833                                  source = relation(DBSource),
2834                                  poolfile_id = self.tbl_dsc_files.c.file,
2835                                  poolfile = relation(PoolFile)))
2836
2837         mapper(PoolFile, self.tbl_files,
2838                properties = dict(file_id = self.tbl_files.c.id,
2839                                  filesize = self.tbl_files.c.size,
2840                                  location_id = self.tbl_files.c.location,
2841                                  location = relation(Location)))
2842
2843         mapper(Fingerprint, self.tbl_fingerprint,
2844                properties = dict(fingerprint_id = self.tbl_fingerprint.c.id,
2845                                  uid_id = self.tbl_fingerprint.c.uid,
2846                                  uid = relation(Uid),
2847                                  keyring_id = self.tbl_fingerprint.c.keyring,
2848                                  keyring = relation(Keyring),
2849                                  source_acl = relation(SourceACL),
2850                                  binary_acl = relation(BinaryACL)))
2851
2852         mapper(Keyring, self.tbl_keyrings,
2853                properties = dict(keyring_name = self.tbl_keyrings.c.name,
2854                                  keyring_id = self.tbl_keyrings.c.id))
2855
2856         mapper(DBChange, self.tbl_changes,
2857                properties = dict(change_id = self.tbl_changes.c.id,
2858                                  poolfiles = relation(PoolFile,
2859                                                       secondary=self.tbl_changes_pool_files,
2860                                                       backref="changeslinks"),
2861                                  seen = self.tbl_changes.c.seen,
2862                                  source = self.tbl_changes.c.source,
2863                                  binaries = self.tbl_changes.c.binaries,
2864                                  architecture = self.tbl_changes.c.architecture,
2865                                  distribution = self.tbl_changes.c.distribution,
2866                                  urgency = self.tbl_changes.c.urgency,
2867                                  maintainer = self.tbl_changes.c.maintainer,
2868                                  changedby = self.tbl_changes.c.changedby,
2869                                  date = self.tbl_changes.c.date,
2870                                  version = self.tbl_changes.c.version,
2871                                  files = relation(ChangePendingFile,
2872                                                   secondary=self.tbl_changes_pending_files_map,
2873                                                   backref="changesfile"),
2874                                  in_queue_id = self.tbl_changes.c.in_queue,
2875                                  in_queue = relation(PolicyQueue,
2876                                                      primaryjoin=(self.tbl_changes.c.in_queue==self.tbl_policy_queue.c.id)),
2877                                  approved_for_id = self.tbl_changes.c.approved_for))
2878
2879         mapper(ChangePendingBinary, self.tbl_changes_pending_binaries,
2880                properties = dict(change_pending_binary_id = self.tbl_changes_pending_binaries.c.id))
2881
2882         mapper(ChangePendingFile, self.tbl_changes_pending_files,
2883                properties = dict(change_pending_file_id = self.tbl_changes_pending_files.c.id,
2884                                  filename = self.tbl_changes_pending_files.c.filename,
2885                                  size = self.tbl_changes_pending_files.c.size,
2886                                  md5sum = self.tbl_changes_pending_files.c.md5sum,
2887                                  sha1sum = self.tbl_changes_pending_files.c.sha1sum,
2888                                  sha256sum = self.tbl_changes_pending_files.c.sha256sum))
2889
2890         mapper(ChangePendingSource, self.tbl_changes_pending_source,
2891                properties = dict(change_pending_source_id = self.tbl_changes_pending_source.c.id,
2892                                  change = relation(DBChange),
2893                                  maintainer = relation(Maintainer,
2894                                                        primaryjoin=(self.tbl_changes_pending_source.c.maintainer_id==self.tbl_maintainer.c.id)),
2895                                  changedby = relation(Maintainer,
2896                                                       primaryjoin=(self.tbl_changes_pending_source.c.changedby_id==self.tbl_maintainer.c.id)),
2897                                  fingerprint = relation(Fingerprint),
2898                                  source_files = relation(ChangePendingFile,
2899                                                          secondary=self.tbl_changes_pending_source_files,
2900                                                          backref="pending_sources")))
2901         mapper(KeyringACLMap, self.tbl_keyring_acl_map,
2902                properties = dict(keyring_acl_map_id = self.tbl_keyring_acl_map.c.id,
2903                                  keyring = relation(Keyring, backref="keyring_acl_map"),
2904                                  architecture = relation(Architecture)))
2905
2906         mapper(Location, self.tbl_location,
2907                properties = dict(location_id = self.tbl_location.c.id,
2908                                  component_id = self.tbl_location.c.component,
2909                                  component = relation(Component),
2910                                  archive_id = self.tbl_location.c.archive,
2911                                  archive = relation(Archive),
2912                                  archive_type = self.tbl_location.c.type))
2913
2914         mapper(Maintainer, self.tbl_maintainer,
2915                properties = dict(maintainer_id = self.tbl_maintainer.c.id))
2916
2917         mapper(NewComment, self.tbl_new_comments,
2918                properties = dict(comment_id = self.tbl_new_comments.c.id))
2919
2920         mapper(Override, self.tbl_override,
2921                properties = dict(suite_id = self.tbl_override.c.suite,
2922                                  suite = relation(Suite),
2923                                  component_id = self.tbl_override.c.component,
2924                                  component = relation(Component),
2925                                  priority_id = self.tbl_override.c.priority,
2926                                  priority = relation(Priority),
2927                                  section_id = self.tbl_override.c.section,
2928                                  section = relation(Section),
2929                                  overridetype_id = self.tbl_override.c.type,
2930                                  overridetype = relation(OverrideType)))
2931
2932         mapper(OverrideType, self.tbl_override_type,
2933                properties = dict(overridetype = self.tbl_override_type.c.type,
2934                                  overridetype_id = self.tbl_override_type.c.id))
2935
2936         mapper(PolicyQueue, self.tbl_policy_queue,
2937                properties = dict(policy_queue_id = self.tbl_policy_queue.c.id))
2938
2939         mapper(Priority, self.tbl_priority,
2940                properties = dict(priority_id = self.tbl_priority.c.id))
2941
2942         mapper(Section, self.tbl_section,
2943                properties = dict(section_id = self.tbl_section.c.id))
2944
2945         mapper(DBSource, self.tbl_source,
2946                properties = dict(source_id = self.tbl_source.c.id,
2947                                  version = self.tbl_source.c.version,
2948                                  maintainer_id = self.tbl_source.c.maintainer,
2949                                  maintainer = relation(Maintainer,
2950                                                        primaryjoin=(self.tbl_source.c.maintainer==self.tbl_maintainer.c.id)),
2951                                  poolfile_id = self.tbl_source.c.file,
2952                                  poolfile = relation(PoolFile),
2953                                  fingerprint_id = self.tbl_source.c.sig_fpr,
2954                                  fingerprint = relation(Fingerprint),
2955                                  changedby_id = self.tbl_source.c.changedby,
2956                                  changedby = relation(Maintainer,
2957                                                       primaryjoin=(self.tbl_source.c.changedby==self.tbl_maintainer.c.id)),
2958                                  srcfiles = relation(DSCFile,
2959                                                      primaryjoin=(self.tbl_source.c.id==self.tbl_dsc_files.c.source)),
2960                                  srcassociations = relation(SrcAssociation,
2961                                                             primaryjoin=(self.tbl_source.c.id==self.tbl_src_associations.c.source)),
2962                                  srcuploaders = relation(SrcUploader)))
2963
2964         mapper(SourceACL, self.tbl_source_acl,
2965                properties = dict(source_acl_id = self.tbl_source_acl.c.id))
2966
2967         mapper(SrcAssociation, self.tbl_src_associations,
2968                properties = dict(sa_id = self.tbl_src_associations.c.id,
2969                                  suite_id = self.tbl_src_associations.c.suite,
2970                                  suite = relation(Suite),
2971                                  source_id = self.tbl_src_associations.c.source,
2972                                  source = relation(DBSource)))
2973
2974         mapper(SrcFormat, self.tbl_src_format,
2975                properties = dict(src_format_id = self.tbl_src_format.c.id,
2976                                  format_name = self.tbl_src_format.c.format_name))
2977
2978         mapper(SrcUploader, self.tbl_src_uploaders,
2979                properties = dict(uploader_id = self.tbl_src_uploaders.c.id,
2980                                  source_id = self.tbl_src_uploaders.c.source,
2981                                  source = relation(DBSource,
2982                                                    primaryjoin=(self.tbl_src_uploaders.c.source==self.tbl_source.c.id)),
2983                                  maintainer_id = self.tbl_src_uploaders.c.maintainer,
2984                                  maintainer = relation(Maintainer,
2985                                                        primaryjoin=(self.tbl_src_uploaders.c.maintainer==self.tbl_maintainer.c.id))))
2986
2987         mapper(Suite, self.tbl_suite,
2988                properties = dict(suite_id = self.tbl_suite.c.id,
2989                                  policy_queue = relation(PolicyQueue),
2990                                  copy_queues = relation(BuildQueue, secondary=self.tbl_suite_build_queue_copy)))
2991
2992         mapper(SuiteArchitecture, self.tbl_suite_architectures,
2993                properties = dict(suite_id = self.tbl_suite_architectures.c.suite,
2994                                  suite = relation(Suite, backref='suitearchitectures'),
2995                                  arch_id = self.tbl_suite_architectures.c.architecture,
2996                                  architecture = relation(Architecture)))
2997
2998         mapper(SuiteSrcFormat, self.tbl_suite_src_formats,
2999                properties = dict(suite_id = self.tbl_suite_src_formats.c.suite,
3000                                  suite = relation(Suite, backref='suitesrcformats'),
3001                                  src_format_id = self.tbl_suite_src_formats.c.src_format,
3002                                  src_format = relation(SrcFormat)))
3003
3004         mapper(Uid, self.tbl_uid,
3005                properties = dict(uid_id = self.tbl_uid.c.id,
3006                                  fingerprint = relation(Fingerprint)))
3007
3008         mapper(UploadBlock, self.tbl_upload_blocks,
3009                properties = dict(upload_block_id = self.tbl_upload_blocks.c.id,
3010                                  fingerprint = relation(Fingerprint, backref="uploadblocks"),
3011                                  uid = relation(Uid, backref="uploadblocks")))
3012
3013     ## Connection functions
3014     def __createconn(self):
3015         from config import Config
3016         cnf = Config()
3017         if cnf["DB::Host"]:
3018             # TCP/IP
3019             connstr = "postgres://%s" % cnf["DB::Host"]
3020             if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
3021                 connstr += ":%s" % cnf["DB::Port"]
3022             connstr += "/%s" % cnf["DB::Name"]
3023         else:
3024             # Unix Socket
3025             connstr = "postgres:///%s" % cnf["DB::Name"]
3026             if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
3027                 connstr += "?port=%s" % cnf["DB::Port"]
3028
3029         self.db_pg   = create_engine(connstr, echo=self.debug)
3030         self.db_meta = MetaData()
3031         self.db_meta.bind = self.db_pg
3032         self.db_smaker = sessionmaker(bind=self.db_pg,
3033                                       autoflush=True,
3034                                       autocommit=False)
3035
3036         self.__setuptables()
3037         self.__setupmappers()
3038
3039     def session(self):
3040         return self.db_smaker()
3041
3042 __all__.append('DBConn')
3043
3044