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

import Queue

from warnings import warn

from itertools import chain

from time import time, localtime, strftime

from contextlib import contextmanager

from logilab.common.decorators import cached, clear_cache

from logilab.common.deprecation import deprecated

from yams import BadSchemaDefinition

from rql.utils import rqlvar_maker

from cubicweb import (CW_MIGRATION_MAP, QueryError,

                      UnknownEid, AuthenticationError, ExecutionError,

                      BadConnectionId, ValidationError, Unauthorized,

                      UniqueTogetherError, onevent, ViolatedConstraint)

from cubicweb import cwvreg, schema, server

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

from cubicweb.server.session import Session, InternalManager

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

                           ('created_by', 'object'),

                           ('cw_source', 'object'),

                           ])

def prefill_entity_caches(entity):

    cnx = 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',

                                         cnx.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', cnx.empty_rset())

def del_existing_rel_if_needed(cnx, 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 cnx.is_hook_category_activated('activeintegrity'):

        return

    rdef = cnx.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 cnx.security_enabled(read=False):

            cnx.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 cnx.security_enabled(read=False):

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

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

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

def preprocess_inlined_relations(cnx, entity):

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

    requires to be extrated for proper call hooks

    """

    relations = []

    activeintegrity = cnx.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))

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

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

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

                with cnx.security_enabled(read=False):

                    cnx.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()

    #@locked

    def _get_cnxset(self):

        try:

            return self._cnxsets_pool.get(True, timeout=5)