cubicweb: comparison server/sources/ldapuser.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 }
 class LDAPUserSource(AbstractSource):
 """LDAP read-only CWUser source"""
 support_entities = {'CWUser': False}
 port = None
 cnx_mode = 0
 cnx_dn = ''
 cnx_pwd = ''
 options = (
 ('host',
 {'type' : 'string',
 'default': 'ldap',
 'help': 'ldap host',
 {'type' : 'int',
 'default': 2*60,
 'help': 'life time of query cache in minutes (default to two hours).',
 'group': 'ldap-source', 'inputlevel': 2,
 }),
 )
 def __init__(self, repo, appschema, source_config, *args, **kwargs):
 AbstractSource.__init__(self, repo, appschema, source_config,
 *args, **kwargs)
 self.host = source_config['host']
 self.user_base_dn = source_config['user-base-dn']
 """method called during test to reset potential source caches"""
 self._query_cache = TimedCache(2*60)
 def init(self):
 """method called by the repository once ready to handle request"""
 self.repo.looping_task(self._interval, self.synchronize)
 self.repo.looping_task(self._query_cache.ttl.seconds/10, self._query_cache.clear_expired)
 def synchronize(self):
 """synchronize content known by this repository with content in the
 external repository
 """
 cursor = session.system_sql("SELECT eid, extid FROM entities WHERE "
 "source='%s'" % self.uri)
 for eid, extid in cursor.fetchall():
 # if no result found, _search automatically delete entity information
 res = self._search(session, extid, BASE)
 if res:
 ldapemailaddr = res[0].get(ldap_emailattr)
 if ldapemailaddr:
 rset = session.execute('EmailAddress X,A WHERE '
 'U use_email X, U eid %(u)s',
 {'u': eid})
 # no email found, create it
 _insert_email(session, ldapemailaddr, eid)
 finally:
 session.commit()
 session.close()
 def get_connection(self):
 """open and return a connection to the source"""
 if self._conn is None:
 self._connect()
 return ConnectionWrapper(self._conn)
 def authenticate(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
 def ldap_name(self, var):
 if var.stinfo['relations']:
 relname = iter(var.stinfo['relations']).next().r_type
 return self.user_rev_attrs.get(relname)
 return None
 def prepare_columns(self, mainvars, rqlst):
 """return two list describin how to build the final results
 from the result of an ldap search (ie a list of dictionnary)
 """
 columns = []
 columns.append((mainvar, self.ldap_name(var)))
 #else:
 #    # probably a bug in rql splitting if we arrive here
 #    raise NotImplementedError
 return columns, global_transforms
 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.
 """
 # XXX not handled : transform/aggregat function, join on multiple users...
 assert len(union.children) == 1, 'union not supported'
 result.append(line)
 for trfunc in globtransforms:
 result = trfunc.apply(result)
 #print '--> ldap result', result
 return result
 def _connect(self, userdn=None, userpwd=None):
 port, protocol = MODES[self.cnx_mode]
 if protocol == 'ldapi':
 hostport = self.host
 else:
 rec_dict['dn'] = rec_dn
 self._cache[rec_dn] = rec_dict
 result.append(rec_dict)
 #print '--->', result
 return result
 def before_entity_insertion(self, session, lid, etype, eid):
 """called by the repository when an eid has been attributed for an
 entity stored here but the entity has not been inserted in the system
 table yet.
 This method must return the an Entity instance representation of this
 entity.
 """
 entity = super(LDAPUserSource, self).before_entity_insertion(session, lid, etype, eid)
 res = self._search(session, lid, BASE)[0]
 for attr in entity.e_schema.indexable_attributes():
 entity[attr] = res[self.user_rev_attrs[attr]]
 return entity
 def after_entity_insertion(self, session, dn, entity):
 """called by the repository after an entity stored here has been
 inserted in the system table.
 """
 super(LDAPUserSource, self).after_entity_insertion(session, dn, entity)
 raise RepositoryError('this source is read only')
 def _insert_email(session, emailaddr, ueid):
 session.execute('INSERT EmailAddress X: X address %(addr)s, U primary_email X '
 'WHERE U eid %(x)s', {'addr': emailaddr, 'x': ueid}, 'x')
 class GotDN(Exception):
 """exception used when a dn localizing the searched user has been found"""
 def __init__(self, dn):
 self.dn = dn
 class RQL2LDAPFilter(object):
 """generate an LDAP filter for a rql query"""
 def __init__(self, source, session, args=None, mainvars=()):
 self.source = source
 self._ldap_attrs = source.user_rev_attrs
 self._session = session
 if args is None:
 args = {}
 self._args = args
 self.mainvars = mainvars
 def generate(self, selection, mainvarname):
 self._filters = res = self._base_filters[:]
 self._mainvarname = mainvarname
 self._eidfilters = []
 self._done_not = set()
 elif restriction:
 restriction.accept(self)
 if len(res) > 1:
 return self._eidfilters, '(&%s)' % ''.join(res)
 return self._eidfilters, res[0]
 def visit_and(self, et):
 """generate filter for a AND subtree"""
 for c in et.children:
 part = c.accept(self)
 if part:
 raise NotImplementedError(relation)
 # regular relation XXX todo: in_group
 else:
 raise NotImplementedError(relation)
 return res
 def _visit_attribute_relation(self, relation):
 """generate filter for an attribute relation"""
 lhs, rhs = relation.get_parts()
 lhsvar = lhs.variable
 if relation.r_type == 'eid':
 raise UnknownEid # trick to return no result
 return filter
 def visit_comparison(self, cmp):
 """generate filter for a comparaison"""
 return '%s%s'% (cmp.operator, cmp.children[0].accept(self))
 def visit_mathexpression(self, mexpr):
 """generate filter for a mathematic expression"""
 raise NotImplementedError
 def visit_function(self, function):
 """generate filter name for a function"""
 if function.name == 'IN':
 return self.visit_in(function)
 raise NotImplementedError
 def visit_in(self, function):
 grandpapa = function.parent.parent
 ldapattr = self._ldap_attrs[grandpapa.r_type]
 res = []
 for c in function.children:
 if len(res) > 1:
 part = '(|%s)' % ''.join('(%s=%s)' % (ldapattr, v) for v in res)
 else:
 part = '(%s=%s)' % (ldapattr, res[0])
 return part
 def visit_constant(self, constant):
 """generate filter name for a constant"""
 value = constant.value
 if constant.type is None:
 raise NotImplementedError
 if isinstance(value, unicode):
 value = value.encode('utf8')
 else:
 value = str(value)
 return escape_filter_chars(value)
 def visit_variableref(self, variableref):
 """get the sql name for a variable reference"""
 pass

branch	tls-sprint
changeset 1802	d628defebc17
parent 1398	5fe84a5f7035
child 1952	8e19c813750d