AnyBlok / Anyblok_Pyramid / 311

pending completion

Build # 311

Build Type

Pull #36

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/AnyBlok/Anyblok_Pyramid/commit/<a class=hub.com/AnyBlok/Anyblok_Pyramid/commit/<a class="double-link" href="https://git"><a class=hub.com/AnyBlok/Anyblok_Pyramid/commit/<a class="double-link" href="https://git"><a class=hub.com/AnyBlok/Anyblok_Pyramid/commit/<a class="double-link" href="https://git"><a class=hub.com/AnyBlok/Anyblok_Pyramid/commit/d4f8b0c58b78c9194bb712e1cf8abbbf129abcbf">d4f8b0c58">&lt;a href=&quot;https://github.com/AnyBlok/Anyblok_Pyramid/commit/</a><a class="double-link" href="https://github.com/AnyBlok/Anyblok_Pyramid/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/AnyBlok/Anyblok_Pyramid/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/AnyBlok/Anyblok_Pyramid/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/AnyBlok/Anyblok_Pyramid/commit/d4f8b0c58b78c9194bb712e1cf8abbbf129abcbf">d4f8b0c58</a><a href="https://github.com/AnyBlok/Anyblok_Pyramid/commit/d4f8b0c58b78c9194bb712e1cf8abbbf129abcbf">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/AnyBlok/Anyblok_Pyramid/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/AnyBlok/Anyblok_Pyramid/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/AnyBlok/Anyblok_Pyramid/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/AnyBlok/Anyblok_Pyramid/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/AnyBlok/Anyblok_Pyramid/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/AnyBlok/Anyblok_Pyramid/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/AnyBlok/Anyblok_Pyramid/commit/d4f8b0c58b78c9194bb712e1cf8abbbf129abcbf&quot;&gt;d4f8b0c58&lt;/a&gt;&lt;a href=&quot;https://github.com/AnyBlok/Anyblok_Pyramid/commit/d4f8b0c58b78c9194bb712e1cf8abbbf129abcbf&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/AnyBlok/Anyblok_Pyramid/commit/&amp;lt;/... (continued)

Pull Request Pull Request #36: Upgrade Pyramid >= 2.0 and AnyBlok >= 1.1.0

Run Details

20 of 20 new or added lines in 7 files covered. (100.0%)

818 of 959 relevant lines covered (85.3%)

4.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

36.0

/anyblok_pyramid/anyblok.py

# -*- coding: utf-8 -*-
# This file is a part of the AnyBlok / Pyramid project
#
#    Copyright (C) 2015 Jean-Sebastien SUZANNE <jssuzanne@anybox.fr>
#    Copyright (C) 2017 Jean-Sebastien SUZANNE <jssuzanne@anybox.fr>
#    Copyright (C) 2019 Jean-Sebastien SUZANNE <js.suzanne@gmail.fr>
#
# This Source Code Form is subject to the terms of the Mozilla Public License,
# v. 2.0. If a copy of the MPL was not distributed with this file,You can
# obtain one at http://mozilla.org/MPL/2.0/.
try:
    from zope.sqlalchemy import ZopeTransactionExtension
except ImportError:
    from zope.sqlalchemy import (
        ZopeTransactionEvents as ZopeTransactionExtension)

from zope.sqlalchemy.datamanager import (
    _SESSION_STATE, STATUS_ACTIVE, STATUS_READONLY, STATUS_CHANGED,
    STATUS_INVALIDATED, NO_SAVEPOINT_SUPPORT, _retryable_errors)
import transaction as zope_transaction
from transaction._transaction import Status as ZopeStatus


from zope.interface import implementer
from transaction.interfaces import IDataManagerSavepoint
from anyblok.environment import EnvironmentManager
from sqlalchemy.engine.base import Engine
from sqlalchemy.orm.exc import ConcurrentModificationError
from sqlalchemy.exc import DBAPIError
from sqlalchemy import event


