"""Repository users' and internal' sessions.

:organization: Logilab

:copyright: 2001-2010 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

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

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

from __future__ import with_statement

__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 rql.nodes import VariableRef, Function, ETYPE_PYOBJ_MAP, etype_from_pyobj

from yams import BASE_TYPES

from cubicweb import Binary, UnknownEid, schema

from cubicweb.req import RequestSessionBase

from cubicweb.dbapi import ConnectionProperties

from cubicweb.utils import make_uid, RepeatList

from cubicweb.rqlrewrite import RQLRewriter

ETYPE_PYOBJ_MAP[Binary] = 'Bytes'

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

# XXX rememberme,forgotpwd,apycot,vcsfile

def is_final(rqlst, variable, args):

    # try to find if this is a final var or not

    for select in rqlst.children:

        for sol in select.solutions:

            etype = variable.get_type(sol, args)

            if etype is None:

                continue

            if etype in BASE_TYPES:

                return True

            return False

def _make_description(selected, args, solution):

    """return a description for a result set"""

    description = []

    for term in selected:

        description.append(term.get_type(solution, args))

    return description

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.

    """

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

        self.session = session

        self.mode = mode

        self.categories = categories

    def __enter__(self):

        self.oldmode = self.session.set_hooks_mode(self.mode)

        if self.mode is self.session.HOOKS_DENY_ALL:

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

        else:

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

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

        if self.changes:

            if self.mode is self.session.HOOKS_DENY_ALL:

                self.session.disable_hook_categories(*self.changes)

            else:

                self.session.enable_hook_categories(*self.changes)

        self.session.set_hooks_mode(self.oldmode)

INDENT = ''

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

#        global INDENT

        if self.read is not None:

            self.oldread = self.session.set_read_security(self.read)

#            print INDENT + 'read', self.read, self.oldread

        if self.write is not None:

            self.oldwrite = self.session.set_write_security(self.write)

#            print INDENT + 'write', self.write, self.oldwrite

#        INDENT += '  '

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

#        global INDENT

#        INDENT = INDENT[:-2]

        if self.read is not None:

            self.session.set_read_security(self.oldread)

#            print INDENT + 'reset read to', self.oldread

        if self.write is not None:

            self.session.set_write_security(self.oldwrite)

#            print INDENT + 'reset write to', self.oldwrite

class Session(RequestSessionBase):

    """tie session id, user, connections pool and other session data all

    together

    """

    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(user.login.encode('UTF8'))

        cnxprops = cnxprops or ConnectionProperties('inmemory')

        self.user = user

        self.repo = repo

        self.cnxtype = cnxprops.cnxtype

        self.creation = time()

        self.timestamp = self.creation

        self.default_mode = 'read'

        # support undo for Create Update Delete entity / Add Remove relation

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

            self.undo_actions = ()

        else:

            self.undo_actions = set(repo.config['undo-support'].upper())

            if self.undo_actions - set('CUDAR'):

                raise Exception('bad undo-support string in configuration')

        # 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(cnxprops.lang)

        # internals

        self._threaddata = threading.local()

        self._threads_in_transaction = set()

        self._closed = False

    def __unicode__(self):

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

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

    def hijack_user(self, user):

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

        session = Session(user, self.repo)

        threaddata = session._threaddata

        threaddata.pool = self.pool

        # 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.

        """

        with security_enabled(self, False, False):

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

                entity = self.entity_from_eid(fromeid)

                entity[rtype] = toeid

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

            else:

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

    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[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.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

            entities.append(targetentity)

            entity._related_cache['%s_%s' % (rtype, role)] = (rset, tuple(entities))

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

        try:

            entity = self.entity_cache(eid)

        except KeyError:

            return

        rcache = entity.relation_cached(rtype, role)

        if rcache is not None:

            rset, entities = rcache

            for idx, row in enumerate(rset.rows):

                if row[0] == targeteid:

                    break

            else:

                # this may occurs if the cache has been filed by a hook

                # after the database update

                self.debug('cache inconsistency for %s %s %s %s', eid, rtype,

                           role, targeteid)

                return

            rset = rset.copy()

            entities = list(entities)

            del rset.rows[idx]

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

                del rset.description[idx]

            del entities[idx]

            rset.rowcount -= 1

            entity._related_cache['%s_%s' % (rtype, role)] = (rset, tuple(entities))

    # resource accessors ######################################################

    def system_sql(self, sql, args=None, rollback_on_failure=True):

        """return a sql cursor on the system database"""

        if sql.split(None, 1)[0].upper() != 'SELECT':

            self.mode = 'write'

        source = self.pool.source('system')

        try:

            return source.doexec(self, sql, args, rollback=rollback_on_failure)

        except (source.OperationalError, source.InterfaceError):

            source.warning("trying to reconnect")

            self.pool.reconnect(self)

            return source.doexec(self, sql, args, rollback=rollback_on_failure)

    def set_language(self, language):

        """i18n configuration for translation"""

        vreg = self.vreg

        language = language or self.user.property_value('ui.language')

        try:

            gettext, pgettext = vreg.config.translations[language]

            self._ = self.__ = gettext

            self.pgettext = pgettext

        except KeyError:

            language = vreg.property_value('ui.language')

            try:

                gettext, pgettext = vreg.config.translations[language]

                self._ = self.__ = gettext

                self.pgettext = pgettext

            except KeyError:

                self._ = self.__ = unicode

                self.pgettext = lambda x, y: y

        self.lang = language

    def change_property(self, prop, value):

        assert prop == 'lang' # this is the only one changeable property for now

        self.set_language(value)

    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.transaction_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.transaction_data.get('neweids', ())

    def schema_rproperty(self, rtype, eidfrom, eidto, rprop):

        rschema = self.repo.schema[rtype]

        subjtype = self.describe(eidfrom)[0]

        objtype = self.describe(eidto)[0]

        rdef = rschema.rdef(subjtype, objtype)

        return rdef.get(rprop)

    # security control #########################################################

    DEFAULT_SECURITY = object() # evaluated to true by design

    @property

    def read_security(self):

        """return a boolean telling if read security is activated or not"""

        try:

            return self._threaddata.read_security

        except AttributeError:

            self._threaddata.read_security = self.DEFAULT_SECURITY

            return self._threaddata.read_security

    def set_read_security(self, activated):

        """[de]activate read security, returning the previous value set for

        later restoration.

        you should usually use the `security_enabled` context manager instead

        of this to change security settings.

        """

        oldmode = self.read_security

        self._threaddata.read_security = activated

        # 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 dbapi_query to true when we go back to DEFAULT_SECURITY

        self._threaddata.dbapi_query = (oldmode is self.DEFAULT_SECURITY

                                        or activated is self.DEFAULT_SECURITY)

        return oldmode

    @property

    def write_security(self):