# 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):

    """repository side only predicate returning 1 if the session is a regular

    user session and not an internal session

    """

    return not req.is_internal_session

@objectify_predicate

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

    """repository side only predicate returning 1 if the session is not a regular

    user session but an internal session

    """

    return req.is_internal_session

@objectify_predicate

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

    """repository side only predicate returning 1 if the session is not a regular

    user session but an internal session

    """

    return req.vreg.config.repairing

class transaction(object):

    """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, since 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)

class TransactionData(object):

    def __init__(self, txid):

        self.transactionid = txid

        self.ctx_count = 0

class Session(RequestSessionBase):

    """Repository usersession, tie a session id, user, connections set and

    other session data all together.

    About session storage / transactions

    ------------------------------------

    Here is a description of internal session attributes. Besides :attr:`data`

    and :attr:`transaction_data`, you should not have to use attributes

    described here but higher level APIs.

      :attr:`data` is a dictionary containing shared data, used to communicate

      extra information between the client and the repository

      :attr:`_tx_data` is a dictionary of :class:`TransactionData` instance, one

      for each running transaction. The key is the transaction id. By default

      the transaction id is the thread name but it can be otherwise (per dbapi

      cursor for instance, or per thread name *from another process*).

      :attr:`__threaddata` is a thread local storage whose `txdata` attribute

      refers to the proper instance of :class:`TransactionData` according to the

      transaction.

      :attr:`_threads_in_transaction` is a set of (thread, connections set)

      referencing threads that currently hold a connections set for the session.

    You should not have to use neither :attr:`_txdata` nor :attr:`__threaddata`,

    simply access transaction data transparently through the :attr:`_threaddata`

    property. Also, you usually don't have to access it directly since current

    transaction's data may be accessed/modified through properties / methods:

      :attr:`transaction_data`, similarly to :attr:`data`, is a dictionary

      containing some shared data that should be 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:`cnxset`, the connections set to use to execute queries on sources.

      During a transaction, the connection set may be freed so that is may be

      used by another session as long as no writing is done. This means we can

      have multiple sessions with a reasonably low connections set pool size.

      :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)

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

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

      read/write security is currently activated.

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

      :attr:`enabled_hook_categories`, when :attr:`hooks_mode` is

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

      :attr:`disabled_hook_categories`, when :attr:`hooks_mode` is

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

      :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

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

    .. automethod:: cubicweb.server.session.all_all_hooks_but

    """

    is_request = False

    is_internal_session = False

    def __init__(self, user, repo, cnxprops=None, _id=None):

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

        self.id = _id or make_uid(unormalize(user.login).encode('UTF8'))

        self.user = user

        self.repo = repo

        self.timestamp = time()

        self.default_mode = 'read'

        # undo support

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

            self.undo_actions = False

        else:

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

        # short cut to querier .execute method

        self._execute = repo.querier.execute

        # shared data, used to communicate extra information between the client

        # and the rql server

        self.data = {}

        # i18n initialization

        self.set_language(user.prefered_language())

        # internals

        self._tx_data = {}

        self.__threaddata = threading.local()

        self._threads_in_transaction = set()

        self._closed = False

        self._closed_lock = threading.Lock()

    def __unicode__(self):

        return '<session %s (%s 0x%x)>' % (

            unicode(self.user.login), self.id, id(self))

    def transaction(self, free_cnxset=True):

        """return context manager to enter a transaction for the session: when

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

        call `session.commit()` on normal exit.

        The `free_cnxset` will be given to rollback/commit methods to indicate

        wether the connections set should be freed or not.

        """

        return transaction(self, free_cnxset)

    def set_tx_data(self, txid=None):

        if txid is None:

            txid = threading.currentThread().getName()

        try:

            self.__threaddata.txdata = self._tx_data[txid]

        except KeyError:

            self.__threaddata.txdata = self._tx_data[txid] = TransactionData(txid)

    @property

    def _threaddata(self):

        try:

            return self.__threaddata.txdata

        except AttributeError:

            self.set_tx_data()

            return self.__threaddata.txdata

    def get_option_value(self, option, foreid=None):

        return self.repo.get_option_value(option, foreid)

    def hijack_user(self, user):

        """return a fake request/session using specified user"""

        session = Session(user, self.repo)

        threaddata = session._threaddata

        threaddata.cnxset = self.cnxset

        # we attributed a connections set, need to update ctx_count else it will be freed

        # while undesired

        threaddata.ctx_count = 1

        # share pending_operations, else operation added in the hi-jacked

        # session such as SendMailOp won't ever be processed

        threaddata.pending_operations = self.pending_operations

        # everything in transaction_data should be copied back but the entity

        # type cache we don't want to avoid security pb

        threaddata.transaction_data = self.transaction_data.copy()

        threaddata.transaction_data.pop('ecache', None)

        return session

    def add_relation(self, fromeid, rtype, toeid):

        """provide direct access to the repository method to add a relation.

        This is equivalent to the following rql query:

          SET X rtype Y WHERE X eid  fromeid, T eid toeid

        without read security check but also all the burden of rql execution.

        You may use this in hooks when you know both eids of the relation you

        want to add.

        """

        self.add_relations([(rtype, [(fromeid,  toeid)])])

    def add_relations(self, relations):

        '''set many relation using a shortcut similar to the one in add_relation

        relations is a list of 2-uples, the first element of each

        2-uple is the rtype, and the second is a list of (fromeid,

        toeid) tuples

        '''

        edited_entities = {}

        relations_dict = {}

        with security_enabled(self, False, False):

            for rtype, eids in relations:

                if self.vreg.schema[rtype].inlined:

                    for fromeid, toeid in eids:

                        if fromeid not in edited_entities:

                            entity = self.entity_from_eid(fromeid)

                            edited = EditedEntity(entity)

                            edited_entities[fromeid] = edited

                        else:

                            edited = edited_entities[fromeid]

                        edited.edited_attribute(rtype, toeid)

                else:

                    relations_dict[rtype] = eids

            self.repo.glob_add_relations(self, relations_dict)

            for edited in edited_entities.itervalues():

                self.repo.glob_update_entity(self, edited)

    def delete_relation(self, fromeid, rtype, toeid):

        """provide direct access to the repository method to delete a relation.

        This is equivalent to the following rql query:

          DELETE X rtype Y WHERE X eid  fromeid, T eid toeid

        without read security check but also all the burden of rql execution.

        You may use this in hooks when you know both eids of the relation you

        want to delete.

        """

        with security_enabled(self, False, False):

            if self.vreg.schema[rtype].inlined:

                entity = self.entity_from_eid(fromeid)

                entity.cw_attr_cache[rtype] = None

                self.repo.glob_update_entity(self, entity, set((rtype,)))

            else:

                self.repo.glob_delete_relation(self, fromeid, rtype, toeid)

    # relations cache handling #################################################

    def update_rel_cache_add(self, subject, rtype, object, symmetric=False):

        self._update_entity_rel_cache_add(subject, rtype, 'subject', object)

        if symmetric:

            self._update_entity_rel_cache_add(object, rtype, 'subject', subject)

        else:

            self._update_entity_rel_cache_add(object, rtype, 'object', subject)

    def update_rel_cache_del(self, subject, rtype, object, symmetric=False):

        self._update_entity_rel_cache_del(subject, rtype, 'subject', object)

        if symmetric:

            self._update_entity_rel_cache_del(object, rtype, 'object', object)

        else:

            self._update_entity_rel_cache_del(object, rtype, 'object', subject)

    def _update_entity_rel_cache_add(self, eid, rtype, role, targeteid):

        try:

            entity = self.entity_cache(eid)

        except KeyError:

            return

        rcache = entity.cw_relation_cached(rtype, role)

        if rcache is not None:

            rset, entities = rcache

            rset = rset.copy()

            entities = list(entities)

            rset.rows.append([targeteid])

            if not isinstance(rset.description, list): # else description not set

                rset.description = list(rset.description)

            rset.description.append([self.describe(targeteid)[0]])

            targetentity = self.entity_from_eid(targeteid)

            if targetentity.cw_rset is None:

                targetentity.cw_rset = rset

                targetentity.cw_row = rset.rowcount

                targetentity.cw_col = 0

            rset.rowcount += 1