class AnyBlokSessionDataManager:

    def __init__(self, session, status, transaction_manager,
                 keep_session=False):
        self.transaction_manager = transaction_manager
        self.registry = session._query_cls.registry
        self.transaction = self.registry.session.transaction
        transaction_manager.get().join(self)
        _SESSION_STATE[session] = status
        self.state = 'init'
        self.keep_session = keep_session

    def _finish(self, final_state):
        assert self.transaction is not None
        del _SESSION_STATE[self.registry.session]
        registry = self.registry
        self.transaction = self.registry = None
        self.state = final_state
        if not self.keep_session:
            registry.session.close()
        else:
            registry.session.expire_all()

        EnvironmentManager.set('_precommit_hook', [])

    def abort(self, trans):
        if self.transaction is not None:
            self._finish('aborted')

    def tpc_begin(self, trans):
        self.registry.session.flush()

    def commit(self, trans):
        status = _SESSION_STATE[self.registry.session]
        if status is not STATUS_INVALIDATED:
            if self.registry.session.expire_on_commit:
                self.registry.session.expire_all()
            self._finish('no work')

    def tpc_vote(self, trans):
        if self.transaction is not None:
            self.registry.commit()
            self._finish('committed')

    def tpc_finish(self, trans):
        pass

    def tpc_abort(self, trans):
        assert self.state != 'committed'

    def sortKey(self):
        return "~AnyBlok:%d" % id(self.transaction)

    @property
    def savepoint(self):
        if set(engine.url.drivername
               for engine in self.transaction._connections.keys()
               if isinstance(engine, Engine)
               ).intersection(NO_SAVEPOINT_SUPPORT):
            raise AttributeError('savepoint')
        return self._savepoint

    def _savepoint(self):
        self.registry.System.Cache.clear_invalidate_cache()
        return AnyBlokSessionSavepoint(self.registry)

    def should_retry(self, error):
        if isinstance(error, ConcurrentModificationError):
            return True
        if isinstance(error, DBAPIError):
            orig = error.orig
            for error_type, test in _retryable_errors:
                if isinstance(orig, error_type):
                    if test is None:
                        return True
                    if test(orig):
                        return True


class AnyBlokTwoPhaseSessionDataManager(AnyBlokSessionDataManager):

    def tpc_vote(self, trans):
        if self.transaction is not None:
            self.transaction.prepare()
            self.state = 'voted'

    def tpc_finish(self, trans):
        if self.transaction is not None:
            self.registry.commit()
            self._finish('committed')

    def tpc_abort(self, trans):
        if self.transaction is not None:
            self.registry.rollback()
            self._finish('aborted commit')

    def sortKey(self):
        # Sort normally
        return "AnyBlok.twophase:%d" % id(self.transaction)


@implementer(IDataManagerSavepoint)
class AnyBlokSessionSavepoint:

    def __init__(self, registry):
        self.registry = registry
        self.transaction = self.registry.session.begin_nested()

    def rollback(self):
        self.transaction.rollback()


def join_transaction(session, initial_state=STATUS_ACTIVE,
                     transaction_manager=zope_transaction.manager,
                     keep_session=False):
    if _SESSION_STATE.get(session, None) is None:
        if session.twophase:
            DataManager = AnyBlokTwoPhaseSessionDataManager
        else:
            DataManager = AnyBlokSessionDataManager
        DataManager(session, initial_state, transaction_manager,
                    keep_session=keep_session)


def mark_changed(session, transaction_manager=zope_transaction.manager,
                 keep_session=False):
    session_id = session
    assert _SESSION_STATE.get(session_id, None) is not STATUS_READONLY, (
        "Session already registered as read only")
    join_transaction(session, STATUS_CHANGED, transaction_manager, keep_session)
    _SESSION_STATE[session_id] = STATUS_CHANGED


class AnyBlokZopeTransactionExtension(ZopeTransactionExtension):

    def after_begin(self, session, transaction, connection):
        join_transaction(session, self.initial_state, self.transaction_manager,
                         self.keep_session)

    def after_attach(self, session, instance):
        join_transaction(session, self.initial_state, self.transaction_manager,
                         self.keep_session)

    def after_flush(self, session, flush_context):
        mark_changed(session, self.transaction_manager, self.keep_session)

    def after_bulk_update(self, session, query, query_context, result):
        mark_changed(session, self.transaction_manager, self.keep_session)

    def after_bulk_delete(self, session, query, query_context, result):
        mark_changed(session, self.transaction_manager, self.keep_session)

    def before_commit(self, session):
        assert (
            session.transaction.nested or  # noqa
            self.transaction_manager.get().status == ZopeStatus.COMMITTING
        ), "Transaction must be committed using the transaction manager"


