Merge lp:~stefanor/ibid/sqlalchemy-370772 into lp:~ibid-core/ibid/old-trunk-pack-0.92

[Stefano Rivera]

[Stefano Rivera (stefanor)]

Happy reviewing, folks :P

This is one mother of a branch.

We still have the option of attaching identities and accounts to the event. However, I'm not doing that now.

[Stefano Rivera (stefanor)]

> We still have the option of attaching identities and accounts to the event.
> However, I'm not doing that now.

Maybe we don't. You can't reuse rolled back sessions...

[Stefano Rivera (stefanor)]

No reviews yet, so re-submitted to get new diff

[Stefano Rivera (stefanor)]

Note: This can't be merged until all DB-touching branches are in trunk and this has been updated to fix them too.

Also: There appears to be a bug in granting priviledges, but it'd help to have accounts-330942 merged to fix that.

[Michael Gorven (mgorven)]

+ self.log.exception(u"Exception occured in %s processor
of %s plugin", processor.__class__.__name__, processor.name)

Can you just change the log message so something like "Exception occured while
committing session after %s processor of %s plugin".

+ self[name] = scoped_session(sessionmaker(bind=engine))

Do all versions of SQLAlchemy default to using transactions and autoflush?

- session.flush()
         log.info(u"%s %s permission for account %s (%s) by account %s",
actions[action.lower()], name, account.id, account.username, event.account)

The account ID won't be available if autoflush isn't on.

There's a problem we didn't think of, which is that processors add responses
before knowing that their database changes succeeded. So the bot will still
respond positively if the commit() by the dispatcher failed. Maybe we do need
to commit() in the plugin itself.

I'd prefer the except block in Identify.identify() to only catch
IntegrityErrors.

 review needs_fixing

review: Needs Fixing

[Stefano Rivera (stefanor)]

> Can you just change the log message so something like "Exception occured while
> committing session after %s processor of %s plugin".

Agreed. I sort of skipped over that. r628

> Do all versions of SQLAlchemy default to using transactions and autoflush?

All supported versions. And not likely to change.

> The account ID won't be available if autoflush isn't on.

No, autoflush doesn't help, but yes we do need a manual flush. r629
Although logging factoid IDs is of arguable value.

> There's a problem we didn't think of, which is that processors add responses
> before knowing that their database changes succeeded. So the bot will still
> respond positively if the commit() by the dispatcher failed. Maybe we do need
> to commit() in the plugin itself.

Yes, that's certainly an issue. We even have the option of re-running failed
processors now (although we'd need to differentiate which are safe to re-run,
etc.)

> I'd prefer the except block in Identify.identify() to only catch
> IntegrityErrors.

Agreed. r631

The reason for that is SQLite can cause an OperationalError to be thrown if
the database is locked. The correct behaviour in that case is probably to sleep
and then try and commit again. (at least at the pysqlite level, that'd be the
right thing)

[Jonathan Hitchcock (vhata)]

review: Approve

[lp:~stefanor/ibid/sqlalchemy-370772]

633. By Stefano Rivera on 2009-05-04

Merge from trunk

[Michael Gorven (mgorven)]

This still allows positive acknowledgements to be returned even if the
commit() fails. If we need to flush() in order to get an ID for logging, why
don't we just commit() instead? As long as the dispatcher cleans up the
session when commit() fails, I don't see a problem.

[lp:~stefanor/ibid/sqlalchemy-370772]

634. By Stefano Rivera on 2009-05-05

Commit in plugins, to ensure that Ibid only confirms successful actions (rollback in dispatcher)

[Stefano Rivera (stefanor)]

r634

[Michael Gorven (mgorven)]

Why is the session deleted if an exception occurs? Is rolling back not
sufficient?

[Stefano Rivera (stefanor)]

> Why is the session deleted if an exception occurs? Is rolling back not
> sufficient?

Exactly, you can't operate on a rolled back sqlalchemy session.

[Michael Gorven (mgorven)]

> Exactly, you can't operate on a rolled back sqlalchemy session.

Um, I don't understand why that should be the case, but okay.

 review approve

review: Approve

=== modified file 'ibid/auth.py'
--- ibid/auth.py	2009-03-16 21:00:23 +0000
+++ ibid/auth.py	2009-05-02 22:05:13 +0000
@@ -23,11 +23,11 @@
         salt = ''.join([choice(chars) for i in xrange(8)])
     return unicode(salt + sha1(salt + password).hexdigest())
 
-def permission(name, account, source):
+def permission(name, account, source, session):
     if account:
-        session = ibid.databases.ibid()
-        permission = session.query(Permission).filter_by(account_id=account).filter_by(name=name).first()
-        session.close()
+        permission = session.query(Permission) \
+                .filter_by(account_id=account) \
+                .filter_by(name=name).first()
 
         if permission:
             return permission.value
@@ -95,7 +95,7 @@
         return False
 
     def authorise(self, event, name):
-        value = permission(name, event.account, event.source)
+        value = permission(name, event.account, event.source, event.session)
         self.log.info(u"Checking %s permission for %s/%s (%s): %s", name, event.account, event.identity, event.sender['connection'], value)
 
         if value == 'yes':
@@ -105,15 +105,17 @@
 
         return False
 
-    def implicit(self, event, credential = None):
+    def implicit(self, event, credential=None):
         return True
 
     def password(self, event, password):
         if password is None:
             return False
 
-        session = ibid.databases.ibid()
-        for credential in session.query(Credential).filter_by(method=u'password').filter_by(account_id=event.account).filter(or_(Credential.source == event.source, Credential.source == None)).all():
+        for credential in event.session.query(Credential) \
+                .filter_by(method=u'password') \
+                .filter_by(account_id=event.account) \
+                .filter(or_(Credential.source == event.source, Credential.source == None)).all():
             if hash(password, credential.credential) == credential.credential:
                 return True
 
 
=== modified file 'ibid/core.py'
--- ibid/core.py	2009-05-02 15:14:56 +0000
+++ ibid/core.py	2009-05-03 16:37:03 +0000
@@ -7,6 +7,7 @@
 from twisted.python.modules import getModule
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker, scoped_session
+from sqlalchemy.exceptions import IntegrityError
 
 import ibid
 import auth
@@ -21,9 +22,25 @@
             try:
                 processor.process(event)
             except Exception:
-                self.log.exception(u"Exception occured in %s processor of %s plugin", processor.__class__.__name__, processor.name)
+                self.log.exception(u"Exception occured in %s processor of %s plugin",
+                        processor.__class__.__name__, processor.name)
                 event.complain = u'exception'
 
+            if 'session' in event and (event.session.dirty or event.session.deleted):
+                try:
+                    event.session.commit()
+                except IntegrityError:
+                    self.log.exception(u"Exception occured committing session from the %s processor of %s plugin",
+                            processor.__class__.__name__, processor.name)
+                    event.complain = u'exception'
+                    event.session.rollback()
+                    event.session.close()
+                    del event['session']
+
+        if 'session' in event:
+            event.session.close()
+            del event['session']
+
         log_level = logging.DEBUG
         if event.type == u'clock' and not event.processed:
             log_level -= 5
@@ -263,7 +280,7 @@
 
                 engine.dialect.use_ansiquotes = True
 
-        self[name] = scoped_session(sessionmaker(bind=engine, transactional=False, autoflush=True))
+        self[name] = scoped_session(sessionmaker(bind=engine))
 
         self.log.info(u"Loaded %s database", name)
 
 
=== modified file 'ibid/event.py'
--- ibid/event.py	2009-05-01 11:14:06 +0000
+++ ibid/event.py	2009-05-02 19:29:44 +0000
@@ -1,3 +1,4 @@
+import ibid
 
 class Event(dict):
 
@@ -9,6 +10,8 @@
         self.processed = False
 
     def __getattr__(self, name):
+        if name == 'session' and 'session' not in self:
+            self['session'] = ibid.databases.ibid()
         return self[name]
 
     def __setattr__(self, name, value):
 
=== modified file 'ibid/models.py'
--- ibid/models.py	2009-04-21 20:09:06 +0000
+++ ibid/models.py	2009-05-02 19:29:44 +0000
@@ -61,7 +61,6 @@
             metadata.tables[dependancy].versioned_schema.upgrade_schema(sessionmaker)
 
         self.upgrade_session = session = sessionmaker()
-        trans = session.begin()
 
         schema = session.query(Schema).filter(Schema.table==unicode(self.table.name)).first()
 
@@ -79,8 +78,7 @@
                 for version in range(schema.version + 1, self.version + 1):
                     log.info(u"Upgrading table %s to version %i", self.table.name, version)
 
-                    trans.commit()
-                    trans = session.begin()
+                    session.commit()
 
                     getattr(self, 'upgrade_%i_to_%i' % (version - 1, version))()
 
@@ -88,10 +86,10 @@
                     session.save_or_update(schema)
                 del self.upgrade_reflected_model
 
-            trans.commit()
+            session.commit()
 
         except:
-            trans.rollback()
+            session.rollback()
             raise
 
         session.close()
@@ -236,7 +234,7 @@
                 schema = Schema(unicode(self.table.name), self.version)
                 session.save_or_update(schema)
 
-            session.flush()
+            session.commit()
             session.close()
 
     __table__.versioned_schema = SchemaSchema(__table__, 1)
 
=== modified file 'ibid/plugins/auth.py'
--- ibid/plugins/auth.py	2009-05-01 12:22:37 +0000
+++ ibid/plugins/auth.py	2009-05-03 16:25:57 +0000
@@ -5,7 +5,7 @@
 import ibid
 from ibid.plugins import Processor, match, auth_responses, authorise
 from ibid.models import Credential, Permission, Account
-from ibid.auth import hash, permission
+from ibid.auth import hash
 
 help = {}
 
@@ -21,7 +21,6 @@
     @match(r'^authenticate\s+(.+?)(?:\s+on\s+(.+))?\s+using\s+(\S+)\s+(.+)$')
     def handler(self, event, user, source, method, credential):
 
-        session = ibid.databases.ibid()
         if user.lower() == 'me':
             if not event.account:
                 event.addresponse(u"I don't know who you are")
@@ -29,15 +28,14 @@
             if not ibid.auth.authenticate(event):
                 event.complain = 'notauthed'
                 return
-            account = session.query(Account).filter_by(id=event.account).first()
+            account = event.session.query(Account).filter_by(id=event.account).first()
 
         else:
             if not auth_responses(event, 'admin'):
                 return
-            account = session.query(Account).filter_by(username=user).first()
+            account = event.session.query(Account).filter_by(username=user).first()
             if not account:
                 event.addresponse(u"I don't know who %s is", user)
-                session.close()
                 return
 
         if source:
@@ -49,14 +47,15 @@
         if method.lower() == 'password':
             password = hash(credential)
             event.message['clean'] = event.message['clean'][:-len(credential)] + password
-            event.message['raw'] = event.message['raw'][:event.message['raw'].rfind(credential)] + password + event.message['raw'][event.message['raw'].rfind(credential)+len(credential):]
+            event.message['raw'] = event.message['raw'][:event.message['raw'].rfind(credential)] \
+                    + password + event.message['raw'][event.message['raw'].rfind(credential)+len(credential):]
             credential = password
 
         credential = Credential(method, credential, source, account.id)
-        session.save_or_update(credential)
-        session.flush()
-        log.info(u"Added %s credential %s for account %s (%s) on %s by account %s", method, credential.credential, account.id, account.username, source, event.account)
-        session.close()
+        event.session.save_or_update(credential)
+        event.session.flush()
+        log.info(u"Added %s credential %s for account %s (%s) on %s by account %s",
+                method, credential.credential, account.id, account.username, source, event.account)
 
         event.addresponse(True)
 
@@ -73,17 +72,17 @@
     @authorise
     def grant(self, event, action, name, username, auth):
 
-        session = ibid.databases.ibid()
-        account = session.query(Account).filter_by(username=username).first()
+        account = event.session.query(Account).filter_by(username=username).first()
         if not account:
             event.addresponse(u"I don't know who %s is", username)
-            session.close()
             return
 
-        permission = session.query(Permission).filter_by(account_id=account.id).filter(func.lower(Permission.name)==name.lower()).first()
+        permission = event.session.query(Permission) \
+                .filter_by(account_id=account.id) \
+                .filter(func.lower(Permission.name) == name.lower()).first()
         if action.lower() == 'remove':
             if permission:
-                session.delete(permission)
+                event.session.delete(permission)
             else:
                 event.addresponse(u"%s doesn't have that permission anyway", username)
                 return
@@ -108,26 +107,25 @@
                 return
 
             permission.value = value
-            session.save_or_update(permission)
+            event.session.save_or_update(permission)
 
-        session.flush()
-        log.info(u"%s %s permission for account %s (%s) by account %s", actions[action.lower()], name, account.id, account.username, event.account)
-        session.close()
+        event.session.flush()
+        log.info(u"%s %s permission for account %s (%s) by account %s",
+                actions[action.lower()], name, account.id, account.username, event.account)
 
         event.addresponse(True)
 
     @match(r'^permissions(?:\s+for\s+(\S+))?$')
     def list(self, event, username):
-        session = ibid.databases.ibid()
         if not username:
             if not event.account:
                 event.addresponse(u"I don't know who you are")
                 return
-            account = session.query(Account).filter_by(id=event.account).first()
+            account = event.session.query(Account).filter_by(id=event.account).first()
         else:
             if not auth_responses(event, u'accounts'):
                 return
-            account = session.query(Account).filter_by(username=username).first()
+            account = event.session.query(Account).filter_by(username=username).first()
             if not account:
                 event.addresponse(u"I don't know who %s is", username)
                 return
 
=== modified file 'ibid/plugins/factoid.py'
--- ibid/plugins/factoid.py	2009-05-01 12:17:57 +0000
+++ ibid/plugins/factoid.py	2009-05-03 16:33:10 +0000
@@ -6,7 +6,6 @@
 from sqlalchemy.orm import relation, eagerload
 from sqlalchemy.sql import func
 
-import ibid
 from ibid.plugins import Processor, match, handler, authorise, auth_responses, RPC
 from ibid.config import Option, IntOption
 from ibid.plugins.identity import get_identities
@@ -160,9 +159,7 @@
 
     @match(r'^literal\s+(.+?)(?:\s+#(\d+)|\s+(?:/(.+?)/(r?)))?$')
     def literal(self, event, name, number, pattern, is_regex):
-        session = ibid.databases.ibid()
-        factoids = get_factoid(session, name, number, pattern, is_regex, literal=True)
-        session.close()
+        factoids = get_factoid(event.session, name, number, pattern, is_regex, literal=True)
         number = number and int(number) or 0
         if factoids:
             event.addresponse(u', '.join(u'%i: %s'
@@ -179,12 +176,11 @@
     @match(r'^forget\s+(.+?)(?:\s+#(\d+)|\s+(?:/(.+?)/(r?)))?$')
     @authorise
     def forget(self, event, name, number, pattern, is_regex):
-        session = ibid.databases.ibid()
-        factoids = get_factoid(session, name, number, pattern, is_regex, all=True)
+        factoids = get_factoid(event.session, name, number, pattern, is_regex, all=True)
         if factoids:
             factoidadmin = auth_responses(event, u'factoidadmin')
-            identities = get_identities(event, session)
-            factoid = session.query(Factoid).get(factoids[0][0].id)
+            identities = get_identities(event)
+            factoid = event.session.query(Factoid).get(factoids[0][0].id)
 
             if (number or pattern):
                 if len(factoids) > 1:
@@ -194,30 +190,28 @@
                 if factoids[0][2].identity_id not in identities and not factoidadmin:
                     return
 
-                if session.query(FactoidValue).filter_by(factoid_id=factoid.id).count() == 1:
+                if event.session.query(FactoidValue).filter_by(factoid_id=factoid.id).count() == 1:
                     if len(filter(lambda x: x.identity_id not in identities, factoid.names)) > 0 and not factoidadmin:
                         return
                     log.info(u"Deleting factoid %s (%s) by %s/%s (%s)", factoid.id, name, event.account, event.identity, event.sender['connection'])
-                    session.delete(factoid)
+                    event.session.delete(factoid)
                 else:
                     log.info(u"Deleting value %s of factoid %s (%s) by %s/%s (%s)", factoids[0][2].id, factoid.id, factoids[0][2].value, event.account, event.identity, event.sender['connection'])
-                    session.delete(factoids[0][2])
+                    event.session.delete(factoids[0][2])
 
             else:
                 if factoids[0][1].identity_id not in identities and not factoidadmin:
                     return
 
-                if session.query(FactoidName).filter_by(factoid_id=factoid.id).count() == 1:
+                if event.session.query(FactoidName).filter_by(factoid_id=factoid.id).count() == 1:
                     if len(filter(lambda x: x.identity_id not in identities, factoid.values)) > 0 and not factoidadmin:
                         return
                     log.info(u"Deleting factoid %s (%s) by %s/%s (%s)", factoid.id, name, event.account, event.identity, event.sender['connection'])
-                    session.delete(factoid)
+                    event.session.delete(factoid)
                 else:
                     log.info(u"Deleting name %s of factoid %s (%s) by %s/%s (%s)", factoids[0][1].id, factoid.id, factoids[0][1].name, event.account, event.identity, event.sender['connection'])
-                    session.delete(factoids[0][1])
+                    event.session.delete(factoids[0][1])
 
-            session.flush()
-            session.close()
             event.addresponse(True)
         else:
             event.addresponse(u"I didn't know about %s anyway", name)
@@ -230,15 +224,12 @@
             event.addresponse(u"That makes no sense, they *are* the same")
             return
 
-        session = ibid.databases.ibid()
-        factoid = session.query(Factoid).join(Factoid.names)\
+        factoid = event.session.query(Factoid).join(Factoid.names)\
                 .filter(func.lower(FactoidName.name)==escape_name(source).lower()).first()
         if factoid:
             name = FactoidName(escape_name(unicode(target)), event.identity)
             factoid.names.append(name)
-            session.save_or_update(factoid)
-            session.flush()
-            session.close()
+            event.session.save_or_update(factoid)
             event.addresponse(True)
             log.info(u"Added name '%s' to factoid %s by %s/%s (%s)", name.name, factoid.id, event.account, event.identity, event.sender['connection'])
         else:
@@ -266,8 +257,7 @@
             pattern = m.group(1)
             is_regex = bool(m.group(2))
 
-        session = ibid.databases.ibid()
-        query = session.query(Factoid)\
+        query = event.session.query(Factoid)\
                 .join(Factoid.names).add_entity(FactoidName)\
                 .join(Factoid.values)
 
@@ -320,9 +310,7 @@
             event.addresponse(response)
 
     def remote_get(self, name, number=None, pattern=None, is_regex=None, event={}):
-        session = ibid.databases.ibid()
-        factoid = get_factoid(session, name, number, pattern, is_regex)
-        session.close()
+        factoid = get_factoid(event.session, name, number, pattern, is_regex)
 
         if factoid:
             (factoid, fname, fvalue) = factoid
@@ -377,17 +365,15 @@
     def set_factoid(self, event, correction, name, verb1, verb2, addition, value):
         verb = verb1 and verb1 or verb2
 
-        session = ibid.databases.ibid()
-        factoid = session.query(Factoid).join(Factoid.names)\
+        factoid = event.session.query(Factoid).join(Factoid.names)\
                 .filter(func.lower(FactoidName.name)==escape_name(name).lower()).first()
         if factoid:
             if correction:
-                identities = get_identities(event, session)
+                identities = get_identities(event)
                 if not auth_responses(event, u'factoidadmin') and len(filter(lambda x: x.identity_id not in identities, factoid.values)) > 0:
                     return
                 for fvalue in factoid.values:
-                    session.delete(fvalue)
-                session.flush()
+                    event.session.delete(fvalue)
             elif not addition:
                 event.addresponse(u'I already know stuff about %s', name)
                 return
@@ -395,6 +381,7 @@
             factoid = Factoid()
             fname = FactoidName(escape_name(unicode(name)), event.identity)
             factoid.names.append(fname)
+            event.session.flush()
             log.info(u"Created factoid %s with name '%s' by %s", factoid.id, fname.name, event.identity)
 
         if not reply_re.match(value) and not action_re.match(value):
@@ -402,9 +389,7 @@
         fvalue = FactoidValue(unicode(value), event.identity)
         factoid.values.append(fvalue)
         log.info(u"Added value '%s' to factoid %s by %s/%s (%s)", fvalue.value, factoid.id, event.account, event.identity, event.sender['connection'])
-        session.save_or_update(factoid)
-        session.flush()
-        session.close()
+        event.session.save_or_update(factoid)
         event.addresponse(True)
 
 class Modify(Processor):
@@ -419,8 +404,7 @@
     @match(r'^(.+?)(?:\s+#(\d+)|\s+/(.+?)/(r?))?\s*\+=\s?(.+)$')
     @authorise
     def append(self, event, name, number, pattern, is_regex, suffix):
-        session = ibid.databases.ibid()
-        factoids = get_factoid(session, name, number, pattern, is_regex, all=True)
+        factoids = get_factoid(event.session, name, number, pattern, is_regex, all=True)
         if len(factoids) == 0:
             if pattern:
                 event.addresponse(u"I don't know about any %(name)s matching %(pattern)s", {
@@ -433,7 +417,7 @@
             event.addresponse(u"Pattern matches multiple factoids, please be more specific")
         else:
             factoidadmin = auth_responses(event, u'factoidadmin')
-            identities = get_identities(event, session)
+            identities = get_identities(event)
             factoid = factoids[0]
 
             if factoid[2].identity_id not in identities and not factoidadmin:
@@ -443,16 +427,13 @@
                     suffix, factoid[2].id, factoid[0].id, factoid[2].value, event.account, event.identity, event.sender['connection'])
             factoid[2].value += suffix
 
-            session.save_or_update(factoid[2])
-            session.flush()
-            session.close()
+            event.session.save_or_update(factoid[2])
             event.addresponse(True)
 
     @match(r'^(.+?)(?:\s+#(\d+)|\s+/(.+?)/(r?))?\s*(?:~=|=~)\s*([sy](?P<sep>.).+(?P=sep).*(?P=sep)[gir]*)$')
     @authorise
     def modify(self, event, name, number, pattern, is_regex, operation, separator):
-        session = ibid.databases.ibid()
-        factoids = get_factoid(session, name, number, pattern, is_regex, all=True)
+        factoids = get_factoid(event.session, name, number, pattern, is_regex, all=True)
         if len(factoids) == 0:
             if pattern:
                 event.addresponse(u"I don't know about any %(name)s matching %(pattern)s", {
@@ -465,7 +446,7 @@
             event.addresponse(u"Pattern matches multiple factoids, please be more specific")
         else:
             factoidadmin = auth_responses(event, u'factoidadmin')
-            identities = get_identities(event, session)
+            identities = get_identities(event)
             factoid = factoids[0]
 
             if factoid[2].identity_id not in identities and not factoidadmin:
@@ -537,9 +518,7 @@
             log.info(u"Applying '%s' to value %s of factoid %s (%s) by %s/%s (%s)",
                     operation, factoid[2].id, factoid[0].id, oldvalue, event.account, event.identity, event.sender['connection'])
 
-            session.save_or_update(factoid[2])
-            session.flush()
-            session.close()
+            event.session.save_or_update(factoid[2])
             event.addresponse(True)
 
 # vi: set et sta sw=4 ts=4:
 
=== modified file 'ibid/plugins/feeds.py'
--- ibid/plugins/feeds.py	2009-05-01 12:17:57 +0000
+++ ibid/plugins/feeds.py	2009-05-03 16:33:10 +0000
@@ -10,7 +10,6 @@
 import feedparser
 from html2text import html2text_file
 
-import ibid
 from ibid.plugins import Processor, match, authorise
 from ibid.models import Base, VersionedSchema
 from ibid.utils import cacheable_download, get_html_parse_tree
@@ -56,8 +55,8 @@
     @match(r'^add\s+feed\s+(.+?)\s+as\s+(.+?)$')
     @authorise
     def add(self, event, url, name):
-        session = ibid.databases.ibid()
-        feed = session.query(Feed).filter(func.lower(Feed.name)==name.lower()).first()
+        feed = event.session.query(Feed) \
+                .filter(func.lower(Feed.name) == name.lower()).first()
 
         if feed:
             event.addresponse(u"I already have the %s feed", name)
@@ -85,15 +84,13 @@
             return
 
         feed = Feed(unicode(name), unicode(url), event.identity)
-        session.save(feed)
-        session.flush()
+        event.session.save(feed)
         event.addresponse(True)
         log.info(u"Added feed '%s' by %s/%s (%s): %s (Found %s entries)", name, event.account, event.identity, event.sender['connection'], url, len(feed.entries))
 
     @match(r'^(?:list\s+)?feeds$')
     def list(self, event):
-        session = ibid.databases.ibid()
-        feeds = session.query(Feed).all()
+        feeds = event.session.query(Feed).all()
         if feeds:
             event.addresponse(u'I know about: %s', u', '.join(sorted([feed.name for feed in feeds])))
         else:
@@ -102,19 +99,16 @@
     @match(r'^remove\s+(.+?)\s+feed$')
     @authorise
     def remove(self, event, name):
-        session = ibid.databases.ibid()
-        feed = session.query(Feed).filter(func.lower(Feed.name)==name.lower()).first()
+        feed = event.session.query(Feed) \
+                .filter(func.lower(Feed.name) == name.lower()).first()
 
         if not feed:
             event.addresponse(u"I don't have the %s feed anyway", name)
         else:
-            session.delete(feed)
+            event.session.delete(feed)
             log.info(u"Deleted feed '%s' by %s/%s (%s): %s", name, event.account, event.identity, event.sender['connection'], feed.url)
-            session.flush()
             event.addresponse(True)
 
-        session.close()
-
 class Retrieve(Processor):
     u"""latest [ <count> ] articles from <name> [ starting at <number> ]
     article ( <number> | /<pattern>/ ) from <name>"""
@@ -125,9 +119,8 @@
         number = number and int(number) or 10
         start = start and int(start) or 0
 
-        session = ibid.databases.ibid()
-        feed = session.query(Feed).filter(func.lower(Feed.name)==name.lower()).first()
-        session.close()
+        feed = event.session.query(Feed) \
+                .filter(func.lower(Feed.name) == name.lower()).first()
 
         if not feed:
             event.addresponse(u"I don't know about the %s feed", name)
@@ -144,9 +137,8 @@
 
     @match(r'^article\s+(?:(\d+)|/(.+?)/)\s+from\s+(.+?)$')
     def article(self, event, number, pattern, name):
-        session = ibid.databases.ibid()
-        feed = session.query(Feed).filter(func.lower(Feed.name)==name.lower()).first()
-        session.close()
+        feed = event.session.query(Feed) \
+                .filter(func.lower(Feed.name) == name.lower()).first()
 
         if not feed:
             event.addresponse(u"I don't know about the %s feed", name)
 
=== modified file 'ibid/plugins/identity.py'
--- ibid/plugins/identity.py	2009-04-27 00:50:19 +0000
+++ ibid/plugins/identity.py	2009-05-03 16:37:03 +0000
@@ -15,43 +15,45 @@
 
 log = logging.getLogger('plugins.identity')
 
-help['accounts'] = u'An account represents a person. An account has one or more identities, which is a user on a specific source.'
+help['accounts'] = u'An account represents a person. ' \
+        'An account has one or more identities, which is a user on a specific source.'
 class Accounts(Processor):
     u"""create account <name>"""
     feature = 'accounts'
 
     @match(r'^create\s+account\s+(.+)$')
     def account(self, event, username):
-        session = ibid.databases.ibid()
         admin = False
 
         if event.account:
             if ibid.auth.authenticate(event) and ibid.auth.authorise(event, 'accounts'):
                 admin = True
             else:
-                account = session.query(Account).filter_by(id=event.account).first()
+                account = event.session.query(Account).filter_by(id=event.account).first()
                 event.addresponse(u'You already have an account called "%s"', account.username)
                 return
 
-        account = session.query(Account).filter_by(username=username).first()
+        account = event.session.query(Account).filter_by(username=username).first()
         if account:
-            event.addresponse(u'There is already an account called "%s". Please choose a different name', account.username)
+            event.addresponse(u'There is already an account called "%s". ' \
+                    'Please choose a different name', account.username)
             return
 
         account = Account(username)
-        session.save_or_update(account)
-        session.flush()
-        log.info(u"Created account %s (%s) by %s/%s (%s)", account.id, account.username, event.account, event.identity, event.sender['connection'])
+        event.session.save_or_update(account)
+        event.session.flush()
+        log.info(u"Created account %s (%s) by %s/%s (%s)",
+                account.id, account.username, event.account, event.identity, event.sender['connection'])
 
         if not admin:
-            identity = session.query(Identity).filter_by(id=event.identity).first()
+            identity = event.session.query(Identity).filter_by(id=event.identity).first()
             identity.account_id = account.id
             session.save_or_update(identity)
-            session.flush()
-            log.info(u"Attached identity %s (%s on %s) to account %s (%s)", identity.id, identity.identity, identity.source, account.id, account.username)
+            event.session.flush()
+            log.info(u"Attached identity %s (%s on %s) to account %s (%s)",
+                    identity.id, identity.identity, identity.source, account.id, account.username)
 
         identify_cache.clear()
-        session.close()
         event.addresponse(True)
 
 chars = string.letters + string.digits
@@ -68,44 +70,54 @@
 
     @match(r'^(I|.+?)\s+(?:is|am)\s+(.+)\s+on\s+(.+)$')
     def identity(self, event, username, identity, source):
-        session = ibid.databases.ibid()
         admin = False
         identity = identity.replace(' ', '')
 
         if username.upper() == 'I':
             if event.account:
-                account = session.query(Account).filter_by(id=event.account).first()
+                account = event.session.query(Account).filter_by(id=event.account).first()
             else:
                 username = event.sender['id']
-                account = session.query(Account).filter_by(username=username).first()
+
+                account = event.session.query(Account).filter_by(username=username).first()
+
                 if account:
                     event.addresponse(u'I tried to create the account %s for you, but it already exists. '
                         u"Please use 'create account <name>'", username)
                     return
+
                 account = Account(username)
-                session.save_or_update(account)
-                session.flush()
-                currentidentity = session.query(Identity).filter_by(id=event.identity).first()
+                event.session.save_or_update(account)
+
+                currentidentity = event.session.query(Identity).filter_by(id=event.identity).first()
                 currentidentity.account_id = account.id
-                session.save_or_update(currentidentity)
-                session.flush()
+                event.session.save_or_update(currentidentity)
+
                 identify_cache.clear()
+
                 event.addresponse(u"I've created the account %s for you", username)
-                log.info(u"Created account %s (%s) by %s/%s (%s)", account.id, account.username, event.account, event.identity, event.sender['connection'])
-                log.info(u"Attached identity %s (%s on %s) to account %s (%s)", currentidentity.id, currentidentity.identity, currentidentity.source, account.id, account.username)
+
+                event.session.flush()
+                log.info(u"Created account %s (%s) by %s/%s (%s)",
+                        account.id, account.username, event.account, event.identity, event.sender['connection'])
+                log.info(u"Attached identity %s (%s on %s) to account %s (%s)",
+                        currentidentity.id, currentidentity.identity, currentidentity.source, account.id, account.username)
 
         else:
             if not auth_responses(event, 'accounts'):
                 return
             admin = True
-            account = session.query(Account).filter_by(username=username).first()
+            account = event.session.query(Account).filter_by(username=username).first()
             if not account:
                 event.addresponse(u"I don't know who %s is", username)
                 return
 
-        ident = session.query(Identity).filter(func.lower(Identity.identity)==identity.lower()).filter(func.lower(Identity.source)==source.lower()).first()
+        ident = event.session.query(Identity) \
+                .filter(func.lower(Identity.identity) == identity.lower()) \
+                .filter(func.lower(Identity.source) == source.lower()).first()
         if ident and ident.account:
-            event.addresponse(u'This identity is already attached to account %s', ident.account.username)
+            event.addresponse(u'This identity is already attached to account %s',
+                    ident.account.username)
             return
 
         if source not in ibid.sources:
@@ -121,22 +133,26 @@
             if event.public:
                 response['target'] = event.sender['id']
             event.addresponse(response)
-            log.info(u"Sent token %s to %s/%s (%s)", token, event.account, event.identity, event.sender['connection'])
+            log.info(u"Sent token %s to %s/%s (%s)",
+                    token, event.account, event.identity, event.sender['connection'])
 
         else:
             if not ident:
                 ident = Identity(source, identity)
             ident.account_id = account.id
-            session.save_or_update(ident)
-            session.flush()
+            event.session.save_or_update(ident)
+
             identify_cache.clear()
             event.addresponse(True)
-            log.info(u"Attached identity %s (%s on %s) to account %s (%s) by %s/%s (%s)", ident.id, ident.identity, ident.source, account.id, account.username, event.account, event.identity, event.sender['connection'])
+
+            event.session.flush()
+            log.info(u"Attached identity %s (%s on %s) to account %s (%s) by %s/%s (%s)",
+                    ident.id, ident.identity, ident.source, account.id, account.username,
+                    event.account, event.identity, event.sender['connection'])
 
     @match(r'^(\S{16})$')
     def token(self, event, token):
         if token in self.tokens:
-            session = ibid.databases.ibid()
             (account_id, user, source) = self.tokens[token]
             if event.source.lower() != source.lower() or event.sender['id'].lower() != user.lower():
                 event.addresponse(u'You need to send me this token from %(name)s on %(source)s', {
@@ -145,45 +161,49 @@
                 })
                 return
 
-            identity = session.query(Identity).filter(func.lower(Identity.identity)==user.lower()).filter(func.lower(Identity.source)==source.lower()).first()
+            identity = event.session.query(Identity) \
+                    .filter(func.lower(Identity.identity) == user.lower()) \
+                    .filter(func.lower(Identity.source) == source.lower()).first()
             if not identity:
                 identity = Identity(source, user)
             identity.account_id = account_id
-            session.save_or_update(identity)
-            session.flush()
-            session.close()
+            event.session.save_or_update(identity)
             identify_cache.clear()
 
             del self.tokens[token]
             event.addresponse(u'Identity added')
-            log.info(u"Attached identity %s (%s on %s) to account %s by %s/%s (%s) with token %s", identity.id, identity.identity, identity.source, account_id, event.account, event.identity, event.sender['connection'], token)
+
+            event.session.flush()
+            log.info(u"Attached identity %s (%s on %s) to account %s by %s/%s (%s) with token %s",
+                    identity.id, identity.identity, identity.source, account_id, event.account,
+                    event.identity, event.sender['connection'], token)
 
     @match(r'^remove\s+identity\s+(.+?)\s+on\s+(\S+)(?:\s+from\s+(\S+))?$')
     def remove(self, event, user, source, username):
-        session = ibid.databases.ibid()
-
         if not username:
-            account = session.query(Account).get(event.account)
+            account = event.session.query(Account).get(event.account)
         else:
             if not auth_responses(event, 'accounts'):
                 return
-            account = session.query(Account).filter_by(username=username).first()
+            account = event.session.query(Account).filter_by(username=username).first()
             if not account:
                 event.addresponse(u"I don't know who %s is", username)
                 return
 
-        identity = session.query(Identity).filter_by(account_id=account.id).filter(func.lower(Identity.identity)==user.lower()).filter(func.lower(Identity.source)==source.lower()).first()
+        identity = event.session.query(Identity) \
+                .filter_by(account_id=account.id) \
+                .filter(func.lower(Identity.identity) == user.lower()) \
+                .filter(func.lower(Identity.source) == source.lower()).first()
         if not identity:
             event.addresponse(u"I don't know about that identity")
         else:
             identity.account_id = None
-            session.save_or_update(identity)
-            session.flush()
+            event.session.save_or_update(identity)
             identify_cache.clear()
             event.addresponse(True)
-            log.info(u"Removed identity %s (%s on %s) from account %s (%s) by %s/%s (%s)", identity.id, identity.identity, identity.source, account.id, account.username, event.account, event.identity, event.sender['connection'])
-
-        session.close()
+            log.info(u"Removed identity %s (%s on %s) from account %s (%s) by %s/%s (%s)",
+                    identity.id, identity.identity, identity.source, account.id,
+                    account.username, event.account, event.identity, event.sender['connection'])
 
 class Attributes(Processor):
     u"""set (my|<account>) <name> to <value>"""
@@ -191,13 +211,12 @@
 
     @match(r"^set\s+(my|.+?)(?:\'s)?\s+(.+)\s+to\s+(.+)$")
     def attribute(self, event, username, name, value):
-        session = ibid.databases.ibid()
 
         if username.lower() == 'my':
             if not event.account:
                 event.addresponse(u"I don't know who you are")
                 return
-            account = session.query(Account).filter_by(id=event.account).first()
+            account = event.session.query(Account).filter_by(id=event.account).first()
             if not account:
                 event.addresponse(u"%s doesn't exist. Please use 'add account' first", username)
                 return
@@ -205,17 +224,17 @@
         else:
             if not auth_responses(event, 'accounts'):
                 return
-            account = session.query(Account).filter_by(username=username).first()
+            account = event.session.query(Account).filter_by(username=username).first()
             if not account:
                 event.addresponse(u"I don't know who %s is", username)
                 return
 
         account.attributes.append(Attribute(name, value))
-        session.save_or_update(account)
-        session.flush()
-        session.close()
+        event.session.save_or_update(account)
         event.addresponse(True)
-        log.info(u"Added attribute '%s' = '%s' to account %s (%s) by %s/%s (%s)", name, value, account.id, account.username, event.account, event.identity, event.sender['connection'])
+        log.info(u"Added attribute '%s' = '%s' to account %s (%s) by %s/%s (%s)",
+                name, value, account.id, account.username, event.account,
+                event.identity, event.sender['connection'])
 
 class Describe(Processor):
     u"""who (am I|is <username>)"""
@@ -223,19 +242,18 @@
 
     @match(r'^who\s+(?:is|am)\s+(I|.+?)$')
     def describe(self, event, username):
-        session = ibid.databases.ibid()
         if username.upper() == 'I':
             if not event.account:
-                identity = session.query(Identity).get(event.identity)
+                identity = event.session.query(Identity).get(event.identity)
                 event.addresponse(u"%(name)s on %(source)s", {
                     'name': identity.identity,
                     'source': identity.source,
                 })
                 return
-            account = session.query(Account).get(event.account)
+            account = event.session.query(Account).get(event.account)
 
         else:
-            account = session.query(Account).filter_by(username=username).first()
+            account = event.session.query(Account).filter_by(username=username).first()
             if not account:
                 event.addresponse(u"I don't know who %s is", username)
                 return
@@ -244,7 +262,6 @@
             'accountname': account.username,
             'identities': u', '.join(u'%s on %s' % (identity.identity, identity.source) for identity in account.identities),
         })
-        session.close()
 
 class Identify(Processor):
 
@@ -256,25 +273,26 @@
                 (event.identity, event.account) = identify_cache[(event.source, event.sender['connection'])]
                 return
 
-            session = ibid.databases.ibid()
-            identity = session.query(Identity)\
-                    .options(eagerload('account'))\
-                    .filter(func.lower(Identity.source) == event.source.lower())\
-                    .filter(func.lower(Identity.identity) == event.sender['id'].lower())\
+            identity = event.session.query(Identity) \
+                    .options(eagerload('account')) \
+                    .filter(func.lower(Identity.source) == event.source.lower()) \
+                    .filter(func.lower(Identity.identity) == event.sender['id'].lower()) \
                     .first()
             if not identity:
                 identity = Identity(event.source, event.sender['id'])
-                session.save_or_update(identity)
+                event.session.save_or_update(identity)
                 try:
-                    session.flush()
+                    event.session.commit()
                     log.info(u'Created identity %s for %s on %s', identity.id, identity.identity, identity.source)
                 except IntegrityError:
-                    session.expunge(identity)
+                    event.session.rollback()
+                    event.session.close()
+                    del event['session']
                     log.debug(u'Race encountered creating identity for %s on %s', event.sender['id'], event.source)
-                    identity = session.query(Identity)\
-                            .options(eagerload('account'))\
-                            .filter(func.lower(Identity.source) == event.source.lower())\
-                            .filter(func.lower(Identity.identity) == event.sender['id'].lower())\
+                    identity = event.session.query(Identity) \
+                            .options(eagerload('account')) \
+                            .filter(func.lower(Identity.source) == event.source.lower()) \
+                            .filter(func.lower(Identity.identity) == event.sender['id'].lower()) \
                             .one()
 
             event.identity = identity.id
@@ -284,29 +302,9 @@
                 event.account = None
             identify_cache[(event.source, event.sender['connection'])] = (event.identity, event.account)
 
-            session.close()
-
-def identify(source, user):
-
-    session = ibid.databases.ibid()
-
-    identity = session.query(Identity).filter(func.lower(Identity.source)==source.lower()).filter(func.lower(Identity.identity)==user.lower()).first()
-    account = session.query(Account).filter_by(username=user).first()
-
-    if not account and not identity:
-        return None
-    if not account:
-        return identity
-    if not identity or identity in account.identities:
-        return account
-    return (account, identity)
-
-def get_identities(event, session=None):
-    if not session:
-        session = ibid.databases.ibid()
-
+def get_identities(event):
     if event.account:
-        account = session.query(Account).get(event.account)
+        account = event.session.query(Account).get(event.account)
         return [identity.id for identity in account.identities]
     else:
         return (event.identity,)
 
=== modified file 'ibid/plugins/karma.py'
--- ibid/plugins/karma.py	2009-05-01 12:17:57 +0000
+++ ibid/plugins/karma.py	2009-05-03 16:33:10 +0000
@@ -4,7 +4,6 @@
 from sqlalchemy import Column, Integer, Unicode, DateTime, Table
 from sqlalchemy.sql import func
 
-import ibid
 from ibid.plugins import Processor, match, handler, authorise
 from ibid.config import Option, BoolOption, IntOption
 from ibid.models import Base, VersionedSchema
@@ -59,8 +58,8 @@
         if subject.lower() in self.ignore:
             return
 
-        session = ibid.databases.ibid()
-        karma = session.query(Karma).filter(func.lower(Karma.subject)==subject.lower()).first()
+        karma = event.session.query(Karma) \
+                .filter(func.lower(Karma.subject) == subject.lower()).first()
         if not karma:
             karma = Karma(subject)
 
@@ -82,14 +81,12 @@
         if karma.value == 0 and karma.changes <= self.importance:
             change = u'Forgotten (unimportant)'
 
-            session.delete(karma)
+            event.session.delete(karma)
         else:
-            session.save_or_update(karma)
-
-        session.flush()
-        session.close()
-
-        log.info(u"%s karma for '%s' by %s/%s (%s) because: %s", change, subject, event.account, event.identity, event.sender['connection'], reason)
+            event.session.save_or_update(karma)
+
+        log.info(u"%s karma for '%s' by %s/%s (%s) because: %s",
+                change, subject, event.account, event.identity, event.sender['connection'], reason)
 
         if self.reply:
             event.addresponse(True)
@@ -103,8 +100,8 @@
 
     @match(r'^karma\s+(?:for\s+)?(.+)$')
     def handle_karma(self, event, subject):
-        session = ibid.databases.ibid()
-        karma = session.query(Karma).filter(func.lower(Karma.subject)==subject.lower()).first()
+        karma = event.session.query(Karma) \
+                .filter(func.lower(Karma.subject) == subject.lower()).first()
         if not karma:
             event.addresponse(u'nobody cares, dude')
         elif karma.value == 0:
@@ -114,17 +111,16 @@
                 'subject': subject,
                 'value': karma.value,
             })
-        session.close()
 
     @match(r'^(reverse\s+)?karmaladder$')
     def ladder(self, event, reverse):
-        session = ibid.databases.ibid()
-        karmas = session.query(Karma).order_by(reverse and Karma.value.asc() or Karma.value.desc()).limit(30).all()
+        karmas = event.session.query(Karma) \
+                .order_by(reverse and Karma.value.asc() or Karma.value.desc()) \
+                .limit(30).all()
         if karmas:
             event.addresponse(', '.join(['%s: %s (%s)' % (karmas.index(karma), karma.subject, karma.value) for karma in karmas]))
         else:
             event.addresponse(u"I don't really care about anything")
-        session.close()
 
 class Forget(Processor):
     u"""forget karma for <subject> [[reason]]"""
@@ -138,17 +134,16 @@
     @match(r'^forget\s+karma\s+for\s+(.+?)(?:\s*[[{(]+\s*(.+?)\s*[\]})]+)?$')
     @authorise
     def forget(self, event, subject, reason):
-        session = ibid.databases.ibid()
-        karma = session.query(Karma).filter(func.lower(Karma.subject)==subject.lower()).first()
+        karma = event.session.query(Karma) \
+                .filter(func.lower(Karma.subject) == subject.lower()).first()
         if not karma:
             karma = Karma(subject)
             event.addresponse(u"I was pretty ambivalent about %s, anyway", subject)
 
-        session.delete(karma)
-        session.flush()
-        session.close()
+        event.session.delete(karma)
 
-        log.info(u"Forgot karma for '%s' by %s/%s (%s) because: %s", subject, event.account, event.identity, event.sender['connection'], reason)
+        log.info(u"Forgot karma for '%s' by %s/%s (%s) because: %s",
+                subject, event.account, event.identity, event.sender['connection'], reason)
         event.addresponse(True)
 
 # vi: set et sta sw=4 ts=4:
 
=== modified file 'ibid/plugins/memo.py'
--- ibid/plugins/memo.py	2009-05-01 12:27:24 +0000
+++ ibid/plugins/memo.py	2009-05-03 16:33:10 +0000
@@ -5,10 +5,9 @@
 from sqlalchemy.orm import relation
 from sqlalchemy.sql import func
 
-import ibid
 from ibid.plugins import Processor, handler, match, authorise
 from ibid.config import Option
-from ibid.plugins.auth import permission
+from ibid.auth import permission
 from ibid.plugins.identity import get_identities
 from ibid.models import Base, VersionedSchema, Identity, Account
 from ibid.utils import ago
@@ -51,10 +50,12 @@
     @match(r'^(?:please\s+)?(tell|pm|privmsg|msg)\s+(\S+)\s+(?:(?:that|to)\s+)?(.+)$')
     @authorise
     def tell(self, event, how, who, memo):
-        session = ibid.databases.ibid()
-        to = session.query(Identity).filter(func.lower(Identity.identity)==who.lower()).filter_by(source=event.source).first()
+        to = event.session.query(Identity) \
+                .filter(func.lower(Identity.identity) == who.lower()) \
+                .filter_by(source=event.source).first()
         if not to:
-            account = session.query(Account).filter(func.lower(Account.username)==who.lower()).first()
+            account = event.session.query(Account) \
+                    .filter(func.lower(Account.username) == who.lower()).first()
             if account:
                 for identity in account.identities:
                     if identity.source == event.source:
@@ -63,27 +64,32 @@
                     identity = account.identities[0]
         if not to:
             to = Identity(event.source, who)
-            session.save(to)
-            session.flush()
+            event.session.save(to)
+
+            event.session.flush()
             log.info(u"Created identity %s for %s on %s", to.id, to.identity, to.source)
 
-        if permission(u'recvmemo', to.account and to.account.id or None, to.source) != 'yes':
+        if permission(u'recvmemo', to.account and to.account.id or None, to.source, event.session) != 'yes':
             event.addresponse(u'Just tell %s yourself', who)
             return
 
         memo = Memo(event.identity, to.id, memo, how.lower() in ('pm', 'privmsg', 'msg'))
-        session.save_or_update(memo)
-        session.flush()
-        log.info(u"Stored memo %s for %s (%s) from %s (%s): %s", memo.id, to.id, who, event.identity, event.sender['connection'], memo.memo)
+        event.session.save_or_update(memo)
+
+        event.session.flush()
+        log.info(u"Stored memo %s for %s (%s) from %s (%s): %s",
+                memo.id, to.id, who, event.identity, event.sender['connection'], memo.memo)
         event.memo = memo.id
-        session.close()
         memo_cache.clear()
 
         event.addresponse(True)
 
-def get_memos(session, event, delivered=False):
-    identities = get_identities(event, session)
-    return session.query(Memo).filter_by(delivered=delivered).filter(Memo.to_id.in_(identities)).order_by(Memo.time.asc()).all()
+def get_memos(event, delivered=False):
+    identities = get_identities(event)
+    return event.session.query(Memo) \
+            .filter_by(delivered=delivered) \
+            .filter(Memo.to_id.in_(identities)) \
+            .order_by(Memo.time.asc()).all()
 
 class Deliver(Processor):
     feature = 'memo'
@@ -96,8 +102,7 @@
         if event.identity in memo_cache:
             return
 
-        session = ibid.databases.ibid()
-        memos = get_memos(session, event)
+        memos = get_memos(event)
 
         for memo in memos:
             # Don't deliver if the user just sent a memo to themself
@@ -122,11 +127,9 @@
                 })
 
             memo.delivered = True
