def authenticate(self):  # pylint: disable=too-many-locals
        """
        Launch the authentication process: for 'auto' provider, it means first to find the relevant
        provider, then call its authenticate() method. Almost every subsequent operation will then
        be delegated to that provider.
        """
        mapping_override = self.config.resolve('lexicon:auto:mapping_override')
        mapping_override_processed = {}
        if mapping_override:
            for one_mapping in mapping_override.split(','):
                one_mapping_processed = one_mapping.split(':')
                mapping_override_processed[one_mapping_processed[0]
                                           ] = one_mapping_processed[1]

        override_provider = mapping_override_processed.get(self.domain)
        if override_provider:
            provider = [
                element for element in AVAILABLE_PROVIDERS.items()
                if element[0] == override_provider][0]
            LOGGER.info('Provider authoritatively mapped for domain %s: %s.',
                        self.domain, provider.__name__)
            (provider_name, provider_module) = provider
        else:
            (provider_name, provider_module) = _relevant_provider_for_domain(self.domain)
            LOGGER.info('Provider discovered for domain %s: %s.',
                        self.domain, provider_name)

        new_config = ConfigResolver()
        new_config.with_dict({'lexicon:provider_name': provider_name})

        target_prefix = 'auto_{0}_'.format(provider_name)
        for config_source in self.config._config_sources:  # pylint: disable=protected-access
            if not isinstance(config_source, ArgsConfigSource):
                new_config.with_config_source(config_source)
            else:
                # ArgsConfigSource needs to be reprocessed to rescope the provided
                # args to the delegate provider
                new_dict = {}
                for key, value in config_source._parameters.items():  # pylint: disable=protected-access
                    if key.startswith(target_prefix):
                        new_param_name = re.sub(
                            '^{0}'.format(target_prefix), '', key)
                        new_dict['lexicon:{0}:{1}'.format(
                            provider_name, new_param_name)] = value
                    elif not key.startswith('auto_'):
                        new_dict['lexicon:{0}'.format(key)] = value
                new_config.with_dict(new_dict)

        self.proxy_provider = provider_module.Provider(new_config)
        self.proxy_provider.authenticate()
Launch the authentication process: for 'auto' provider, it means first to find the relevant
        provider, then call its authenticate() method. Almost every subsequent operation will then
        be delegated to that provider.