def getResolverObject(resolvername):
"""
get the resolver instance from a resolver name spec
- either take the class from the request context
- or create one from the global object list + init with resolver config
:remark: the resolver object is preserved in the request context, so that
a resolver could preserve a connection durung a request
:param resolvername: the resolver string as from the token including
the config as last part
:return: instance of the resolver with the loaded config
"""
r_obj = None
# this patch is a bit hacky:
# the normal request has a request context, where it retrieves
# the resolver info from and preserves the loaded resolvers for reusage
# But in case of a authentication request (by a redirect from a 401)
# the caller is no std request and the context object is missing :-(
# The solution is to deal with local references, either to the
# global context or to local data (where we have no reuse of the resolver)
resolvers_loaded = context.setdefault('resolvers_loaded', {})
# port of the 2.6. resolver to 2.7
if resolvername[:len('useridresolveree.')] == 'useridresolveree.':
resolvername = "useridresolver.%s" % resolvername[len('useridreseolveree.') - 1:]
# test if there is already a resolver of this kind loaded
if resolvername in resolvers_loaded:
return resolvers_loaded.get(resolvername)
# no resolver - so instatiate one
else:
parts = resolvername.split('.')
if len(parts) > 2:
re_name = '.'.join(parts[:-1])
r_obj_class = get_resolver_class(re_name)
if r_obj_class is None:
log.error("unknown resolver class %s " % resolvername)
return r_obj
# create the resolver instance and load the config
r_obj = r_obj_class()
conf = resolvername.split(".")[-1]
if r_obj is not None:
config = getLinotpConfig()
r_obj.loadConfig(config, conf)
resolvers_loaded[resolvername] = r_obj
return r_obj
def getResolverObject(resolver_spec, config=None, load_config=True):
"""
get the resolver instance from a resolver specification.
:remark: internally this function uses the request context for caching.
:param resolver_spec: the resolver string as from the token including
the config identifier.
format:
<resolver class identifier>.<config identifier>
:return: instance of the resolver with the loaded config (or None
if specification was invalid or didn't match a resolver)
"""
# this patch is a bit hacky:
# the normal request has a request context, where it retrieves
# the resolver info from and preserves the loaded resolvers for reusage
# But in case of a authentication request (by a redirect from a 401)
# the caller is no std request and the context object is missing :-(
# The solution is to deal with local references, either to the
# global context or to local data (where we have no reuse of the resolver)
resolvers_loaded = context.setdefault('resolvers_loaded', {})
if not config:
config = getLinotpConfig()
# test if the resolver is in the cache
if resolver_spec in resolvers_loaded:
return resolvers_loaded.get(resolver_spec)
# no resolver - so instantiate one
else:
cls_identifier, config_identifier = parse_resolver_spec(resolver_spec)
if not cls_identifier or not config_identifier:
log.error('Format error: resolver_spec must have the format '
'<resolver_class_identifier>.<config_identifier>, but '
'value was %s' % resolver_spec)
return None
resolver_cls = get_resolver_class(cls_identifier)
if resolver_cls is None:
log.error('Unknown resolver class: %s' % cls_identifier)
return None
resolver = resolver_cls()
if load_config:
try:
resolver.loadConfig(config, config_identifier)
except ResolverNotAvailable:
log.error('Unable to connect to resolver %r', resolver_spec)
return None
except Exception as exx:
# FIXME: Except clause is too general. resolver
# should be ResolverLoadConfigError
# exceptions in the useridresolver modules should
# have their own type, so we can filter here
log.error(
'Resolver config loading failed for resolver with '
'specification %s: %r', resolver_spec, exx)
return None
# in case of the replication there might by difference
# in the used resolver config and the config from the LinOTP config
_check_for_resolver_cache_flush(resolver_spec, config_identifier)
resolvers_loaded[resolver_spec] = resolver
return resolver
def getResolverObject(resolver_spec):
"""
get the resolver instance from a resolver specification.
:remark: internally this function uses the request context for caching.
:param resolver_spec: the resolver string as from the token including
the config identifier.
format:
<resolver class identifier>.<config identifier>
:return: instance of the resolver with the loaded config (or None
if specification was invalid or didn't match a resolver)
"""
# this patch is a bit hacky:
# the normal request has a request context, where it retrieves
# the resolver info from and preserves the loaded resolvers for reusage
# But in case of a authentication request (by a redirect from a 401)
# the caller is no std request and the context object is missing :-(
# The solution is to deal with local references, either to the
# global context or to local data (where we have no reuse of the resolver)
resolvers_loaded = context.setdefault('resolvers_loaded', {})
# test if the resolver is in the cache
if resolver_spec in resolvers_loaded:
return resolvers_loaded.get(resolver_spec)
# no resolver - so instatiate one
else:
cls_identifier, config_identifier = parse_resolver_spec(resolver_spec)
if not cls_identifier or not config_identifier:
log.error('Format error: resolver_spec must have the format '
'<resolver_class_identifier>.<config_identifier>, but '
'value was %s' % resolver_spec)
return None
resolver_cls = get_resolver_class(cls_identifier)
if resolver_cls is None:
log.error('unknown resolver class: %s' % cls_identifier)
return None
resolver = resolver_cls()
config = getLinotpConfig()
try:
resolver.loadConfig(config, config_identifier)
except:
# FIXME: Except clause is too general. resolver
# exceptions in the useridresolver modules should
# have their own type, so we can filter here
log.error('resolver config loading failed for resolver with '
'specification %s' % resolver_spec)
return None
resolvers_loaded[resolver_spec] = resolver
return resolver