-            session.save_or_update(memo)
-            log.info(u"Delivered memo %s to %s (%s)", memo.id, event.identity, event.sender['connection'])
-
-        session.flush()
-        session.close()
+            event.session.save_or_update(memo)
+            log.info(u"Delivered memo %s to %s (%s)",
+                    memo.id, event.identity, event.sender['connection'])
 
         if 'memo' not in event:
             memo_cache[event.identity] = None
@@ -146,16 +149,13 @@
         if event.identity in memo_cache:
             return
 
-        session = ibid.databases.ibid()
-        memos = get_memos(session, event)
+        memos = get_memos(event)
 
         if len(memos) > 0:
             event.addresponse({'reply': u'You have %s messages' % len(memos), 'target': event.sender['id']})
         else:
             memo_cache[event.identity] = None
 
-        session.close()
-
 class Messages(Processor):
     u"""my messages
     message <number>"""
@@ -165,18 +165,15 @@
 
     @match(r'^my\s+messages$')
     def messages(self, event):
-        session = ibid.databases.ibid()
-        memos = get_memos(session, event, True)
+        memos = get_memos(event, True)
         if memos:
             event.addresponse(u', '.join(['%s: %s (%s)' % (memos.index(memo), memo.sender.identity, memo.time.strftime(self.datetime_format)) for memo in memos]))
         else:
             event.addresponse(u"Sorry, nobody loves you")
