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