logging: removed log.warning calls

rhodecode/authentication/registry.py

@@ -1,121 +1,121 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import time
 import logging
 
 from pyramid.exceptions import ConfigurationError
 from zope.interface import implementer
 
 from rhodecode.authentication.interface import IAuthnPluginRegistry
 from rhodecode.model.settings import SettingsModel
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.lib.statsd_client import StatsdClient
 from rhodecode.lib import rc_cache
 
 log = logging.getLogger(__name__)
 
 
 @implementer(IAuthnPluginRegistry)
 class AuthenticationPluginRegistry(object):
 
     # INI settings key to set a fallback authentication plugin.
     fallback_plugin_key = 'rhodecode.auth_plugin_fallback'
 
     def __init__(self, settings):
         self._plugins = {}
         self._fallback_plugin = settings.get(self.fallback_plugin_key, None)
 
     def add_authn_plugin(self, config, plugin):
         plugin_id = plugin.get_id()
         if plugin_id in self._plugins.keys():
             raise ConfigurationError(
                 'Cannot register authentication plugin twice: "%s"', plugin_id)
         else:
             log.debug('Register authentication plugin: "%s"', plugin_id)
             self._plugins[plugin_id] = plugin
 
     def get_plugins(self):
         def sort_key(plugin):
             return str.lower(safe_str(plugin.get_display_name()))
 
         return sorted(self._plugins.values(), key=sort_key)
 
     def get_plugin(self, plugin_id):
         return self._plugins.get(plugin_id, None)
 
     def get_plugin_by_uid(self, plugin_uid):
         for plugin in self._plugins.values():
             if plugin.uid == plugin_uid:
                 return plugin
 
     def get_plugins_for_authentication(self, cache=True):
         """
         Returns a list of plugins which should be consulted when authenticating
         a user. It only returns plugins which are enabled and active.
         Additionally it includes the fallback plugin from the INI file, if
         `rhodecode.auth_plugin_fallback` is set to a plugin ID.
         """
 
         cache_namespace_uid = 'cache_auth_plugins'
         region = rc_cache.get_or_create_region('cache_general', cache_namespace_uid)
 
         @region.conditional_cache_on_arguments(condition=cache)
         def _get_auth_plugins(name, key, fallback_plugin):
             plugins = []
 
             # Add all enabled and active plugins to the list. We iterate over the
             # auth_plugins setting from DB because it also represents the ordering.
             enabled_plugins = SettingsModel().get_auth_plugins()
             raw_settings = SettingsModel().get_all_settings(cache=False)
             for plugin_id in enabled_plugins:
                 plugin = self.get_plugin(plugin_id)
                 if plugin is not None and plugin.is_active(
                         plugin_cached_settings=raw_settings):
 
                     # inject settings into plugin, we can re-use the DB fetched settings here
                     plugin._settings = plugin._propagate_settings(raw_settings)
                     plugins.append(plugin)
 
             # Add the fallback plugin from ini file.
             if fallback_plugin:
-                log.warn(
+                log.warning(
                     'Using fallback authentication plugin from INI file: "%s"',
                     fallback_plugin)
                 plugin = self.get_plugin(fallback_plugin)
                 if plugin is not None and plugin not in plugins:
                     plugin._settings = plugin._propagate_settings(raw_settings)
                     plugins.append(plugin)
             return plugins
 
         start = time.time()
         plugins = _get_auth_plugins('rhodecode_auth_plugins', 'v1', self._fallback_plugin)
 
         compute_time = time.time() - start
         log.debug('cached method:%s took %.4fs', _get_auth_plugins.__name__, compute_time)
 
         statsd = StatsdClient.statsd
         if statsd:
             elapsed_time_ms = round(1000.0 * compute_time)  # use ms only
             statsd.timing("rhodecode_auth_plugins_timing.histogram", elapsed_time_ms,
                           use_decimals=False)
 
         return plugins
 

rhodecode/authentication/routes.py

@@ -1,155 +1,155 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import collections
 
 from pyramid.exceptions import ConfigurationError
 
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.model.settings import SettingsModel
 from rhodecode.translation import _
 
 
 log = logging.getLogger(__name__)
 
 
 class AuthnResourceBase(object):
     __name__ = None
     __parent__ = None
 
     def get_root(self):
         current = self
         while current.__parent__ is not None:
             current = current.__parent__
         return current
 
 
 class AuthnPluginResourceBase(AuthnResourceBase):
 
     def __init__(self, plugin):
         self.plugin = plugin
         self.__name__ = plugin.get_url_slug()
         self.display_name = plugin.get_display_name()
 
 
 class AuthnRootResource(AuthnResourceBase):
     """
     This is the root traversal resource object for the authentication settings.
     """
 
     def __init__(self):
         self._store = collections.OrderedDict()
         self._resource_name_map = {}
         self.display_name = _('Authentication Plugins')
 
     def __getitem__(self, key):
         """
         Customized get item function to return only items (plugins) that are
         activated.
         """
         if self._is_item_active(key):
             return self._store[key]
         else:
             raise KeyError('Authentication plugin "{}" is not active.'.format(
                 key))
 
     def __iter__(self):
         for key in self._store.keys():
             if self._is_item_active(key):
                 yield self._store[key]
 
     def _is_item_active(self, key):
         activated_plugins = SettingsModel().get_auth_plugins()
         plugin_id = self.get_plugin_id(key)
         return plugin_id in activated_plugins
 
     def get_plugin_id(self, resource_name):
         """
         Return the plugin id for the given traversal resource name.
         """
         # TODO: Store this info in the resource element.
         return self._resource_name_map[resource_name]
 
     def get_sorted_list(self, sort_key=None):
         """
         Returns a sorted list of sub resources for displaying purposes.
         """
         def default_sort_key(resource):
             return str.lower(safe_str(resource.display_name))
 
         active = [item for item in self]
         return sorted(active, key=sort_key or default_sort_key)
 
     def get_nav_list(self, sort=True):
         """
         Returns a sorted list of resources for displaying the navigation.
         """
         if sort:
             nav_list = self.get_sorted_list()
         else:
             nav_list = [item for item in self]
 
         nav_list.insert(0, self)
         return nav_list
 
     def add_authn_resource(self, config, plugin_id, resource):
         """
         Register a traversal resource as a sub element to the authentication
         settings. This method is registered as a directive on the pyramid
         configurator object and called by plugins.
         """
 
         def _ensure_unique_name(name, limit=100):
             counter = 1
             current = name
             while current in self._store.keys():
                 current = '{}{}'.format(name, counter)
                 counter += 1
                 if counter > limit:
                     raise ConfigurationError(
                         'Cannot build unique name for traversal resource "%s" '
                         'registered by plugin "%s"', name, plugin_id)
             return current
 
         # Allow plugin resources with identical names by rename duplicates.
         unique_name = _ensure_unique_name(resource.__name__)
         if unique_name != resource.__name__:
-            log.warn('Name collision for traversal resource "%s" registered '
+            log.warning('Name collision for traversal resource "%s" registered '
                      'by authentication plugin "%s"', resource.__name__,
                      plugin_id)
             resource.__name__ = unique_name
 
         log.debug('Register traversal resource "%s" for plugin "%s"',
                   unique_name, plugin_id)
         self._resource_name_map[unique_name] = plugin_id
         resource.__parent__ = self
         self._store[unique_name] = resource
 
 
 root = AuthnRootResource()
 
 
 def root_factory(request=None):
     """
     Returns the root traversal resource instance used for the authentication
     settings route.
     """
     return root