-        session.close()
 
     @match(r'^message\s+(\d+)$')
     def message(self, event, number):
-        session = ibid.databases.ibid()
-        memos = get_memos(session, event, True)
+        memos = get_memos(event, True)
         memo = memos[int(number)]
         event.addresponse(u"From %(sender)s on %(source)s at %(time)s: %(message)s", {
             'sender': memo.sender.identity,
@@ -184,7 +181,5 @@
             'time': memo.time.strftime(self.datetime_format),
             'message': memo.memo,
         })
-        session.close()
-
 
 # vi: set et sta sw=4 ts=4:
 
=== modified file 'ibid/plugins/seen.py'
--- ibid/plugins/seen.py	2009-05-01 12:22:37 +0000
+++ ibid/plugins/seen.py	2009-05-03 16:37:03 +0000
@@ -6,7 +6,6 @@
 from sqlalchemy.sql import func
 from sqlalchemy.exceptions import IntegrityError
 
-import ibid
 from ibid.plugins import Processor, match
 from ibid.config import Option
 from ibid.models import Base, VersionedSchema, Identity, Account
@@ -51,8 +50,9 @@
         if event.type != 'message' and event.type != 'state':
             return
 
-        session = ibid.databases.ibid()
-        sighting = session.query(Sighting).filter_by(identity_id=event.identity).filter_by(type=event.type).first()
+        sighting = event.session.query(Sighting) \
+                .filter_by(identity_id=event.identity) \
+                .filter_by(type=event.type).first()
         if not sighting:
             sighting = Sighting(event.identity, event.type)
 
