# copyright 2003-2016 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

"""

from itertools import chain

from contextlib import contextmanager

from logging import getLogger

import queue

from logilab.common.decorators import cached, clear_cache

from yams import BadSchemaDefinition

from rql.utils import rqlvar_maker

from cubicweb import (CW_MIGRATION_MAP,

                      UnknownEid, AuthenticationError, ExecutionError,

                      UniqueTogetherError, ViolatedConstraint)

from cubicweb import set_log_methods

from cubicweb import cwvreg, schema, server

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

from cubicweb.server.session import InternalManager, Connection

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

    def __init__(self, source, size):

        self._cnxsets = []

        if size is not None:

            self._queue = queue.Queue()

            for i in range(size):

                cnxset = source.wrapped_connection()

                self._cnxsets.append(cnxset)

                self._queue.put_nowait(cnxset)

        else:

            self._queue = None

            self._source = source

    def qsize(self):

        if self._queue is None:

            return None

        return self._queue.qsize()

    def get(self):

        if self._queue is None:

            return self._source.wrapped_connection()

        try:

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

        except queue.Empty:

            raise Exception('no connections set available after 5 secs, probably either a '

                            'bug in code (too many uncommited/rolled back '

                            'connections) or too much load on the server (in '

                            'which case you can try to set a bigger '

                            'connections pool size)')

    def release(self, cnxset):

        if self._queue is None:

            cnxset.close(True)

        else:

            self._queue.put_nowait(cnxset)

    def __iter__(self):

        for cnxset in self._cnxsets:

            yield cnxset

    def close(self):

        if self._queue is not None:

            while not self._queue.empty():

                cnxset = self._queue.get_nowait()

                try:

                    cnxset.close(True)

                except Exception as e:

                    self.exception('error while closing %s, error: %s' % (cnxset, e))

class Repository(object):

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

    entities and relations

    """

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

        self.config = config

        if vreg is None:

            vreg = cwvreg.CWRegistryStore(config)

        self.vreg = vreg

        self._scheduler = scheduler

        self.app_instances_bus = NullEventBus()

        # 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 = None

        # sources (additional sources info in the system database)

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

                                             config.system_source_config.copy())

        # querier helper, need to be created after sources initialization

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

        # cache eid -> type

        self._type_cache = {}

        # the hooks manager

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

    def bootstrap(self):

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

        self.shutting_down = False

        config = self.config

        # copy pool size here since config.init_cube() and config.load_schema()

        # reload configuration from file and could reset a manually set pool

        # size.

        if config['connections-pooler-enabled']:

            pool_size, min_pool_size = config['connections-pool-size'], 1

        else:

            pool_size = min_pool_size = None

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

        #    the database

        self.cnxsets = _CnxSetPool(self.system_source, min_pool_size)

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

            pool_size = min_pool_size

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

            # load schema from the file system

            if not config.creating:

                self.info("set fs instance's schema")

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

            if not config.creating:

                # set eids on entities schema

                with self.internal_cnx() as cnx:

                    for etype, eid in cnx.execute('Any XN,X WHERE X is CWEType, X name XN'):

                        try:

                            self.schema.eschema(etype).eid = eid

                        except KeyError:

                            # etype in the database doesn't exist in the fs schema, this may occur

                            # during dev and we shouldn't crash

                            self.warning('No %s entity type in the file system schema', etype)

        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_system_source()

            if 'CWProperty' in self.schema:

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

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

        #    proper initialization

        self.cnxsets.close()

        self.cnxsets = _CnxSetPool(self.system_source, pool_size)

        # 5. call instance level initialisation hooks

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

    def source_by_uri(self, uri):

        with self.internal_cnx() as cnx:

            rset = cnx.find('CWSource', name=uri)

            if not rset:

                raise ValueError('no source with uri %s found' % uri)

            return self._source_from_cwsource(rset.one())

    def source_by_eid(self, eid):

        with self.internal_cnx() as cnx:

            rset = cnx.find('CWSource', eid=eid)

            if not rset:

                raise ValueError('no source with eid %d found' % eid)

            return self._source_from_cwsource(rset.one())

    @property

    def sources_by_uri(self):

        mapping = {'system': self.system_source}

        mapping.update((sourceent.name, source)

                       for sourceent, source in self._sources())

        return mapping

    def _sources(self):

        if self.config.quick_start:

            return

        with self.internal_cnx() as cnx:

            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, S name != "system"').entities():

                source = self._source_from_cwsource(sourceent)

                yield sourceent, source

        self._clear_source_defs_caches()

    def _source_from_cwsource(self, sourceent):

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

                                 sourceent.host_config, sourceent.eid)

        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(sourceent)

        return source

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

    def _init_system_source(self):

        if self.config.quick_start:

            self.system_source.init_creating()

            return

        with self.internal_cnx() as cnx:

            sourceent = cnx.execute(

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

                ' S name "system", S type SA, S config SC'

            ).one()

            self.system_source.eid = sourceent.eid

            self.system_source.init(sourceent)

    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)

        self.system_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))