# copyright 2003-2017 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."""

from __future__ import print_function

import functools

import sys

from uuid import uuid4

from contextlib import contextmanager

from logging import getLogger

from six import text_type

from logilab.common.registry import objectify_predicate

from cubicweb import QueryError, ProgrammingError, schema, server

from cubicweb import set_log_methods

from cubicweb.req import RequestSessionBase

from cubicweb.rqlrewrite import RQLRewriter

from cubicweb.server.edition import EditedEntity

NO_UNDO_TYPES = schema.SCHEMA_TYPES.copy()

NO_UNDO_TYPES.add('CWSession')

NO_UNDO_TYPES.add('CWDataImport')

# 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 _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`

    Connection methods.

    """

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

        assert mode in (HOOKS_ALLOW_ALL, HOOKS_DENY_ALL)

        self.cnx = cnx

        self.mode = mode

        self.categories = set(categories)

        self.old_mode = None

        self.old_categories = None

    def __enter__(self):

        self.old_mode = self.cnx._hooks_mode

        self.old_categories = self.cnx._hooks_categories

        self.cnx._hooks_mode = self.mode

        self.cnx._hooks_categories = self.categories

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

        self.cnx._hooks_mode = self.old_mode

        self.cnx._hooks_categories = self.old_categories

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

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

        if self.oldread is not None:

            self.cnx.read_security = self.oldread

        if self.oldwrite is not None:

            self.cnx.write_security = self.oldwrite

HOOKS_ALLOW_ALL = object()

HOOKS_DENY_ALL = object()

DEFAULT_SECURITY = object()  # evaluated to true by design

def _open_only(func):

    """decorator for Connection method that check it is open"""

    @functools.wraps(func)

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

        if not cnx._open:

            raise ProgrammingError('Closed Connection: %s' % cnx)

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

    return check_open

class Connection(RequestSessionBase):

    """Repository Connection

    Holds all connection related data

    Database connection resources:

      :attr:`hooks_in_progress`, boolean flag telling if the executing

      query is coming from a repoapi connection or is a query from

      within the repository (e.g. started by hooks)

      :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 queries. This allows multiple connections with a reasonably 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)

    Shared data:

      :attr:`data` is a dictionary bound to the underlying session,

      who will be present for the life time of the session. This may

      be useful for web clients that rely on the server for managing

      bits of session-scoped data.

      :attr:`transaction_data` is a dictionary cleared at the end of

      the transaction. Hooks and operations may put arbitrary data in

      there.

    Internal state:

      :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 rolled back).

    Hooks controls:

    .. automethod:: cubicweb.server.session.Connection.deny_all_hooks_but

    .. automethod:: cubicweb.server.session.Connection.allow_all_hooks_but

    Security level Management:

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

      read/write security is currently activated.

    """

    is_request = False

    hooks_in_progress = False

    def __init__(self, repo, user):

        super(Connection, self).__init__(repo.vreg)

        #: connection unique id

        self._open = None

        #: server.Repository object

        self.repo = repo

        self.vreg = self.repo.vreg

        self._execute = self.repo.querier.execute

        # internal (root) session

        self.is_internal_session = isinstance(user, InternalManager)

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

        self.transaction_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

        # `_hooks_mode`, may be either `HOOKS_ALLOW_ALL` or `HOOKS_DENY_ALL`.

        self._hooks_mode = HOOKS_ALLOW_ALL

        # `_hooks_categories`, when :attr:`_hooks_mode` is `HOOKS_DENY_ALL`,

        # this set contains hooks categories that are enabled ;

        # when :attr:`_hooks_mode` is `HOOKS_ALLOW_ALL`, it contains hooks

        # categories that are disabled.

        self._hooks_categories = set()

        self.pruned_hooks_cache = {}

        # security control attributes

        self._read_security = DEFAULT_SECURITY  # handled by a property

        self.write_security = DEFAULT_SECURITY

        # undo control

        config = repo.config

        if config.creating or config.repairing or self.is_internal_session:

            self.undo_actions = False

        else:

            self.undo_actions = config['undo-enabled']

        # RQLRewriter are not thread safe

        self._rewriter = RQLRewriter(self)

        # other session utility

        if user.login == '__internal_manager__':

            self.user = user

        else:

            self._set_user(user)

    @_open_only

    def get_schema(self):

        """Return the schema currently used by the repository."""

        return self.repo.source_defs()

    @_open_only

    def get_option_value(self, option):

        """Return the value for `option` in the configuration."""

        return self.repo.get_option_value(option)

    # transaction api

    @_open_only

    def undoable_transactions(self, ueid=None, **actionfilters):

        """Return a list of undoable transaction objects by the connection's

        user, ordered by descendant transaction time.

        Managers may filter according to user (eid) who has done the transaction

        using the `ueid` argument. Others will only see their own transactions.

        Additional filtering capabilities is provided by using the following

        named arguments:

        * `etype` to get only transactions creating/updating/deleting entities

          of the given type

        * `eid` to get only transactions applied to entity of the given eid

        * `action` to get only transactions doing the given action (action in

          'C', 'U', 'D', 'A', 'R'). If `etype`, action can only be 'C', 'U' or

          'D'.

        * `public`: when additional filtering is provided, they are by default

          only searched in 'public' actions, unless a `public` argument is given

          and set to false.

        """

        return self.repo.system_source.undoable_transactions(self, ueid,

                                                             **actionfilters)

    @_open_only

    def transaction_info(self, txuuid):

        """Return transaction object for the given uid.

        raise `NoSuchTransaction` if not found or if session's user is

        not allowed (eg not in managers group and the transaction

        doesn't belong to him).

        """

        return self.repo.system_source.tx_info(self, txuuid)

    @_open_only

    def transaction_actions(self, txuuid, public=True):

        """Return an ordered list of actions effectued during that transaction.

        If public is true, return only 'public' actions, i.e. not ones

        triggered under the cover by hooks, else return all actions.

        raise `NoSuchTransaction` if the transaction is not found or

        if the user is not allowed (eg not in managers group).

        """

        return self.repo.system_source.tx_actions(self, txuuid, public)

    @_open_only

    def undo_transaction(self, txuuid):

        """Undo the given transaction. Return potential restoration errors.

        raise `NoSuchTransaction` if not found or if user is not

        allowed (eg not in managers group).

        """

        return self.repo.system_source.undo_transaction(self, txuuid)

    # life cycle handling ####################################################

    def __enter__(self):

        assert not self._open

        self._open = True

        self.cnxset = self.repo.cnxsets.get()

        if self.lang is None:

            self.set_language(self.user.prefered_language())

        return self

    def __exit__(self, exctype=None, excvalue=None, tb=None):

        assert self._open  # actually already open

        self.rollback()

        self._open = False

        self.cnxset.cnxset_freed()

        self.repo.cnxsets.release(self.cnxset)

        self.cnxset = None

    @contextmanager

    def running_hooks_ops(self):

        """this context manager should be called whenever hooks or operations

        are about to be run (but after hook selection)

        It will help the undo logic record pertinent metadata or some

        hooks to run (or not) depending on who/what issued the query.

        """

        prevmode = self.hooks_in_progress

        self.hooks_in_progress = True

        yield

        self.hooks_in_progress = prevmode

    # shared data handling ###################################################

    @property

    def rql_rewriter(self):

        return self._rewriter

    def clear(self):

        """reset internal data"""

        self.transaction_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 = {}

        self.local_perm_cache.clear()

        self.rewriter = RQLRewriter(self)

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

    #

    # The connection entity cache as held in cnx.transaction_data is removed at the

    # end of the connection (commit and rollback)

    #

    # XXX connection 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 connection entity cache"""

        # XXX not using _open_only because before at creation time. _set_user

        # call this function to cache the Connection user.

        if entity.cw_etype != 'CWUser' and not self._open:

            raise ProgrammingError('Closed Connection: %s' % self)

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

        ecache.setdefault(entity.eid, entity)