@@ -65,12 +65,15 @@
         sighting.time = datetime.now()
         sighting.count = sighting.count + 1
 
+        event.session.save_or_update(sighting)
         try:
-            session.save_or_update(sighting)
-            session.flush()
+            event.session.commit()
         except IntegrityError:
-            log.debug('Race on seen update for identity %s', event.identity)
-        session.close()
+            event.session.rollback()
+            event.session.close()
+            del event['session']
+            log.debug(u'Race encountered updating seen for %s on %s',
+                    event.sender['id'], event.source)
 
 class Seen(Processor):
     u"""seen <who>"""
@@ -81,14 +84,15 @@
     @match(r'^(?:have\s+you\s+)?seen\s+(\S+)(?:\s+on\s+(\S+))?$')
     def handler(self, event, who, source):
 
-        session = ibid.databases.ibid()
         account = None
-        identity = session.query(Identity).filter(func.lower(Identity.source)==(source and source or event.source).lower()).filter(func.lower(Identity.identity)==who.lower()).first()
+        identity = event.session.query(Identity) \
+                .filter(func.lower(Identity.source) == (source and source or event.source).lower()) \
+                .filter(func.lower(Identity.identity) == who.lower()).first()
         if identity and identity.account and not source:
             account = identity.account
 
         if not identity and not source:
