# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""Repository users' and internal' sessions."""

__docformat__ = "restructuredtext en"

import sys

import threading

from time import time

from uuid import uuid4

from warnings import warn

from logilab.common.deprecation import deprecated

from logilab.common.textutils import unormalize

from logilab.common.registry import objectify_predicate

from cubicweb import UnknownEid, QueryError, schema, server

from cubicweb.req import RequestSessionBase

from cubicweb.utils import make_uid

from cubicweb.rqlrewrite import RQLRewriter

from cubicweb.server import ShuttingDown

from cubicweb.server.edition import EditedEntity

NO_UNDO_TYPES = schema.SCHEMA_TYPES.copy()

NO_UNDO_TYPES.add('CWCache')

# is / is_instance_of are usually added by sql hooks except when using

# dataimport.NoHookRQLObjectStore, and we don't want to record them

# anyway in the later case

NO_UNDO_TYPES.add('is')

NO_UNDO_TYPES.add('is_instance_of')

NO_UNDO_TYPES.add('cw_source')

# XXX rememberme,forgotpwd,apycot,vcsfile

@objectify_predicate

def is_user_session(cls, req, **kwargs):

    """return 1 when session is not internal.

    This predicate can only be used repository side only. """

    return not req.is_internal_session

@objectify_predicate

def is_internal_session(cls, req, **kwargs):

    """return 1 when session is not internal.

    This predicate can only be used repository side only. """

    return req.is_internal_session

@objectify_predicate

def repairing(cls, req, **kwargs):

    """return 1 when repository is running in repair mode"""

    return req.vreg.config.repairing

class transaction(object):

    """Ensure that the transaction is either commited or rollbacked at exit

    Context manager to enter a transaction for a session: when exiting the

    `with` block on exception, call `session.rollback()`, else call

    `session.commit()` on normal exit

    """

    def __init__(self, session, free_cnxset=True):

        self.session = session

        self.free_cnxset = free_cnxset

    def __enter__(self):

        # ensure session has a cnxset

        self.session.set_cnxset()

    def __exit__(self, exctype, exc, traceback):

        if exctype:

            self.session.rollback(free_cnxset=self.free_cnxset)

        else:

            self.session.commit(free_cnxset=self.free_cnxset)

class hooks_control(object):

    """context manager to control activated hooks categories.

    If mode is session.`HOOKS_DENY_ALL`, given hooks categories will

    be enabled.

    If mode is session.`HOOKS_ALLOW_ALL`, given hooks categories will

    be disabled.

    .. sourcecode:: python

       with hooks_control(self.session, self.session.HOOKS_ALLOW_ALL, 'integrity'):

           # ... do stuff with all but 'integrity' hooks activated

       with hooks_control(self.session, self.session.HOOKS_DENY_ALL, 'integrity'):

           # ... do stuff with none but 'integrity' hooks activated

    This is an internal api, you should rather use

    :meth:`~cubicweb.server.session.Session.deny_all_hooks_but` or

    :meth:`~cubicweb.server.session.Session.allow_all_hooks_but` session

    methods.

    """

    def __init__(self, session, mode, *categories):

        self.session = session

        self.mode = mode

        self.categories = categories

    def __enter__(self):

        self.oldmode, self.changes = self.session.init_hooks_mode_categories(

            self.mode, self.categories)

    def __exit__(self, exctype, exc, traceback):

        self.session.reset_hooks_mode_categories(self.oldmode, self.mode, self.changes)

class security_enabled(object):

    """context manager to control security w/ session.execute,

    By default security is disabled on queries executed on the repository

    side.

    """

    def __init__(self, session, read=None, write=None):

        self.session = session

        self.read = read

        self.write = write

    def __enter__(self):

        self.oldread, self.oldwrite = self.session.init_security(

            self.read, self.write)

    def __exit__(self, exctype, exc, traceback):

        self.session.reset_security(self.oldread, self.oldwrite)

HOOKS_ALLOW_ALL = object()

HOOKS_DENY_ALL = object()

DEFAULT_SECURITY = object() # evaluated to true by design

