"""provide an abstract class for external sources using a sqlite database helper

:organization: Logilab

:copyright: 2007-2008 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

"""

__docformat__ = "restructuredtext en"

import time

import threading

from os.path import join, exists

from cubicweb import server

from cubicweb.server.sqlutils import sqlexec, SQLAdapterMixIn

from cubicweb.server.sources import AbstractSource, native

from cubicweb.server.sources.rql2sql import SQLGenerator

def timeout_acquire(lock, timeout):

    while not lock.acquire(False):

        time.sleep(0.2)

        timeout -= 0.2

        if timeout <= 0:

            raise RuntimeError("svn source is busy, can't acquire connection lock")

class ConnectionWrapper(object):

    def __init__(self, source=None):

        self.source = source

        self._cnx = None

    @property

    def cnx(self):

        if self._cnx is None:

            timeout_acquire(self.source._cnxlock, 5)

            self._cnx = self.source._sqlcnx

        return self._cnx

    def commit(self):

        if self._cnx is not None:

            self._cnx.commit()

    def rollback(self):

        if self._cnx is not None:

            self._cnx.rollback()

    def cursor(self):

        return self.cnx.cursor()

class SQLiteAbstractSource(AbstractSource):

    """an abstract class for external sources using a sqlite database helper

    """

    sqlgen_class = SQLGenerator

    @classmethod

    def set_nonsystem_types(cls):

        # those entities are only in this source, we don't want them in the

        # system source

        for etype in cls.support_entities:

            native.NONSYSTEM_ETYPES.add(etype)

        for rtype in cls.support_relations:

            native.NONSYSTEM_RELATIONS.add(rtype)

    options = (

        ('helper-db-path',

         {'type' : 'string',

          'default': None,

          'help': 'path to the sqlite database file used to do queries on the \

repository.',

          'inputlevel': 2,

          }),

    )

    def __init__(self, repo, appschema, source_config, *args, **kwargs):

        # the helper db is used to easy querying and will store everything but

        # actual file content 

        dbpath = source_config.get('helper-db-path')

        if dbpath is None:

            dbpath = join(repo.config.appdatahome,

                          '%(uri)s.sqlite' % source_config)

        self.dbpath = dbpath

        self.sqladapter = SQLAdapterMixIn({'db-driver': 'sqlite',

                                           'db-name': dbpath})

        # those attributes have to be initialized before ancestor's __init__

        # which will call set_schema

        self._need_sql_create = not exists(dbpath)

        self._need_full_import = self._need_sql_create

        AbstractSource.__init__(self, repo, appschema, source_config,

                                *args, **kwargs)

        # sql database can only be accessed by one connection at a time, and a

        # connection can only be used by the thread which created it so:

        # * create the connection when needed

        # * use a lock to be sure only one connection is used

        self._cnxlock = threading.Lock()

    @property

    def _sqlcnx(self):

        # XXX: sqlite connections can only be used in the same thread, so

        #      create a new one each time necessary. If it appears to be time

        #      consuming, find another way

        return self.sqladapter.get_connection()

    def _is_schema_complete(self):

        for etype in self.support_entities:

            if not etype in self.schema:

                self.warning('not ready to generate %s database, %s support missing from schema',

                             self.uri, etype)

                return False

        for rtype in self.support_relations:

            if not rtype in self.schema:

                self.warning('not ready to generate %s database, %s support missing from schema',

                             self.uri, rtype)

                return False

        return True

    def _create_database(self):

        from yams.schema2sql import eschema2sql, rschema2sql

        from cubicweb.toolsutils import restrict_perms_to_user

        self.warning('initializing sqlite database for %s source' % self.uri)

        cnx = self._sqlcnx

        cu = cnx.cursor()

        schema = self.schema

        for etype in self.support_entities:

            eschema = schema.eschema(etype)

            createsqls = eschema2sql(self.sqladapter.dbhelper, eschema,

                                     skip_relations=('data',))

            sqlexec(createsqls, cu, withpb=False)

        for rtype in self.support_relations:

            rschema = schema.rschema(rtype)

            if not rschema.inlined:

                sqlexec(rschema2sql(rschema), cu, withpb=False)

        cnx.commit()

        cnx.close()

        self._need_sql_create = False

        if self.repo.config['uid']:

            from logilab.common.shellutils import chown

            # database file must be owned by the uid of the server process

            self.warning('set %s as owner of the database file',

                         self.repo.config['uid'])

            chown(self.dbpath, self.repo.config['uid'])

        restrict_perms_to_user(self.dbpath, self.info)

    def set_schema(self, schema):

        super(SQLiteAbstractSource, self).set_schema(schema)

        if self._need_sql_create and self._is_schema_complete():

            self._create_database()

        self.rqlsqlgen = self.sqlgen_class(schema, self.sqladapter.dbhelper)

    def get_connection(self):

        return ConnectionWrapper(self)

    def check_connection(self, cnx):

        """check connection validity, return None if the connection is still valid

        else a new connection (called when the pool using the given connection is

        being attached to a session)

        always return the connection to reset eventually cached cursor

        """

        return cnx

    def pool_reset(self, cnx):

        """the pool using the given connection is being reseted from its current

        attached session: release the connection lock if the connection wrapper

        has a connection set

        """

        if cnx._cnx is not None:

            try:

                cnx._cnx.close()

                cnx._cnx = None

            finally:

                self._cnxlock.release()

    def syntax_tree_search(self, session, union,

                           args=None, cachekey=None, varmap=None, debug=0):

        """return result from this source for a rql query (actually from a rql 

        syntax tree and a solution dictionary mapping each used variable to a 

        possible type). If cachekey is given, the query necessary to fetch the

        results (but not the results themselves) may be cached using this key.

        """

        if self._need_sql_create:

            return []

        sql, query_args = self.rqlsqlgen.generate(union, args)

        if server.DEBUG:

            print self.uri, 'SOURCE RQL', union.as_string()

            print 'GENERATED SQL', sql

        args = self.sqladapter.merge_args(args, query_args)

        cursor = session.pool[self.uri]

        cursor.execute(sql, args)

        return self.sqladapter.process_result(cursor) 

    def local_add_entity(self, session, entity):

        """insert the entity in the local database.

        This is not provided as add_entity implementation since usually source

        don't want to simply do this, so let raise NotImplementedError and the

        source implementor may use this method if necessary

        """

        cu = session.pool[self.uri]

        attrs = self.sqladapter.preprocess_entity(entity)

        sql = self.sqladapter.sqlgen.insert(str(entity.e_schema), attrs)

        cu.execute(sql, attrs)

    def add_entity(self, session, entity):

        """add a new entity to the source"""

        raise NotImplementedError()

    def local_update_entity(self, session, entity):

        """update an entity in the source

        This is not provided as update_entity implementation since usually

        source don't want to simply do this, so let raise NotImplementedError

        and the source implementor may use this method if necessary

        """

        cu = session.pool[self.uri]

        attrs = self.sqladapter.preprocess_entity(entity)

        sql = self.sqladapter.sqlgen.update(str(entity.e_schema), attrs, ['eid'])

        cu.execute(sql, attrs)

    def update_entity(self, session, entity):

        """update an entity in the source"""

        raise NotImplementedError()

    def delete_entity(self, session, etype, eid):

        """delete an entity from the source

        this is not deleting a file in the svn but deleting entities from the

        source. Main usage is to delete repository content when a Repository

        entity is deleted.

        """

        sqlcursor = session.pool[self.uri]        

        attrs = {'eid': eid}

        sql = self.sqladapter.sqlgen.delete(etype, attrs)

        sqlcursor.execute(sql, attrs)

    def delete_relation(self, session, subject, rtype, object):

        """delete a relation from the source"""

        rschema = self.schema.rschema(rtype)

        if rschema.inlined:

            if subject in session.query_data('pendingeids', ()):

                return

            etype = session.describe(subject)[0]

            sql = 'UPDATE %s SET %s=NULL WHERE eid=%%(eid)s' % (etype, rtype)

            attrs = {'eid' : subject}

        else:

            attrs = {'eid_from': subject, 'eid_to': object}

            sql = self.sqladapter.sqlgen.delete('%s_relation' % rtype, attrs)

        sqlcursor = session.pool[self.uri]        

        sqlcursor.execute(sql, attrs)