-            account = session.query(Account).filter_by(username=who).first()
+            account = event.session.query(Account).filter_by(username=who).first()
 
         if not identity and not account:
             event.addresponse(u"I don't know who %s is", who)
@@ -98,13 +102,15 @@
         states = []
         if account:
             for identity in account.identities:
-                for sighting in session.query(Sighting).filter_by(identity_id=identity.id).all():
+                for sighting in event.session.query(Sighting) \
+                        .filter_by(identity_id=identity.id).all():
                     if sighting.type == 'message':
                         messages.append(sighting)
                     else:
                         states.append(sighting)
         else:
-            for sighting in session.query(Sighting).filter_by(identity_id=identity.id).all():
+            for sighting in event.session.query(Sighting) \
+                    .filter_by(identity_id=identity.id).all():
                 if sighting.type == 'message':
                     messages.append(sighting)
                 else:
@@ -133,6 +139,5 @@
             reply += u" has been %s on %s since %s" % (sighting.value, sighting.identity.source, sighting.time.strftime(self.datetime_format))
 
         event.addresponse(reply)
-        session.close()
 
 # vi: set et sta sw=4 ts=4:
 
=== modified file 'ibid/plugins/url.py'
--- ibid/plugins/url.py	2009-05-01 12:22:37 +0000
+++ ibid/plugins/url.py	2009-05-02 19:29:44 +0000
@@ -114,11 +114,8 @@
             else:
                 url = 'http://%s' % url
 
