# 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

import json

import functools

from contextlib import contextmanager

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)

@deprecated('[3.17] use <object>.allow/deny_all_hooks_but instead')

def hooks_control(obj, mode, *categories):

    assert mode in  (HOOKS_ALLOW_ALL, HOOKS_DENY_ALL)

    if mode == HOOKS_ALLOW_ALL:

        return obj.allow_all_hooks_but(*categories)

    elif mode == HOOKS_DENY_ALL:

        return obj.deny_all_hooks_but(*categories)

class _hooks_control(object):

    """context manager to control activated hooks categories.

    If mode is`HOOKS_DENY_ALL`, given hooks categories will

    be enabled.

    If mode is `HOOKS_ALLOW_ALL`, given hooks categories will

    be disabled.

    .. sourcecode:: python

       with _hooks_control(cnx, HOOKS_ALLOW_ALL, 'integrity'):

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

       with _hooks_control(cnx, 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.Connection.deny_all_hooks_but` or

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

    Transaction methods.

    """

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

        assert mode in (HOOKS_ALLOW_ALL, HOOKS_DENY_ALL)

        self.cnx = cnx

        self.mode = mode

        self.categories = categories

        self.oldmode = None

        self.changes = ()

    def __enter__(self):

        self.oldmode = self.cnx.hooks_mode

        self.cnx.hooks_mode = self.mode

        if self.mode is HOOKS_DENY_ALL:

            self.changes = self.cnx.enable_hook_categories(*self.categories)

        else:

            self.changes = self.cnx.disable_hook_categories(*self.categories)

        self.cnx.ctx_count += 1

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

        self.cnx.ctx_count -= 1

        try:

            if self.categories:

                if self.mode is HOOKS_DENY_ALL:

                    self.cnx.disable_hook_categories(*self.categories)

                else:

                    self.cnx.enable_hook_categories(*self.categories)

        finally:

            self.cnx.hooks_mode = self.oldmode

class _session_hooks_control(_hooks_control):

    """hook control context manager for session

    Necessary to handle some unholy transaction scope logic."""

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

        self.session = session

        super_init = super(_session_hooks_control, self).__init__

        return super_init(session._cnx, mode, *categories)

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

        super_exit = super(_session_hooks_control, self).__exit__

        ret = super_exit(exctype, exc, traceback)

        if self.cnx.ctx_count == 0:

            self.session.close_cnx(self.cnx)

        return ret

@deprecated('[3.17] use <object>.security_enabled instead')

def security_enabled(obj, *args, **kwargs):

    return obj.security_enabled(*args, **kwargs)

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, cnx, read=None, write=None):

        self.cnx = cnx

        self.read = read

        self.write = write

        self.oldread = None

        self.oldwrite = None

    def __enter__(self):

        if self.read is None:

            self.oldread = None

        else:

            self.oldread = self.cnx.read_security

            self.cnx.read_security = self.read

        if self.write is None:

            self.oldwrite = None

        else:

            self.oldwrite = self.cnx.write_security

            self.cnx.write_security = self.write

        self.cnx.ctx_count += 1

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

        self.cnx.ctx_count -= 1

        if self.oldread is not None:

            self.cnx.read_security = self.oldread

        if self.oldwrite is not None:

            self.cnx.write_security = self.oldwrite

class _session_security_enabled(_security_enabled):

    """hook security context manager for session

    Necessary To handle some unholy transaction scope logic."""

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

        self.session = session

        super_init = super(_session_security_enabled, self).__init__

        return super_init(session._cnx, read=read, write=write)

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

        super_exit = super(_session_security_enabled, self).__exit__

        ret = super_exit(exctype, exc, traceback)

        if self.cnx.ctx_count == 0:

            self.session.close_cnx(self.cnx)

        return ret

HOOKS_ALLOW_ALL = object()

HOOKS_DENY_ALL = object()

DEFAULT_SECURITY = object() # evaluated to true by design

class SessionClosedError(RuntimeError):

    pass

