Customise meta.py to support strict boolean values.

Author: esirK

.gitignore

@@ -105,7 +105,6 @@ ENV/
 ckan
 ckan/
 ckan-*.tar.gz
-
 # Env
 env*
 !env.tmpl

contrib/ckan/Dockerfile

@@ -7,5 +7,8 @@ ARG CKAN_VERSION=2.8.3
 RUN pip install -U -q pip setuptools
 
 RUN pip install -q -e "git+https://github.com/ckan/ckan.git@ckan-${CKAN_VERSION}#egg=ckan"
+
+ADD meta.py /src/ckan/ckan/model/meta.py
+
 RUN pip install -q -r /src/ckan/requirements.txt
 RUN pip install -q vdm==0.15 sqlalchemy==1.2.19

contrib/ckan/meta.py

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+import datetime
+
+from paste.deploy.converters import asbool
+from ckan.common import config
+"""SQLAlchemy Metadata and Session object"""
+from sqlalchemy import MetaData, and_
+import sqlalchemy.orm as orm
+from sqlalchemy.orm.session import SessionExtension
+
+import extension
+import ckan.lib.activity_streams_session_extension as activity
+
+__all__ = ['Session', 'engine_is_sqlite', 'engine_is_pg']
+
+
+class CkanCacheExtension(SessionExtension):
+    ''' This extension checks what tables have been affected by
+    database access and allows us to act on them. Currently this is
+    used by the page cache to flush the cache when data in the database
+    is altered. '''
+
+    def __init__(self, *args, **kw):
+        super(CkanCacheExtension, self).__init__(*args, **kw)
+
+    def after_commit(self, session):
+        if hasattr(session, '_object_cache'):
+            oc = session._object_cache
+            oc_list = oc['new']
+            oc_list.update(oc['changed'])
+            oc_list.update(oc['deleted'])
+            objs = set()
+            for item in oc_list:
+                objs.add(item.__class__.__name__)
+
+
+class CkanSessionExtension(SessionExtension):
+
+    def before_flush(self, session, flush_context, instances):
+        if not hasattr(session, '_object_cache'):
+            session._object_cache= {'new': set(),
+                                    'deleted': set(),
+                                    'changed': set()}
+
+        changed = [obj for obj in session.dirty if
+            session.is_modified(obj, include_collections=False, passive=True)]
+
+        session._object_cache['new'].update(session.new)
+        session._object_cache['deleted'].update(session.deleted)
+        session._object_cache['changed'].update(changed)
+
+
+    def before_commit(self, session):
+        session.flush()
+        try:
+            obj_cache = session._object_cache
+            revision = session.revision
+        except AttributeError:
+            return
+        if getattr(session, 'revisioning_disabled', False):
+            return
+        new = obj_cache['new']
+        changed = obj_cache['changed']
+        deleted = obj_cache['deleted']
+        for obj in new | changed | deleted:
+            if not hasattr(obj, '__revision_class__'):
+                continue
+            revision_cls = obj.__revision_class__
+            revision_table = orm.class_mapper(revision_cls).mapped_table
+            ## when a normal active transaction happens
+
+            ### this is an sql statement as we do not want it in object cache
+            session.execute(
+                revision_table.update().where(
+                    and_(revision_table.c.id == obj.id,
+                         revision_table.c.current == True)
+                ).values(current=False)
+            )
+
+            q = session.query(revision_cls)
+            q = q.filter_by(expired_timestamp=datetime.datetime(9999, 12, 31), id=obj.id)
+            results = q.all()
+            for rev_obj in results:
+                values = {}
+                if rev_obj.revision_id == revision.id:
+                    values['revision_timestamp'] = revision.timestamp
+                else:
+                    values['expired_timestamp'] = revision.timestamp
+                session.execute(
+                    revision_table.update().where(
+                        and_(revision_table.c.id == rev_obj.id,
+                             revision_table.c.revision_id == rev_obj.revision_id)
+                    ).values(**values)
+                )
+
+    def after_commit(self, session):
+        if hasattr(session, '_object_cache'):
+            del session._object_cache
+
+    def after_rollback(self, session):
+        if hasattr(session, '_object_cache'):
+            del session._object_cache
+
+# __all__ = ['Session', 'engine', 'metadata', 'mapper']
+
+# SQLAlchemy database engine. Updated by model.init_model()
+engine = None
+
+Session = orm.scoped_session(orm.sessionmaker(
+    autoflush=False,
+    autocommit=False,
+    expire_on_commit=False,
+    extension=[CkanCacheExtension(),
+               CkanSessionExtension(),
+               extension.PluginSessionExtension(),
+               activity.DatasetActivitySessionExtension()],
+))
+
+create_local_session = orm.sessionmaker(
+    autoflush=False,
+    autocommit=False,
+    expire_on_commit=False,
+    extension=[CkanCacheExtension(),
+               CkanSessionExtension(),
+               extension.PluginSessionExtension(),
+               activity.DatasetActivitySessionExtension()],
+)
+
+#mapper = Session.mapper
+mapper = orm.mapper
+
+# Global metadata. If you have multiple databases with overlapping table
+# names, you'll need a metadata for each database
+metadata = MetaData()
+
+
+def engine_is_sqlite(sa_engine=None):
+    # Returns true iff the engine is connected to a sqlite database.
+    return (sa_engine or engine).url.drivername == 'sqlite'
+
+
+def engine_is_pg(sa_engine=None):
+    # Returns true iff the engine is connected to a postgresql database.
+    # According to http://docs.sqlalchemy.org/en/latest/core/engines.html#postgresql
+    # all Postgres driver names start with `postgres`
+    return (sa_engine or engine).url.drivername.startswith('postgres')