-        session = ibid.databases.ibid()
         u = URL(url, event.channel, event.identity)
-        session.save_or_update(u)
-        session.flush()
-        session.close()
+        event.session.save_or_update(u)
 
         if self.username != None:
             self.delicious.add_post(self.username, self.password, event, url)
 
=== modified file 'ibid/source/irc.py'
--- ibid/source/irc.py	2009-05-01 12:59:07 +0000
+++ ibid/source/irc.py	2009-05-02 19:29:44 +0000
@@ -237,8 +237,9 @@
         return u'irc://%s@%s:%s' % (self.nick, self.server, self.port)
 
     def auth_hostmask(self, event, credential = None):
-        session = ibid.databases.ibid()
-        for credential in session.query(Credential).filter_by(method=u'hostmask').filter_by(account_id=event.account).filter(or_(Credential.source == event.source, Credential.source == None)).all():
+        for credential in event.session.query(Credential) \
+                .filter_by(method=u'hostmask').filter_by(account_id=event.account) \
+                .filter(or_(Credential.source == event.source, Credential.source == None)).all():
             if fnmatch(event.sender['connection'], credential.credential):
                 return True
 
 
=== modified file 'scripts/ibid-factpack'
--- scripts/ibid-factpack	2009-04-26 11:04:32 +0000
+++ scripts/ibid-factpack	2009-05-02 19:29:44 +0000
@@ -28,7 +28,6 @@
 ibid.reload_reloader()
 ibid.reloader.reload_databases()
 session = ibid.databases.ibid()