class CnxSetTracker(object):

    """Keep track of which connection use which cnxset.

    There should be one of this object per session plus one another for

    internal session.

    Session object are responsible of creating their CnxSetTracker object.

    Connection should use the :meth:`record` and :meth:`forget` to inform the

    tracker of cnxset they have acquired.

    .. automethod:: cubicweb.server.session.CnxSetTracker.record

    .. automethod:: cubicweb.server.session.CnxSetTracker.forget

    Session use the :meth:`close` and :meth:`wait` method when closing.

    .. automethod:: cubicweb.server.session.CnxSetTracker.close

    .. automethod:: cubicweb.server.session.CnxSetTracker.wait

    This object itself is threadsafe. It also requires caller to acquired its

    lock in some situation.

    """

    def __init__(self):

        self._active = True

        self._condition = threading.Condition()

        self._record = {}

    def __enter__(self):

        self._condition.__enter__()

    def __exit__(self, *args):

        self._condition.__exit__(*args)

    def record(self, cnxid, cnxset):

        """Inform the tracker that a cnxid have acquired a cnxset

        This methode is to be used by Connection object.

        This method fails when:

        - The cnxid already have a recorded cnxset.

        - The tracker is not active anymore.

        Notes about the caller:

        (1) It is responsible for retrieving a cnxset.

        (2) It must be prepared to release the cnxset if the

            `cnxsettracker.forget` call fails.

        (3) It should acquire the tracker lock until the very end of the operation.

        (4) However It take care to lock the CnxSetTracker object after having

            retrieved the cnxset to prevent deadlock.

        A typical usage look like::

        cnxset = repo._get_cnxset() # (1)

        try:

            with cnxset_tracker: # (3) and (4)

                cnxset_tracker.record(caller.id, cnxset)

                # (3') operation ends when caller is in expected state only

                caller.cnxset = cnxset

        except Exception:

            repo._free_cnxset(cnxset) # (2)

            raise

        """

        # dubious since the caller is suppose to have acquired it anyway.

        with self._condition:

            if not self._active:

                raise SessionClosedError('Closed')

            old = self._record.get(cnxid)

            if old is not None:

                raise ValueError('"%s" already have a cnx_set (%r)'

                                 % (cnxid, old))

            self._record[cnxid] = cnxset

    def forget(self, cnxid, cnxset):

        """Inform the tracker that a cnxid have release a cnxset

        This methode is to be used by Connection object.

        This method fails when:

        - The cnxset for the cnxid does not match the recorded one.

        Notes about the caller:

        (1) It is responsible for releasing the cnxset.

        (2) It should acquire the tracker lock during the operation to ensure

            the internal tracker state is always accurate regarding its own state.

        A typical usage look like::

        cnxset = caller.cnxset

        try:

            with cnxset_tracker:

                # (2) you can not have caller.cnxset out of sync with

                #     cnxset_tracker state while unlocked

                caller.cnxset = None

                cnxset_tracker.forget(caller.id, cnxset)

        finally:

            cnxset = repo._free_cnxset(cnxset) # (1)

        """

        with self._condition:

            old = self._record.get(cnxid, None)

            if old is not cnxset:

                raise ValueError('recorded cnxset for "%s" mismatch: %r != %r'

                                 % (cnxid, old, cnxset))

            self._record.pop(cnxid)

            self._condition.notify_all()

    def close(self):

        """Marks the tracker as inactive.

        This methode is to be used by Session object.

        Inactive tracker does not accept new record anymore.

        """

        with self._condition:

            self._active = False

    def wait(self, timeout=10):

        """Wait for all recorded cnxset to be released

        This methode is to be used by Session object.

        returns a tuple of connection id that remains open.

        """

        with self._condition:

            if  self._active:

                raise RuntimeError('Cannot wait on active tracker.'

                                   ' Call tracker.close() first')

            while self._record and timeout > 0:

                start = time()

                self._condition.wait(timeout)

                timeout -= time() - start

            return tuple(self._record)

def _with_cnx_set(func):

    """decorator for Connection method that ensure they run with a cnxset """

    @functools.wraps(func)

    def wrapper(cnx, *args, **kwargs):

        with cnx.ensure_cnx_set:

            return func(cnx, *args, **kwargs)

    return wrapper

class Connection(RequestSessionBase):

    """Repository Connection

    Holds all connection 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 connection with a reasonable low

      connection set pool size. control mechanism is detailed below

    .. automethod:: cubicweb.server.session.Connection.set_cnxset

    .. automethod:: cubicweb.server.session.Connection.free_cnxset

      :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