class Transaction(object):

    """Repository Transaction

    Holds all transaction related data

    Database connections resource:

      :attr:`running_dbapi_query`, boolean flag telling if the executing query

      is coming from a dbapi connection or is a query from within the repository

      :attr:`cnxset`, the connections set to use to execute queries on sources.

      If the transaction is read only, the connection set may be freed between

      actual query. This allows multiple transaction with a reasonable low

      connection set pool size. control mechanism is detailed below

      :attr:`mode`, string telling the connections set handling mode, may be one

      of 'read' (connections set may be freed), 'write' (some write was done in

      the connections set, it can't be freed before end of the transaction),

      'transaction' (we want to keep the connections set during all the

      transaction, with or without writing)

    Internal transaction data:

      :attr:`data`,is a dictionary containing some shared data

      cleared at the end of the transaction. Hooks and operations may put

      arbitrary data in there, and this may also be used as a communication

      channel between the client and the repository.

      :attr:`pending_operations`, ordered list of operations to be processed on

      commit/rollback

      :attr:`commit_state`, describing the transaction commit state, may be one

      of None (not yet committing), 'precommit' (calling precommit event on

      operations), 'postcommit' (calling postcommit event on operations),

      'uncommitable' (some :exc:`ValidationError` or :exc:`Unauthorized` error

      has been raised during the transaction and so it must be rollbacked).

    Hooks controls:

      :attr:`hooks_mode`, may be either `HOOKS_ALLOW_ALL` or `HOOKS_DENY_ALL`.

      :attr:`enabled_hook_cats`, when :attr:`hooks_mode` is

      `HOOKS_DENY_ALL`, this set contains hooks categories that are enabled.

      :attr:`disabled_hook_cats`, when :attr:`hooks_mode` is

      `HOOKS_ALLOW_ALL`, this set contains hooks categories that are disabled.

    Security level Management:

      :attr:`read_security` and :attr:`write_security`, boolean flags telling if

      read/write security is currently activated.

    """

    def __init__(self, txid, mode, rewriter):

        #: transaction unique id

        self.transactionid = txid

        #: reentrance handling

        self.ctx_count = 0

        #: connection handling mode

        self.mode = mode

        #: connection set used to execute queries on sources

        self.cnxset = None

        #: is this transaction from a client or internal to the repo

        self.running_dbapi_query = True

        #: dict containing arbitrary data cleared at the end of the transaction

        self.data = {}

        #: ordered list of operations to be processed on commit/rollback

        self.pending_operations = []

        #: (None, 'precommit', 'postcommit', 'uncommitable')

        self.commit_state = None

        ### hook control attribute

        self.hooks_mode = HOOKS_ALLOW_ALL

        self.disabled_hook_cats = set()

        self.enabled_hook_cats = set()

        self.pruned_hooks_cache = {}

        ### security control attributes

        self._read_security = DEFAULT_SECURITY # handled by a property

        self.write_security = DEFAULT_SECURITY

        # RQLRewriter are not thread safe

        self._rewriter = rewriter

    @property

    def transaction_data(self):

        return self.data

    def clear(self):

        """reset internal data"""

        self.data = {}

        #: ordered list of operations to be processed on commit/rollback

        self.pending_operations = []

        #: (None, 'precommit', 'postcommit', 'uncommitable')

        self.commit_state = None

        self.pruned_hooks_cache = {}

    # Entity cache management #################################################

    #

    # The transaction entity cache as held in tx.data it is removed at end the

    # end of the transaction (commit and rollback)

    #

    # XXX transaction level caching may be a pb with multiple repository

    # instances, but 1. this is probably not the only one :$ and 2. it may be

    # an acceptable risk. Anyway we could activate it or not according to a

    # configuration option

    def set_entity_cache(self, entity):

        """Add `entity` to the transaction entity cache"""

        ecache = self.data.setdefault('ecache', {})

        ecache.setdefault(entity.eid, entity)

    def entity_cache(self, eid):

        """get cache entity for `eid`"""

        return self.data['ecache'][eid]

    def cached_entities(self):

        """return the whole entity cache"""

        return self.data.get('ecache', {}).values()

    def drop_entity_cache(self, eid=None):

        """drop entity from the cache

        If eid is None, the whole cache is dropped"""

        if eid is None:

            self.data.pop('ecache', None)

        else:

            del self.data['ecache'][eid]

    # Tracking of entity added of removed in the transaction ##################

    #

    # Those are function to  allows cheap call from client in other process.

    def deleted_in_transaction(self, eid):

        """return True if the entity of the given eid is being deleted in the

        current transaction

        """

        return eid in self.data.get('pendingeids', ())

    def added_in_transaction(self, eid):

        """return True if the entity of the given eid is being created in the

        current transaction

        """

        return eid in self.data.get('neweids', ())

    # Operation management ####################################################

    def add_operation(self, operation, index=None):

        """add an operation to be executed at the end of the transaction"""

        if index is None:

            self.pending_operations.append(operation)

        else:

            self.pending_operations.insert(index, operation)

    # Hooks control ###########################################################

    def disable_hook_categories(self, *categories):

        """disable the given hook categories:

        - on HOOKS_DENY_ALL mode, ensure those categories are not enabled

        - on HOOKS_ALLOW_ALL mode, ensure those categories are disabled

        """

        changes = set()

        self.pruned_hooks_cache.clear()

        categories = set(categories)

        if self.hooks_mode is HOOKS_DENY_ALL:

            enabledcats = self.enabled_hook_cats

            changes = enabledcats & categories

            enabledcats -= changes # changes is small hence faster

        else:

            disabledcats = self.disabled_hook_cats

            changes = categories - disabledcats

            disabledcats |= changes # changes is small hence faster

        return tuple(changes)

    def enable_hook_categories(self, *categories):

        """enable the given hook categories:

        - on HOOKS_DENY_ALL mode, ensure those categories are enabled

        - on HOOKS_ALLOW_ALL mode, ensure those categories are not disabled

        """

        changes = set()

        self.pruned_hooks_cache.clear()

        categories = set(categories)

        if self.hooks_mode is HOOKS_DENY_ALL:

            enabledcats = self.enabled_hook_cats

            changes = categories - enabledcats

            enabledcats |= changes # changes is small hence faster

        else:

            disabledcats = self.disabled_hook_cats

            changes = disabledcats & categories

            disabledcats -= changes # changes is small hence faster

        return tuple(changes)

    def is_hook_category_activated(self, category):

        """return a boolean telling if the given category is currently activated

        or not

        """

        if self.hooks_mode is HOOKS_DENY_ALL:

            return category in self.enabled_hook_cats

        return category not in self.disabled_hook_cats

    def is_hook_activated(self, hook):

        """return a boolean telling if the given hook class is currently

        activated or not

        """

        return self.is_hook_category_activated(hook.category)

    # Security management #####################################################

    @property

    def read_security(self):

        return self._read_security

    @read_security.setter

    def read_security(self, activated):

        oldmode = self._read_security

        self._read_security = activated

        # running_dbapi_query used to detect hooks triggered by a 'dbapi' query

        # (eg not issued on the session). This is tricky since we the execution

        # model of a (write) user query is:

        #

        # repository.execute (security enabled)

        #  \-> querier.execute

        #       \-> repo.glob_xxx (add/update/delete entity/relation)

        #            \-> deactivate security before calling hooks

        #                 \-> WE WANT TO CHECK QUERY NATURE HERE

        #                      \-> potentially, other calls to querier.execute

        #

        # so we can't rely on simply checking session.read_security, but

        # recalling the first transition from DEFAULT_SECURITY to something

        # else (False actually) is not perfect but should be enough

        #

        # also reset running_dbapi_query to true when we go back to

        # DEFAULT_SECURITY

        self.running_dbapi_query = (oldmode is DEFAULT_SECURITY

                                    or activated is DEFAULT_SECURITY)

def tx_attr(attr_name, writable=False):

    """return a property to forward attribute access to transaction.

    This is to be used by session"""

    args = {}

    def attr_from_tx(session):

        return getattr(session._tx, attr_name)

    args['fget'] = attr_from_tx

    if writable:

        def write_attr(session, value):

            return setattr(session._tx, attr_name, value)

        args['fset'] = write_attr

    return property(**args)

def tx_meth(meth_name):

    """return a function forwarding calls to transaction.

    This is to be used by session"""

    def meth_from_tx(session, *args, **kwargs):

        return getattr(session._tx, meth_name)(*args, **kwargs)

    return meth_from_tx