-session.begin()
 
 if options.remove:
     factpack = session.query(Factpack).filter_by(name=filename).first()
@@ -76,7 +75,6 @@
 
 factpack = Factpack(name)
 session.save(factpack)
-session.flush()
 
 existing = []
 for names, values in facts:
 
=== modified file 'scripts/ibid-plugin'
--- scripts/ibid-plugin	2009-05-02 16:20:45 +0000
+++ scripts/ibid-plugin	2009-05-03 16:37:03 +0000
@@ -14,6 +14,7 @@
     pass
 
 from twisted.python.modules import getModule
+from sqlalchemy.exceptions import IntegrityError
 
 import ibid
 import ibid.plugins
@@ -80,15 +81,19 @@
 username = unicode(getenv('USER'))
 if not username:
     username = u'tester'
+
 session = ibid.databases.ibid()
+
 identity = session.query(Identity).filter_by(identity=username).first()
 if not identity:
     identity = Identity(u'test_source',username)
     session.save(identity)
-    session.flush()
+    session.commit()
     identity = session.query(Identity).filter_by(identity=username).first()
 identity_id = identity.id
 
+session.close()
+
 try:
     encoding = getenv("LANG").split(".")[1]
 except:
@@ -115,14 +120,28 @@
         try:
             processor.process(event)
         except Exception:
