X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;ds=sidebyside;f=daklib%2Fdbconn.py;h=d2f4b594d00b60c320cb57045679785216671ef9;hb=eac8189d964d4d5f34a13e692caab0e732045a15;hp=537f822d65a445493e0515d1581ca74dd2da51aa;hpb=32526b9cafff9b9ab3cfae177e634b7f4b43dcc3;p=dak.git diff --git a/daklib/dbconn.py b/daklib/dbconn.py index 537f822d..d2f4b594 100755 --- a/daklib/dbconn.py +++ b/daklib/dbconn.py @@ -44,6 +44,7 @@ from sqlalchemy.orm import sessionmaker, mapper, relation from sqlalchemy.exc import * from singleton import Singleton +from textutils import fix_maintainer ################################################################################ @@ -210,6 +211,27 @@ def get_binaries_from_name(package, session=None): __all__.append('get_binaries_from_name') +def get_binary_from_name_suite(package, suitename, session=None): + ### For dak examine-package + ### XXX: Doesn't use object API yet + if session is None: + session = DBConn().session() + + sql = """SELECT DISTINCT(b.package), b.version, c.name, su.suite_name + FROM binaries b, files fi, location l, component c, bin_associations ba, suite su + WHERE b.package=:package + AND b.file = fi.id + AND fi.location = l.id + AND l.component = c.id + AND ba.bin=b.id + AND ba.suite = su.id + AND su.suite_name=:suitename + ORDER BY b.version DESC""" + + return session.execute(sql, {'package': package, 'suitename': suitename}) + +__all__.append('get_binary_from_name_suite') + def get_binary_components(package, suitename, arch, session=None): # Check for packages that have moved from one component to another query = """SELECT c.name FROM binaries b, bin_associations ba, suite s, location l, component c, architecture a, files f @@ -292,13 +314,16 @@ def get_or_set_contents_file_id(filename, session=None): @param filename: The filename @type session: SQLAlchemy @param session: Optional SQL session object (a temporary one will be - generated if not supplied) + generated if not supplied). If not passed, a commit will be performed at + the end of the function, otherwise the caller is responsible for commiting. @rtype: int @return: the database id for the given component """ + privatetrans = False if session is None: session = DBConn().session() + privatetrans = True try: q = session.query(ContentFilename).filter_by(filename=filename) @@ -306,6 +331,8 @@ def get_or_set_contents_file_id(filename, session=None): cf = ContentFilename() cf.filename = filename session.add(cf) + if privatetrans: + session.commit() return cf.cafilename_id else: return q.one().cafilename_id @@ -316,6 +343,59 @@ def get_or_set_contents_file_id(filename, session=None): __all__.append('get_or_set_contents_file_id') +def get_contents(suite, overridetype, section=None, session=None): + """ + Returns contents for a suite / overridetype combination, limiting + to a section if not None. + + @type suite: Suite + @param suite: Suite object + + @type overridetype: OverrideType + @param overridetype: OverrideType object + + @type section: Section + @param section: Optional section object to limit results to + + @type session: SQLAlchemy + @param session: Optional SQL session object (a temporary one will be + generated if not supplied) + + @rtype: ResultsProxy + @return: ResultsProxy object set up to return tuples of (filename, section, + package, arch_id) + """ + + if session is None: + session = DBConn().session() + + # find me all of the contents for a given suite + contents_q = """SELECT (p.path||'/'||n.file) AS fn, + s.section, + b.package, + b.architecture + FROM content_associations c join content_file_paths p ON (c.filepath=p.id) + JOIN content_file_names n ON (c.filename=n.id) + JOIN binaries b ON (b.id=c.binary_pkg) + JOIN override o ON (o.package=b.package) + JOIN section s ON (s.id=o.section) + WHERE o.suite = :suiteid AND o.type = :overridetypeid + AND b.type=:overridetypename""" + + vals = {'suiteid': suite.suite_id, + 'overridetypeid': overridetype.overridetype_id, + 'overridetypename': overridetype.overridetype} + + if section is not None: + contents_q += " AND s.id = :sectionid" + vals['sectionid'] = section.section_id + + contents_q += " ORDER BY fn" + + return session.execute(contents_q, vals) + +__all__.append('get_contents') + ################################################################################ class ContentFilepath(object): @@ -337,13 +417,16 @@ def get_or_set_contents_path_id(filepath, session): @param filename: The filepath @type session: SQLAlchemy @param session: Optional SQL session object (a temporary one will be - generated if not supplied) + generated if not supplied). If not passed, a commit will be performed at + the end of the function, otherwise the caller is responsible for commiting. @rtype: int @return: the database id for the given path """ + privatetrans = False if session is None: session = DBConn().session() + privatetrans = True try: q = session.query(ContentFilepath).filter_by(filepath=filepath) @@ -351,6 +434,8 @@ def get_or_set_contents_path_id(filepath, session): cf = ContentFilepath() cf.filepath = filepath session.add(cf) + if privatetrans: + session.commit() return cf.cafilepath_id else: return q.one().cafilepath_id @@ -384,7 +469,8 @@ def insert_content_paths(binary_id, fullpaths, session=None): @param session: Optional SQLAlchemy session. If this is passed, the caller is responsible for ensuring a transaction has begun and committing the results or rolling back based on the result code. If not passed, a commit - will be performed at the end of the function + will be performed at the end of the function, otherwise the caller is + responsible for commiting. @return: True upon success """ @@ -549,6 +635,12 @@ class Maintainer(object): def __repr__(self): return '''''' % (self.name, self.maintainer_id) + def get_split_maintainer(self): + if not hasattr(self, 'name') or self.name is None: + return ('', '', '', '') + + return fix_maintainer(self.name.strip()) + __all__.append('Maintainer') ################################################################################ @@ -590,7 +682,7 @@ def get_override_type(override_type, session=None): """ if session is None: session = DBConn().session() - q = session.query(Priority).filter_by(priority=priority) + q = session.query(OverrideType).filter_by(overridetype=override_type) if q.count() == 0: return None return q.one() @@ -777,13 +869,17 @@ class DBSource(object): __all__.append('DBSource') -def get_sources_from_name(source, session=None): +def get_sources_from_name(source, dm_upload_allowed=None, session=None): """ Returns list of DBSource objects for given C{source} name @type source: str @param source: DBSource package name to search for + @type dm_upload_allowed: bool + @param dm_upload_allowed: If None, no effect. If True or False, only + return packages with that dm_upload_allowed setting + @type session: Session @param session: Optional SQL session object (a temporary one will be generated if not supplied) @@ -793,7 +889,12 @@ def get_sources_from_name(source, session=None): """ if session is None: session = DBConn().session() - return session.query(DBSource).filter_by(source=source).all() + + q = session.query(DBSource).filter_by(source=source) + if dm_upload_allowed is not None: + q = q.filter_by(dm_upload_allowed=dm_upload_allowed) + + return q.all() __all__.append('get_sources_from_name') @@ -850,6 +951,26 @@ __all__.append('SrcUploader') ################################################################################ +SUITE_FIELDS = [ ('SuiteName', 'suite_name'), + ('SuiteID', 'suite_id'), + ('Version', 'version'), + ('Origin', 'origin'), + ('Label', 'label'), + ('Description', 'description'), + ('Untouchable', 'untouchable'), + ('Announce', 'announce'), + ('Codename', 'codename'), + ('OverrideCodename', 'overridecodename'), + ('ValidTime', 'validtime'), + ('Priority', 'priority'), + ('NotAutomatic', 'notautomatic'), + ('CopyChanges', 'copychanges'), + ('CopyDotDak', 'copydotdak'), + ('CommentsDir', 'commentsdir'), + ('OverrideSuite', 'overridesuite'), + ('ChangelogBase', 'changelogbase')] + + class Suite(object): def __init__(self, *args, **kwargs): pass @@ -857,6 +978,15 @@ class Suite(object): def __repr__(self): return '' % self.suite_name + def details(self): + ret = [] + for disp, field in SUITE_FIELDS: + val = getattr(self, field, None) + if val is not None: + ret.append("%s: %s" % (disp, val)) + + return "\n".join(ret) + __all__.append('Suite') def get_suite_architecture(suite, architecture, session=None): @@ -974,6 +1104,77 @@ class Uid(object): __all__.append('Uid') +def add_database_user(uidname, session=None): + """ + Adds a database user + + @type uidname: string + @param uidname: The uid of the user to add + + @type session: SQLAlchemy + @param session: Optional SQL session object (a temporary one will be + generated if not supplied). If not passed, a commit will be performed at + the end of the function, otherwise the caller is responsible for commiting. + + @rtype: Uid + @return: the uid object for the given uidname + """ + privatetrans = False + if session is None: + session = DBConn().session() + privatetrans = True + + try: + session.execute("CREATE USER :uid", {'uid': uidname}) + if privatetrans: + session.commit() + except: + traceback.print_exc() + raise + +__all__.append('add_database_user') + +def get_or_set_uid(uidname, session=None): + """ + Returns uid object for given uidname. + + If no matching uidname is found, a row is inserted. + + @type uidname: string + @param uidname: The uid to add + + @type session: SQLAlchemy + @param session: Optional SQL session object (a temporary one will be + generated if not supplied). If not passed, a commit will be performed at + the end of the function, otherwise the caller is responsible for commiting. + + @rtype: Uid + @return: the uid object for the given uidname + """ + privatetrans = False + if session is None: + session = DBConn().session() + privatetrans = True + + try: + q = session.query(Uid).filter_by(uid=uidname) + if q.count() < 1: + uid = Uid() + uid.uid = uidname + session.add(uid) + if privatetrans: + session.commit() + return uid + else: + return q.one() + + except: + traceback.print_exc() + raise + +__all__.append('get_or_set_uid') + + def get_uid_from_fingerprint(fpr, session=None): if session is None: session = DBConn().session()