# copyright 2003-2014 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/>.

"""Defines the central class for the CubicWeb RQL server: the repository.

The repository is an abstraction allowing execution of rql queries against

data sources. Most of the work is actually done in helper classes. The

repository mainly:

* brings these classes all together to provide a single access

  point to a cubicweb instance.

* handles session management

"""

__docformat__ = "restructuredtext en"

import sys

import threading

import Queue

from warnings import warn

from itertools import chain

from time import time, localtime, strftime

from contextlib import contextmanager

from warnings import warn

from logilab.common.decorators import cached, clear_cache

from logilab.common.deprecation import deprecated

from yams import BadSchemaDefinition

from rql import RQLSyntaxError

from rql.utils import rqlvar_maker

from cubicweb import (CW_MIGRATION_MAP, QueryError,

                      UnknownEid, AuthenticationError, ExecutionError,

                      BadConnectionId, Unauthorized, ValidationError,

                      UniqueTogetherError, onevent)

from cubicweb import cwvreg, schema, server

from cubicweb.server import ShuttingDown, utils, hook, querier, sources

from cubicweb.server.session import Session, InternalSession, InternalManager

from cubicweb.server.ssplanner import EditedEntity

NO_CACHE_RELATIONS = set( [('owned_by', 'object'),

                           ('created_by', 'object'),

                           ('cw_source', 'object'),

                           ])

def prefill_entity_caches(entity):

    session = entity._cw

    # prefill entity relation caches

    for rschema in entity.e_schema.subject_relations():

        rtype = str(rschema)

        if rtype in schema.VIRTUAL_RTYPES or (rtype, 'subject') in NO_CACHE_RELATIONS:

            continue

        if rschema.final:

            entity.cw_attr_cache.setdefault(rtype, None)

        else:

            entity.cw_set_relation_cache(rtype, 'subject',

                                         session.empty_rset())

    for rschema in entity.e_schema.object_relations():

        rtype = str(rschema)

        if rtype in schema.VIRTUAL_RTYPES or (rtype, 'object') in NO_CACHE_RELATIONS:

            continue

        entity.cw_set_relation_cache(rtype, 'object', session.empty_rset())

def del_existing_rel_if_needed(session, eidfrom, rtype, eidto):

    """delete existing relation when adding a new one if card is 1 or ?

    have to be done once the new relation has been inserted to avoid having

    an entity without a relation for some time

    this kind of behaviour has to be done in the repository so we don't have

    hooks order hazardness

    """

    # skip that if integrity explicitly disabled

    if not session.is_hook_category_activated('activeintegrity'):

        return

    rdef = session.rtype_eids_rdef(rtype, eidfrom, eidto)

    card = rdef.cardinality

    # one may be tented to check for neweids but this may cause more than one

    # relation even with '1?'  cardinality if thoses relations are added in the

    # same transaction where the entity is being created. This never occurs from

    # the web interface but may occurs during test or dbapi connection (though

    # not expected for this).  So: don't do it, we pretend to ensure repository

    # consistency.

    #

    # notes:

    # * inlined relations will be implicitly deleted for the subject entity

    # * we don't want read permissions to be applied but we want delete

    #   permission to be checked

    if card[0] in '1?':

        with session.security_enabled(read=False):

            session.execute('DELETE X %s Y WHERE X eid %%(x)s, '

                            'NOT Y eid %%(y)s' % rtype,

                                {'x': eidfrom, 'y': eidto})

    if card[1] in '1?':

        with session.security_enabled(read=False):

            session.execute('DELETE X %s Y WHERE Y eid %%(y)s, '

                            'NOT X eid %%(x)s' % rtype,

                            {'x': eidfrom, 'y': eidto})

def preprocess_inlined_relations(session, entity):

    """when an entity is added, check if it has some inlined relation which

    requires to be extrated for proper call hooks

    """

    relations = []

    activeintegrity = session.is_hook_category_activated('activeintegrity')

    eschema = entity.e_schema

    for attr in entity.cw_edited:

        rschema = eschema.subjrels[attr]

        if not rschema.final: # inlined relation

            value = entity.cw_edited[attr]

            relations.append((attr, value))

            session.update_rel_cache_add(entity.eid, attr, value)

            rdef = session.rtype_eids_rdef(attr, entity.eid, value)

            if rdef.cardinality[1] in '1?' and activeintegrity:

                with session.security_enabled(read=False):

                    session.execute('DELETE X %s Y WHERE Y eid %%(y)s' % attr,

                                    {'x': entity.eid, 'y': value})

    return relations