-            log.exception(u"Exception occured in %s processor of %s plugin", processor.__class__.__name__, processor.name)
+            log.exception(u"Exception occured in %s processor of %s plugin",
+                    processor.__class__.__name__, processor.name)
             event.complain = 'exception'
 
+        if 'session' in event:
+            try:
+                event.session.commit()
+            except IntegrityError:
+                self.log.exception(u"Exception occured committing session from the %s processor of %s plugin",
+                        processor.__class__.__name__, processor.name)
+                event.complain = u'exception'
+                event.session.rollback()
+                event.session.close()
+                del event['session']
+
     for response in event.responses:
         if isinstance(response, dict):
             response = response['reply']
         print 'Response: %s' % response
 
+    event.session.close()
+
 if readline:
     readline.write_history_file('.history')
 print "\nExiting"
 
=== modified file 'scripts/ibid-setup'
--- scripts/ibid-setup	2009-05-01 10:39:58 +0000
+++ scripts/ibid-setup	2009-05-02 19:29:44 +0000
@@ -83,7 +83,6 @@
     exit(1)
 
 session = Session()
-session.begin()
 account = Account(identity)
 identity = Identity(source, identity)
 account.identities.append(identity)
 
=== modified file 'scripts/ibid_import'
--- scripts/ibid_import	2009-02-22 07:43:34 +0000
+++ scripts/ibid_import	2009-05-02 19:29:44 +0000
@@ -63,7 +63,9 @@
         return None
     user = decode(user)
     
-    identity = session.query(Identity).filter(func.lower(Identity.identity)==user.lower()).filter(func.lower(Identity.source)==source.lower()).first()
+    identity = session.query(Identity) \
+            .filter(func.lower(Identity.identity) == user.lower()) \
+            .filter(func.lower(Identity.source) == source.lower()).first()
     if not identity:
         identity = Identity(source, user)
         identity.created = created
@@ -231,5 +233,6 @@
     print 'Done'
 
     knab.close()
+    ibid.close()
 
 # vi: set et sta sw=4 ts=4: