From: Mark Hymers Date: Mon, 25 May 2009 18:29:54 +0000 (+0100) Subject: convert add_user to SQLa X-Git-Url: https://err.no/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=8ddcf2fc24b1a0542ed38a25cab7316029a46147;p=dak convert add_user to SQLa Signed-off-by: Mark Hymers --- diff --git a/dak/add_user.py b/dak/add_user.py index 851e0e2e..0e69b7a7 100755 --- a/dak/add_user.py +++ b/dak/add_user.py @@ -24,16 +24,16 @@ import sys import time import os import apt_pkg -from daklib import database + from daklib import daklog from daklib import queue from daklib import utils +from daklib.dbconn import DBConn, add_database_user, get_or_set_uid from daklib.regexes import re_gpg_fingerprint, re_user_address, re_user_mails, re_user_name ################################################################################ Cnf = None -projectB = None Logger = None Upload = None Subst = None @@ -108,7 +108,7 @@ Additionally there is now an account created for you. ################################################################################ def main(): - global Cnf, projectB + global Cnf keyrings = None Cnf = utils.get_conf() @@ -129,8 +129,7 @@ def main(): if Options["help"]: usage() - projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"])) - database.init(Cnf, projectB) + session = DBConn().session() if not keyrings: keyrings = Cnf.ValueList("Dinstall::GPGKeyring") @@ -204,16 +203,18 @@ def main(): utils.warn("Could not prepare password information for mail, not sending password.") # Now add user to the database. - projectB.query("BEGIN WORK") - uid_id = database.get_or_set_uid_id(uid) - projectB.query('CREATE USER "%s"' % (uid)) - projectB.query("COMMIT WORK") + # Note that we provide a session, so we're responsible for committing + uidobj = get_or_set_uid(uid, session=session) + uid_id = uidobj.uid_id + add_database_user(uid) + session.commit() # The following two are kicked out in rhona, so we don't set them. kelly adds # them as soon as she installs a package with unknown ones, so no problems to expect here. # Just leave the comment in, to not think about "Why the hell aren't they added" in # a year, if we ever touch uma again. # maint_id = database.get_or_set_maintainer_id(name) -# projectB.query("INSERT INTO fingerprint (fingerprint, uid) VALUES ('%s', '%s')" % (primary_key, uid_id)) +# session.execute("INSERT INTO fingerprint (fingerprint, uid) VALUES (:fingerprint, uid)", +# {'fingerprint': primary_key, 'uid': uid_id}) # Lets add user to the email-whitelist file if its configured. if Cnf.has_key("Dinstall::MailWhiteList") and Cnf["Dinstall::MailWhiteList"] != "": diff --git a/daklib/dbconn.py b/daklib/dbconn.py index 9e09bdb3..6e118427 100755 --- a/daklib/dbconn.py +++ b/daklib/dbconn.py @@ -314,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) @@ -328,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 @@ -412,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) @@ -426,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 @@ -459,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 """ @@ -1064,6 +1075,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()