cubicweb: comparison goa/gaesource.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 from cubicweb.goa.dbinit import set_user_groups
 from cubicweb.goa.rqlinterpreter import RQLInterpreter
 from google.appengine.api.datastore import Key, Entity, Put, Delete
 from google.appengine.api import datastore_errors, users
 def _init_groups(guser, euser):
 # set default groups
 if guser is None:
 groups = ['guests']
 else:
 if related is not None:
 related = [key for key in related if not key == targetkey]
 gaeentity[relation] = related or None
 _mark_modified(session, gaeentity)
 class DatastorePutOp(SingleOperation):
 """delayed put of entities to have less datastore write api calls
 * save all modified entities at precommit (should be the first operation
 processed, hence the 0 returned by insert_index())
 * in case others precommit operations modify some entities, resave modified
 entities at commit. This suppose that no db changes will occurs during
 commit event but it should be the case.
 """
 def insert_index(self):
 modified = self.session.query_data('modifiedentities', {})
 for eid, gaeentity in modified.iteritems():
 assert not eid in pending
 Put(gaeentity)
 modified.clear()
 def commit_event(self):
 self._put_entities()
 def precommit_event(self):
 self._put_entities()
 class GAESource(AbstractSource):
 """adapter for a system source on top of google appengine datastore"""
 passwd_rql = "Any P WHERE X is CWUser, X login %(login)s, X upassword P"
 auth_rql = "Any X WHERE X is CWUser, X login %(login)s, X upassword %(pwd)s"
 _sols = ({'X': 'CWUser', 'P': 'Password'},)
 options = ()
 def __init__(self, repo, appschema, source_config, *args, **kwargs):
 AbstractSource.__init__(self, repo, appschema, source_config,
 *args, **kwargs)
 if repo.config['use-google-auth']:
 self.info('using google authentication service')
 self.authenticate = self.authenticate_gauth
 else:
 self.authenticate = self.authenticate_local
 def reset_caches(self):
 """method called during test to reset potential source caches"""
 pass
 def init_creating(self):
 pass
 def init(self):
 # XXX unregister unsupported hooks
 self.repo.hm.unregister_hook(sync_owner_after_add_composite_relation,
 'after_add_relation', '')
 def get_connection(self):
 return ConnectionWrapper()
 # ISource interface #######################################################
 def compile_rql(self, rql):
 rqlst = self.repo.querier._rqlhelper.parse(rql)
 rqlst.restricted_vars = ()
 rqlst.children[0].solutions = self._sols
 return rqlst
 def set_schema(self, schema):
 """set the application'schema"""
 self.interpreter = RQLInterpreter(schema)
 self.schema = schema
 if 'CWUser' in schema and not self.repo.config['use-google-auth']:
 # rql syntax trees used to authenticate users
 self._passwd_rqlst = self.compile_rql(self.passwd_rql)
 self._auth_rqlst = self.compile_rql(self.auth_rql)
 def support_entity(self, etype, write=False):
 """return true if the given entity's type is handled by this adapter
 if write is true, return true only if it's a RW support
 """
 return True
 def support_relation(self, rtype, write=False):
 """return true if the given relation's type is handled by this adapter
 if write is true, return true only if it's a RW support
 """
 return True
 euser = Entity('CWUser', name='key_' + login)
 euser['s_login'] = login
 _init_groups(guser, euser)
 Put(euser)
 return str(euser.key())
 def authenticate_local(self, session, login, password):
 """return CWUser eid for the given login/password if this account is
 defined in this source, else raise `AuthenticationError`
 two queries are needed since passwords are stored crypted, so we have
 rset = self.syntax_tree_search(session, self._auth_rqlst, args)
 try:
 return rset[0][0]
 except IndexError:
 raise AuthenticationError('bad password')
 def syntax_tree_search(self, session, union, args=None, cachekey=None,
 varmap=None):
 """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.
 """
 results, description = self.interpreter.interpret(union, args,
 session.datastore_get)
 return results # XXX description
 def flying_insert(self, table, session, union, args=None, varmap=None):
 raise NotImplementedError
 def add_entity(self, session, entity):
 """add a new entity to the source"""
 # do not delay add_entity as other modifications, new created entity
 # needs an eid
 entity.put()
 def update_entity(self, session, entity):
 """replace an entity in the source"""
 gaeentity = entity.to_gae_model()
 _mark_modified(session, entity.to_gae_model())
 if gaeentity.kind() == 'CWUser':
 for asession in self.repo._sessions.itervalues():
 if asession.user.eid == entity.eid:
 asession.user.update(dict(gaeentity))
 def delete_entity(self, session, etype, eid):
 """delete an entity from the source"""
 # do not delay delete_entity as other modifications to ensure
 # consistency
 key = Key(eid)
 """add a relation to the source"""
 gaesubj, gaeobj, cards = _rinfo(session, subject, rtype, object)
 _radd(session, gaesubj, gaeobj.key(), 's_' + rtype, cards[0])
 _radd(session, gaeobj, gaesubj.key(), 'o_' + rtype, cards[1])
 _clear_related_cache(session, gaesubj, rtype, gaeobj)
 def delete_relation(self, session, subject, rtype, object):
 """delete a relation from the source"""
 gaesubj, gaeobj, cards = _rinfo(session, subject, rtype, object)
 pending = session.query_data('pendingeids', set(), setdefault=True)
 if not subject in pending:
 _rdel(session, gaesubj, gaeobj.key(), 's_' + rtype, cards[0])
 if not object in pending:
 _rdel(session, gaeobj, gaesubj.key(), 'o_' + rtype, cards[1])
 _clear_related_cache(session, gaesubj, rtype, gaeobj)
 # system source interface #################################################
 def eid_type_source(self, session, eid):
 """return a tuple (type, source, extid) for the entity with id <eid>"""
 try:
 key = Key(eid)
 except datastore_errors.BadKeyError:
 raise UnknownEid(eid)
 return key.kind(), 'system', None
 def create_eid(self, session):
 return None # let the datastore generating key
 def add_info(self, session, entity, source, extid=None):
 """add type and source info for an eid into the system table"""
 def delete_info(self, session, eid, etype, uri, extid):
 """delete system information on deletion of an entity by transfering
 record from the entities table to the deleted_entities table
 """
 pass
 def fti_unindex_entity(self, session, eid):
 """remove text content for entity with the given eid from the full text
 index
 """
 pass
 def fti_index_entity(self, session, entity):
 """add text content of a created/modified entity to the full text index
 """
 pass

branch	tls-sprint
changeset 1802	d628defebc17
parent 1398	5fe84a5f7035
child 1977	606923dff11b