class NullEventBus(object):

    def publish(self, msg):

        pass

    def add_subscription(self, topic, callback):

        pass

    def start(self):

        pass

    def stop(self):

        pass

class Repository(object):

    """a repository provides access to a set of persistent storages for

    entities and relations

    """

    def __init__(self, config, tasks_manager=None, vreg=None):

        self.config = config

        if vreg is None:

            vreg = cwvreg.CWRegistryStore(config)

        self.vreg = vreg

        self._tasks_manager = tasks_manager

        self.app_instances_bus = NullEventBus()

        self.info('starting repository from %s', self.config.apphome)

        # dictionary of opened sessions

        self._sessions = {}

        # list of functions to be called at regular interval

        # list of running threads

        self._running_threads = []

        # initial schema, should be build or replaced latter

        self.schema = schema.CubicWebSchema(config.appid)

        self.vreg.schema = self.schema # until actual schema is loaded...

        # shutdown flag

        self.shutting_down = False

        # sources (additional sources info in the system database)

        self.system_source = self.get_source('native', 'system',

                                             config.system_source_config.copy())

        self.sources_by_uri = {'system': self.system_source}

        # querier helper, need to be created after sources initialization

        self.querier = querier.QuerierHelper(self, self.schema)

        # cache eid -> (type, extid, actual source)

        self._type_source_cache = {}

        # cache extid -> eid

        self._extid_cache = {}

        # open some connection sets

        if config.init_cnxset_pool:

            self.init_cnxset_pool()

        # the hooks manager

        self.hm = hook.HooksManager(self.vreg)

        # registry hook to fix user class on registry reload

        @onevent('after-registry-reload', self)

        def fix_user_classes(self):

            # After registery reload the 'CWUser' class used for CWEtype

            # changed.  To any existing user object have a different class than

            # the new loaded one. We are hot fixing this.

            usercls = self.vreg['etypes'].etype_class('CWUser')

            for session in self._sessions.itervalues():

                if not isinstance(session.user, InternalManager):

                    session.user.__class__ = usercls

    def init_cnxset_pool(self):

        """should be called bootstrap_repository, as this is what it does"""

        config = self.config

        self._cnxsets_pool = Queue.Queue()

        # 0. init a cnxset that will be used to fetch bootstrap information from

        #    the database

        self._cnxsets_pool.put_nowait(self.system_source.wrapped_connection())

        # 1. set used cubes

        if config.creating or not config.read_instance_schema:

            config.bootstrap_cubes()

        else:

            self.set_schema(self.config.load_bootstrap_schema(), resetvreg=False)

            config.init_cubes(self.get_cubes())

        # 2. load schema

        if config.quick_start:

            # quick start: only to get a minimal repository to get cubes

            # information (eg dump/restore/...)

            #

            # restrict appobject_path to only load hooks and entity classes in

            # the registry

            config.cube_appobject_path = set(('hooks', 'entities'))

            config.cubicweb_appobject_path = set(('hooks', 'entities'))

            # limit connections pool to 1

            config['connections-pool-size'] = 1

        if config.quick_start or config.creating or not config.read_instance_schema:

            # load schema from the file system

            if not config.creating:

                self.warning("set fs instance'schema")

            self.set_schema(config.load_schema(expand_cubes=True))

        else:

            # normal start: load the instance schema from the database

            self.info('loading schema from the repository')

            self.set_schema(self.deserialize_schema())

        # 3. initialize data sources

        if config.creating:

            # call init_creating so that for instance native source can

            # configurate tsearch according to postgres version

            self.system_source.init_creating()

        else:

            self.init_sources_from_database()

            if 'CWProperty' in self.schema:

                self.vreg.init_properties(self.properties())

        # 4. close initialization connection set and reopen fresh ones for

        #    proper initialization

        self._get_cnxset().close(True)

        self.cnxsets = [] # list of available cnxsets (can't iterate on a Queue)

        for i in xrange(config['connections-pool-size']):

            self.cnxsets.append(self.system_source.wrapped_connection())

            self._cnxsets_pool.put_nowait(self.cnxsets[-1])

    # internals ###############################################################

    def init_sources_from_database(self):

        self.sources_by_eid = {}

        if self.config.quick_start \

               or not 'CWSource' in self.schema: # # 3.10 migration

            self.system_source.init_creating()

            return

        with self.internal_cnx() as cnx:

            # FIXME: sources should be ordered (add_entity priority)

            for sourceent in cnx.execute(

                'Any S, SN, SA, SC WHERE S is_instance_of CWSource, '

                'S name SN, S type SA, S config SC').entities():

                if sourceent.name == 'system':

                    self.system_source.eid = sourceent.eid

                    self.sources_by_eid[sourceent.eid] = self.system_source

                    self.system_source.init(True, sourceent)

                    continue

                self.add_source(sourceent)

    def _clear_planning_caches(self):

        clear_cache(self, 'source_defs')

    def add_source(self, sourceent):

        try:

            source = self.get_source(sourceent.type, sourceent.name,

                                     sourceent.host_config, sourceent.eid)

        except RuntimeError:

            if self.config.repairing:

                self.exception('cant setup source %s, skipped', sourceent.name)

                return

            raise

        self.sources_by_eid[sourceent.eid] = source

        self.sources_by_uri[sourceent.name] = source

        if self.config.source_enabled(source):

            # call source's init method to complete their initialisation if

            # needed (for instance looking for persistent configuration using an

            # internal session, which is not possible until connections sets have been

            # initialized)

            source.init(True, sourceent)

        else:

            source.init(False, sourceent)

        self._clear_planning_caches()

    def remove_source(self, uri):

        source = self.sources_by_uri.pop(uri)

        del self.sources_by_eid[source.eid]

        self._clear_planning_caches()

    def get_source(self, type, uri, source_config, eid=None):

        # set uri and type in source config so it's available through

        # source_defs()

        source_config['uri'] = uri

        source_config['type'] = type

        return sources.get_source(type, source_config, self, eid)

    def set_schema(self, schema, resetvreg=True):

        self.info('set schema %s %#x', schema.name, id(schema))

        if resetvreg:

            # trigger full reload of all appobjects

            self.vreg.set_schema(schema)

        else:

            self.vreg._set_schema(schema)

        self.querier.set_schema(schema)

        for source in self.sources_by_uri.itervalues():

            source.set_schema(schema)

        self.schema = schema

    def deserialize_schema(self):

        """load schema from the database"""

        from cubicweb.server.schemaserial import deserialize_schema

        appschema = schema.CubicWebSchema(self.config.appid)

        self.debug('deserializing db schema into %s %#x', appschema.name, id(appschema))

        with self.internal_cnx() as cnx:

            try:

                deserialize_schema(appschema, cnx)

            except BadSchemaDefinition:

                raise

            except Exception as ex:

                import traceback

                traceback.print_exc()

                raise Exception('Is the database initialised ? (cause: %s)' % ex)

        return appschema

    def _prepare_startup(self):

        """Prepare "Repository as a server" for startup.

        * trigger server startup hook,

        * register session clean up task.

        """

        if not (self.config.creating or self.config.repairing

                or self.config.quick_start):

            # call instance level initialisation hooks

            self.hm.call_hooks('server_startup', repo=self)

            # register a task to cleanup expired session

            self.cleanup_session_time = self.config['cleanup-session-time'] or 60 * 60 * 24

            assert self.cleanup_session_time > 0

            cleanup_session_interval = min(60*60, self.cleanup_session_time / 3)

            assert self._tasks_manager is not None, "This Repository is not intended to be used as a server"

            self._tasks_manager.add_looping_task(cleanup_session_interval,

                                                 self.clean_sessions)

    def start_looping_tasks(self):

        """Actual "Repository as a server" startup.

        * trigger server startup hook,

        * register session clean up task,

        * start all tasks.

        XXX Other startup related stuffs are done elsewhere. In Repository

        XXX __init__ or in external codes (various server managers).

        """

        self._prepare_startup()

        assert self._tasks_manager is not None, "This Repository is not intended to be used as a server"

        self._tasks_manager.start()

    def looping_task(self, interval, func, *args):

        """register a function to be called every `interval` seconds.

        looping tasks can only be registered during repository initialization,

        once done this method will fail.

        """

        assert self._tasks_manager is not None, "This Repository is not intended to be used as a server"

        self._tasks_manager.add_looping_task(interval, func, *args)

    def threaded_task(self, func):

        """start function in a separated thread"""

        utils.RepoThread(func, self._running_threads).start()