def register(session, initial_state=STATUS_ACTIVE,
             transaction_manager=zope_transaction.manager, keep_session=False):
    ext = AnyBlokZopeTransactionExtension(
        initial_state=initial_state,
        transaction_manager=transaction_manager,
        keep_session=keep_session,
    )
    event.listen(session, "after_begin", ext.after_begin)
    event.listen(session, "after_attach", ext.after_attach)
    event.listen(session, "after_flush", ext.after_flush)
    event.listen(session, "after_bulk_update", ext.after_bulk_update)
    event.listen(session, "after_bulk_delete", ext.after_bulk_delete)
    event.listen(session, "before_commit", ext.before_commit)

1	# -- coding: utf-8 --
2	# This file is a part of the AnyBlok / Pyramid project
3	#
4	# Copyright (C) 2015 Jean-Sebastien SUZANNE <jssuzanne@anybox.fr>
5	# Copyright (C) 2017 Jean-Sebastien SUZANNE <jssuzanne@anybox.fr>
6	# Copyright (C) 2019 Jean-Sebastien SUZANNE <js.suzanne@gmail.fr>
7	#
8	# This Source Code Form is subject to the terms of the Mozilla Public License,
9	# v. 2.0. If a copy of the MPL was not distributed with this file,You can
10	# obtain one at http://mozilla.org/MPL/2.0/.
11	try:	6✔
12	from zope.sqlalchemy import ZopeTransactionExtension	6✔
13	except ImportError:	6✔
14	from zope.sqlalchemy import (	6✔
15	ZopeTransactionEvents as ZopeTransactionExtension)
16
17	from zope.sqlalchemy.datamanager import (	6✔
18	_SESSION_STATE, STATUS_ACTIVE, STATUS_READONLY, STATUS_CHANGED,
19	STATUS_INVALIDATED, NO_SAVEPOINT_SUPPORT, _retryable_errors)
20	import transaction as zope_transaction	6✔
21	from transaction._transaction import Status as ZopeStatus	6✔
22
23
24	from zope.interface import implementer	6✔
25	from transaction.interfaces import IDataManagerSavepoint	6✔
26	from anyblok.environment import EnvironmentManager	6✔
27	from sqlalchemy.engine.base import Engine	6✔
28	from sqlalchemy.orm.exc import ConcurrentModificationError	6✔
29	from sqlalchemy.exc import DBAPIError	6✔
30	from sqlalchemy import event	6✔
31
32
33	class AnyBlokSessionDataManager:	6✔
34
35	def __init__(self, session, status, transaction_manager,	6✔
36	keep_session=False):
37	self.transaction_manager = transaction_manager	×
38	self.registry = session._query_cls.registry	×
39	self.transaction = self.registry.session.transaction	×
40	transaction_manager.get().join(self)	×
41	_SESSION_STATE[session] = status	×
42	self.state = 'init'	×
43	self.keep_session = keep_session	×
44
45	def _finish(self, final_state):	6✔
46	assert self.transaction is not None	×
47	del _SESSION_STATE[self.registry.session]	×
48	registry = self.registry	×
49	self.transaction = self.registry = None	×
50	self.state = final_state	×
51	if not self.keep_session:	×
52	registry.session.close()	×
53	else:
54	registry.session.expire_all()	×
55
56	EnvironmentManager.set('_precommit_hook', [])	×
57
58	def abort(self, trans):	6✔
59	if self.transaction is not None:	×
60	self._finish('aborted')	×
61
62	def tpc_begin(self, trans):	6✔
63	self.registry.session.flush()	×
64
65	def commit(self, trans):	6✔
66	status = _SESSION_STATE[self.registry.session]	×
67	if status is not STATUS_INVALIDATED:	×
68	if self.registry.session.expire_on_commit:	×
69	self.registry.session.expire_all()	×
70	self._finish('no work')	×
71
72	def tpc_vote(self, trans):	6✔
73	if self.transaction is not None:	×
74	self.registry.commit()	×
75	self._finish('committed')	×
76
77	def tpc_finish(self, trans):	6✔
78	pass	×
79
80	def tpc_abort(self, trans):	6✔
81	assert self.state != 'committed'	×
82
83	def sortKey(self):	6✔
84	return "~AnyBlok:%d" % id(self.transaction)	×
85
86	@property	6✔
87	def savepoint(self):	4✔
88	if set(engine.url.drivername	×
89	for engine in self.transaction._connections.keys()
90	if isinstance(engine, Engine)
91	).intersection(NO_SAVEPOINT_SUPPORT):
92	raise AttributeError('savepoint')	×
93	return self._savepoint	×
94
95	def _savepoint(self):	6✔
96	self.registry.System.Cache.clear_invalidate_cache()	×
97	return AnyBlokSessionSavepoint(self.registry)	×
98
99	def should_retry(self, error):	6✔
100	if isinstance(error, ConcurrentModificationError):	×
101	return True	×
102	if isinstance(error, DBAPIError):	×
103	orig = error.orig	×
104	for error_type, test in _retryable_errors:	×
105	if isinstance(orig, error_type):	×
106	if test is None:	×
107	return True	×
108	if test(orig):	×
109	return True	×
110
111
112	class AnyBlokTwoPhaseSessionDataManager(AnyBlokSessionDataManager):	6✔
113
114	def tpc_vote(self, trans):	6✔
115	if self.transaction is not None:	×
116	self.transaction.prepare()	×
117	self.state = 'voted'	×
118
119	def tpc_finish(self, trans):	6✔
120	if self.transaction is not None:	×
121	self.registry.commit()	×
122	self._finish('committed')	×
123
124	def tpc_abort(self, trans):	6✔
125	if self.transaction is not None:	×
126	self.registry.rollback()	×
127	self._finish('aborted commit')	×
128
129	def sortKey(self):	6✔
130	# Sort normally
131	return "AnyBlok.twophase:%d" % id(self.transaction)	×
132
133
134	@implementer(IDataManagerSavepoint)	6✔
135	class AnyBlokSessionSavepoint:	4✔
136
137	def __init__(self, registry):	6✔
138	self.registry = registry	×
139	self.transaction = self.registry.session.begin_nested()	×
140
141	def rollback(self):	6✔
142	self.transaction.rollback()	×
143
144
145	def join_transaction(session, initial_state=STATUS_ACTIVE,	6✔
146	transaction_manager=zope_transaction.manager,
147	keep_session=False):
148	if _SESSION_STATE.get(session, None) is None:	×
149	if session.twophase:	×
150	DataManager = AnyBlokTwoPhaseSessionDataManager	×
151	else:
152	DataManager = AnyBlokSessionDataManager	×
153	DataManager(session, initial_state, transaction_manager,	×
154	keep_session=keep_session)
155
156
157	def mark_changed(session, transaction_manager=zope_transaction.manager,	6✔
158	keep_session=False):
159	session_id = session	×
160	assert _SESSION_STATE.get(session_id, None) is not STATUS_READONLY, (	×
161	"Session already registered as read only")
162	join_transaction(session, STATUS_CHANGED, transaction_manager, keep_session)	×
163	_SESSION_STATE[session_id] = STATUS_CHANGED	×
164
165
166	class AnyBlokZopeTransactionExtension(ZopeTransactionExtension):	6✔
167
168	def after_begin(self, session, transaction, connection):	6✔
169	join_transaction(session, self.initial_state, self.transaction_manager,	×
170	self.keep_session)
171
172	def after_attach(self, session, instance):	6✔
173	join_transaction(session, self.initial_state, self.transaction_manager,	×
174	self.keep_session)
175
176	def after_flush(self, session, flush_context):	6✔
177	mark_changed(session, self.transaction_manager, self.keep_session)	×
178
179	def after_bulk_update(self, session, query, query_context, result):	6✔
180	mark_changed(session, self.transaction_manager, self.keep_session)	×
181
182	def after_bulk_delete(self, session, query, query_context, result):	6✔
183	mark_changed(session, self.transaction_manager, self.keep_session)	×
184
185	def before_commit(self, session):	6✔
186	assert (	×
187	session.transaction.nested or # noqa
188	self.transaction_manager.get().status == ZopeStatus.COMMITTING
189	), "Transaction must be committed using the transaction manager"
190
191
192	def register(session, initial_state=STATUS_ACTIVE,	6✔
193	transaction_manager=zope_transaction.manager, keep_session=False):
194	ext = AnyBlokZopeTransactionExtension(	×
195	initial_state=initial_state,
196	transaction_manager=transaction_manager,
197	keep_session=keep_session,
198	)
199	event.listen(session, "after_begin", ext.after_begin)	×
200	event.listen(session, "after_attach", ext.after_attach)	×
201	event.listen(session, "after_flush", ext.after_flush)	×
202	event.listen(session, "after_bulk_update", ext.after_bulk_update)	×
203	event.listen(session, "after_bulk_delete", ext.after_bulk_delete)	×
204	event.listen(session, "before_commit", ext.before_commit)	×

AnyBlok / Anyblok_Pyramid / 311

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous