def __init__(self): """Disable the middleware if the feature is not enabled. """ if not settings.FEATURES.get('ENABLE_CROSS_DOMAIN_CSRF_COOKIE'): raise MiddlewareNotUsed() if not getattr(settings, 'CROSS_DOMAIN_CSRF_COOKIE_NAME', ''): raise ImproperlyConfigured( "You must set `CROSS_DOMAIN_CSRF_COOKIE_NAME` when " "`FEATURES['ENABLE_CROSS_DOMAIN_CSRF_COOKIE']` is True.") if not getattr(settings, 'CROSS_DOMAIN_CSRF_COOKIE_DOMAIN', ''): raise ImproperlyConfigured( "You must set `CROSS_DOMAIN_CSRF_COOKIE_DOMAIN` when " "`FEATURES['ENABLE_CROSS_DOMAIN_CSRF_COOKIE']` is True.")
def __init__(self, get_response=None): if not settings.YADP_ENABLED: # Disable the middleware completely when YADP_ENABLED = False raise MiddlewareNotUsed() self.get_response = get_response self.error = None self.profiler = None self.get_parameters = None self.post_parameters = None self.clock_parameter = None self.fraction_parameter = None self.max_calls_parameter = None self.pattern_parameter = None self.profile_parameter = None
def __init__(self): """ Middleware init is called once per server on startup - do the heavy lifting here. """ # If disabled or not enabled raise MiddleWareNotUsed so django # processes next middleware. self.ENABLED = getattr(settings, 'BANISH_ENABLED', False) self.DEBUG = getattr(settings, 'BANISH_DEBUG', False) self.ABUSE_THRESHOLD = getattr(settings, 'BANISH_ABUSE_THRESHOLD', 75) self.USE_HTTP_X_FORWARDED_FOR = getattr( settings, 'BANISH_USE_HTTP_X_FORWARDED_FOR', False) self.BANISH_EMPTY_UA = getattr(settings, 'BANISH_EMPTY_UA', True) self.BANISH_MESSAGE = getattr(settings, 'BANISH_MESSAGE', 'You are banned.') if not self.ENABLED: raise MiddlewareNotUsed( "django-banish is not enabled via settings.py") if self.DEBUG: print >> sys.stderr, "[django-banish] status = enabled" # Prefix All keys in cache to avoid key collisions self.BANISH_PREFIX = 'DJANGO_BANISH:' self.ABUSE_PREFIX = 'DJANGO_BANISH_ABUSE:' self.WHITELIST_PREFIX = 'DJANGO_BANISH_WHITELIST:' self.BANNED_AGENTS = [] if self.BANISH_EMPTY_UA: self.BANNED_AGENTS.append(None) # Populate various 'banish' buckets for ban in Banishment.objects.all(): if self.DEBUG: print >> sys.stderr, "IP BANISHMENT: ", ban.type if ban.type == 'ip-address': cache_key = self.BANISH_PREFIX + ban.condition cache.set(cache_key, "1") if ban.type == 'user-agent': self.BANNED_AGENTS.append(ban.condition) for whitelist in Whitelist.objects.all(): if whitelist.type == 'ip-address-whitelist': cache_key = self.WHITELIST_PREFIX + whitelist.condition cache.set(cache_key, "1")
def __init__(self, get_response): if getattr(settings, 'ALLOWED_IP_BLOCKS', False): self.ip_blocks = [ item.strip() for item in settings.ALLOWED_IP_BLOCKS.split(',') ] # type: ignore else: # this will make Django skip this middleware for all future requests raise MiddlewareNotUsed() if getattr(settings, 'TRUSTED_PROXIES', False): self.trusted_proxies = [ item.strip() for item in getattr(settings, 'TRUSTED_PROXIES').split(',') ] self.get_response = get_response
def __init__(self, *args, **kwargs): redis_handler = RedisHandler() RedisHandler.instance = redis_handler redis_handler.register("UserJoinedMeetingEvtMsg", on_join) redis_handler.register("UserLeftMeetingEvtMsg", on_leave) redis_handler.register("GroupChatMessageBroadcastEvtMsg", on_chat_msg) redis_handler.register("ClearPublicChatHistoryPubMsg", on_chat_clear) redis_handler.start() threads = [RequestThread() for i in range(1)] for thread in threads: thread.start() StateLoader().start() raise MiddlewareNotUsed("Good.Design")
def __init__(self, *args, **kwargs): """Disable the middleware if the feature is not enabled. """ if not settings.FEATURES.get('ENABLE_CROSS_DOMAIN_CSRF_COOKIE'): raise MiddlewareNotUsed() if not getattr(settings, 'CROSS_DOMAIN_CSRF_COOKIE_NAME', ''): raise ImproperlyConfigured( "You must set `CROSS_DOMAIN_CSRF_COOKIE_NAME` when " "`FEATURES['ENABLE_CROSS_DOMAIN_CSRF_COOKIE']` is True.") if not getattr(settings, 'CROSS_DOMAIN_CSRF_COOKIE_DOMAIN', ''): raise ImproperlyConfigured( "You must set `CROSS_DOMAIN_CSRF_COOKIE_DOMAIN` when " "`FEATURES['ENABLE_CROSS_DOMAIN_CSRF_COOKIE']` is True.") super(CsrfCrossDomainCookieMiddleware, self).__init__(*args, **kwargs) # lint-amnesty, pylint: disable=super-with-arguments
def __init__(self, get_response): if not settings.SECURE_PROXY_SSL_HEADER: # For Django to be able to detect if a request is secure # some configuration is required, e.g.. # # The nginx proxy should set: # # proxy_set_header X-Forwarded-Proto $scheme; # # The Django project should set: # # SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https') raise MiddlewareNotUsed( "SECURE_PROXY_SSL_HEADER is not configured") self.get_response = get_response
def __init__(self, logger=None, format=None, logging_level=logging.INFO, logger_name='wsgi', setup_console_handler=True, set_logger_level=logging.DEBUG, disable_on_devel=True): # Because __init__ is called manually by __new__, it is invoked twice: # bail out early the second time as we are already configured. if self.__dict__: return if format is not None: self.format = format self.logging_level = logging_level self.logger_name = logger_name if logger is None: self.logger = logging.getLogger(self.logger_name) if setup_console_handler: console = logging.StreamHandler() console.setLevel(logging.DEBUG) # We need to control the exact format: console.setFormatter(logging.Formatter('%(message)s')) self.logger.addHandler(console) self.logger.propagate = False if set_logger_level is not None: self.logger.setLevel(set_logger_level) else: self.logger = logger # If running under the development server, it will try to log as well if 'django.core.management.commands.runserver' in sys.modules: if disable_on_devel: from django.core.exceptions import MiddlewareNotUsed raise MiddlewareNotUsed("development server detected") else: self.logger.info( "development server detected: disabling its logs") try: from django.core.servers.basehttp import WSGIRequestHandler WSGIRequestHandler.log_message = ( lambda self, format, *args: None) except Exception as e: self.logger.warn("disbling logs failed: %s - %s", e.__class__.__name__, e)
def __init__(self): if system_layout.current_value is not None: raise MiddlewareNotUsed() class FarmNotConfiguredView(APIView): permission_classes = (AllowAny, ) def get(self, request): raise FarmNotConfiguredError() post = get put = get patch = get delete = get self.view = FarmNotConfiguredView.as_view()
def __init__(self, get_response=None): for error in cache.get('configuration-errors', []): ConfigurationError.objects.add( error['name'], error['message'], error['timestamp'] if 'timestamp' in error else now(), ) if self.does_fire(run_index_queue): ConfigurationError.objects.add( 'Offloaded index', 'The processing seems to be slow, ' 'there are more than 20000 entries to process.') if self.does_fire(run_cache): ConfigurationError.objects.add( 'Cache', 'The configured cache backend will lead to serious ' 'performance or consistency issues.') raise MiddlewareNotUsed()
def __init__(self): """Creates the IrcBot and reports that the bot is not used. """ try: self.bots except AttributeError: self.bots = [ SpoilerBot(host='vilma.hsin.hr', port=6667, channels=['#zadaci'], nick='SpoilerBot', identity='SpoilerBot', real_name='I like to spoil things!', owner='brahle'), ] raise MiddlewareNotUsed()
def __init__(self): # we'll never get into process request in case HTTP_AUTH is disabled if not local_settings.HTTP_AUTH_ENABLED: msg = "Basic authentication is not used, this removes it from middleware" raise MiddlewareNotUsed(msg) # if looking only for blocking access for bad-behaved crawlers SSL is not required # BEWARE: without encryption the basic auth credentials are sent in plain text # self.basic_auth_requires_ssl = getattr(settings, 'BASIC_HTTP_AUTH_USE_SSL', '') self.exception_patterns = [ re.compile(exception_pattern) for exception_pattern in local_settings.HTTP_AUTH_URL_EXCEPTIONS ] logger.debug("Using %s URLs for basic auth exceptions", local_settings.HTTP_AUTH_URL_EXCEPTIONS) self.site_checker = get_custom_site_checker()
def InstallJavascriptCatalog(get_response=None): """ Middleware ensuring that 'django.views.i18n.javascript_catalog' is wired. This middleware can be configured using settings : * JSI18N_PACKAGES : default is () * JSI18N_VIEWNAME : default is 'jsi18n' * JSI18N_USE_I18NPATTERN : default is True """ import django.core.urlresolvers as URL jsi18nView = "django.views.i18n.javascript_catalog" try: # check if javascript_catalog exists in settings.ROOT_URLCONF URL.reverse(jsi18nView) except URL.NoReverseMatch : # we fix ROOT_URLCONF urlpatterns... if getattr(settings,'JSI18N_USE_I18NPATTERN',True): from django.conf.urls.i18n import i18n_patterns as patterns else: from django.conf.urls import patterns resolver = URL.get_resolver(None) # define missing jsi18npatterns ... jsi18nParams = dict(packages=getattr(settings,'JSI18N_PACKAGES',())) jsi18nViewName = getattr(settings,'JSI18N_VIEWNAME',"jsi18n") jsi18npatterns = patterns('', (r"^jsi18n$",jsi18nView,jsi18nParams,jsi18nViewName), ) # correct default urlpatterns urlpatterns = resolver.urlconf_module.urlpatterns urlpatterns += jsi18npatterns resolver.urlconf_module.urlpatterns = urlpatterns # reset resolver for cachename in ['_reverse_dict','_namespace_dict','_app_dict']: setattr(resolver,cachename,{}) raise MiddlewareNotUsed()
def process_view(self, request, callback, callback_args, callback_kwargs): """ Enable the profiler and begin collecting data about the view Note that this misses the rest of Django's request processing (other middleware, etc.) """ # Ensure the profiler being requested is actually installed/available if THREAD_LOCAL.profiler_type is None: THREAD_LOCAL.profiler_type = request.GET.get( 'profiler_type', 'hotshot') if self.profiler_type() == THREAD_LOCAL.profiler_type: if not self.profiler_installed(): return MiddlewareNotUsed() THREAD_LOCAL.profiler = self.profiler_start() return THREAD_LOCAL.profiler.runcall(callback, request, *callback_args, **callback_kwargs)
def __init__( self, get_response: Callable, *, enabled: Optional[bool] = None, trusted_proxy_set: Optional[Iterable[str]] = None, ): """ Keyword arguments: enabled: Whether this middleware should be enabled. If None, respects the ``USE_HTTP_FORWARDED`` Django setting. trusted_proxy_set: Base set of trusted proxies. If None, the value is taken from the ``HTTP_FORWARDED_TRUSTED_PROXY_SET`` Django setting. """ log = logging.LoggerAdapter(_log, {"forwarded": None}) if enabled is None: enabled = getattr(settings, "USE_HTTP_FORWARDED", False) if trusted_proxy_set is None: trusted_proxy_set = getattr(settings, "HTTP_FORWARDED_TRUSTED_PROXY_SET", frozenset()) if not enabled: raise MiddlewareNotUsed() # Split trusted proxies on IP adddresses and host names trusted_addr = set() trusted_fqdn = set() for host in trusted_proxy_set: try: trusted_addr.add(ip_address(host)) except ValueError: trusted_fqdn.add(getfqdn(host)) self._get_response = get_response log.debug("Trusting by address: %s", trusted_addr) self._trusted_addr_set = frozenset(trusted_addr) log.debug("Trusting by name: %s", trusted_fqdn) self._trusted_fqdn_set = frozenset(trusted_fqdn)
def __init__(self): if getattr(settings, 'IS_DEV_SERVER', False ) or 'django.contrib.sites' not in settings.INSTALLED_APPS: raise MiddlewareNotUsed() try: from django.contrib.gis.utils import GeoIP, GeoIPException self.g = GeoIP() self.redirect_sites = dict(settings.SITE_GEOIP_REDIRECT) except (ImportError, GeoIPException, ValueError, TypeError, AttributeError): raise ImproperlyConfigured( "The GeoIPRedirectMiddleware requires the" " setting SITE_GEOIP_REDIRECT and GEOIP_PATH to be defined" " along with a working GeoIP installation." " Please see 'django.contrib.gis.utils.geoip.py'.") self.srs_url_re = re.compile("^/siteinfo/srs/?$") self.srs_getvarname = getattr(settings, 'SITE_GEOIP_REDIRECT_GETVARNAME', 'srs')
def admin_requires_2fa_middleware(get_response): try: admin_prefix = reverse("admin:index") except NoReverseMatch: # The admin site isn't installed, likely because # we are running tests with a custom urlconf that # doesn't register the admin site. raise MiddlewareNotUsed() ignored_paths = {reverse("admin:login"), reverse("admin:logout")} def middleware(request): path = request.path if (path.startswith(admin_prefix) and path not in ignored_paths and request.user.is_authenticated and not is_request_user_verified(request)): return redirect_request_to_verify(request) return get_response(request) return middleware
def google_analytics(get_response): """Report a page view to Google Analytics.""" if not settings.GOOGLE_ANALYTICS_TRACKING_ID: raise MiddlewareNotUsed() def middleware(request): client_id = analytics.get_client_id(request) path = request.path language = get_language() headers = request.META try: analytics.report_view( client_id, path=path, language=language, headers=headers ) except Exception: logger.exception("Unable to update analytics") return get_response(request) return middleware
def __init__(self): """Initialise the logging setup from settings. Logging setup is initialized only in the first request. """ logging_setting = getattr(settings, 'LOGGING_SETUP', None) if logging_setting: # Disable handlers that are not used by any logger. active_handlers = set() loggers = logging_setting.get('loggers', {}) for logger in loggers.values(): active_handlers.update(logger.get('handlers', [])) handlers = logging_setting.get('handlers', {}) for handler in handlers: if handler not in active_handlers: handlers[handler] = {'class': 'logging.NullHandler'} logging.NullHandler = NullHandler dictConfig(logging_setting) raise MiddlewareNotUsed('Logging setup only.')
def __init__(self, *args, **kwargs): global PATCHES_APPLIED if not PATCHES_APPLIED: # json module does not escape HTML metacharacters by default. replace_default_argument(json.dump, 'cls', _JsonEncoderForHtml) replace_default_argument(json.dumps, 'cls', _JsonEncoderForHtml) # YAML. The Python tag scheme allows arbitrary code execution: # yaml.load('!!python/object/apply:os.system ["ls"]') replace_default_argument(yaml.compose, 'Loader', yaml.loader.SafeLoader) replace_default_argument(yaml.compose_all, 'Loader', yaml.loader.SafeLoader) replace_default_argument(yaml.load, 'Loader', yaml.loader.SafeLoader) replace_default_argument(yaml.load_all, 'Loader', yaml.loader.SafeLoader) replace_default_argument(yaml.parse, 'Loader', yaml.loader.SafeLoader) replace_default_argument(yaml.scan, 'Loader', yaml.loader.SafeLoader) # AppEngine urlfetch. # Does not validate certificates by default. replace_default_argument(urlfetch.fetch, 'validate_certificate', True) replace_default_argument(urlfetch.make_fetch_call, 'validate_certificate', True) urlfetch.fetch = _HttpUrlLoggingWrapper(urlfetch.fetch) urlfetch.make_fetch_call = _HttpUrlLoggingWrapper( urlfetch.make_fetch_call) for setting in ("CSRF_COOKIE_SECURE", "SESSION_COOKIE_HTTPONLY", "SESSION_COOKIE_SECURE"): if not getattr(settings, setting, False): logging.warning( "settings.%s is not set to True, this is insecure", setting) PATCHES_APPLIED = True raise MiddlewareNotUsed()
def __init__(self): from tardis.tardis_portal.models import Dataset_File for f in settings.POST_SAVE_FILTERS: cls = f[0] args = [] kw = {} if len(f) == 2: args = f[1] if len(f) == 3: kw = f[2] hook = self._safe_import(cls, args, kw) # XXX seems to requre a strong ref else it won't fire, # could be because some hooks are classes not functions. post_save.connect(hook, sender=Dataset_File, weak=False) logger.debug('Initialised postsave hook %s' % post_save.receivers) # disable middleware raise MiddlewareNotUsed()
def __init__(self): print 'Executing CoG initialization tasks' # update name, domain of current site into database current_site = Site.objects.get_current() current_site.name = settings.SITE_NAME current_site.domain = settings.SITE_DOMAIN current_site.save() print 'Updated current site: name=%s domain=%s' % (current_site.name, current_site.domain) # update list of ESGF peers into database filepath = siteManager.get('PEER_NODES') pnl = PeerNodesList(filepath) pnl.reload() # delete=False # read IdP whitelist # remove this class from the middleware that is invoked for every request raise MiddlewareNotUsed('Do not invoke ever again')
def __init__(self): """ Middleware init is called once per server on startup - do the heavy lifting here. """ # If disabled or not enabled raise MiddleWareNotUsed so django # processes next middleware. self.ENABLED = getattr(settings, 'BANS_ENABLED', False) self.DEBUG = getattr(settings, 'BANS_DEBUG', False) if not self.ENABLED: raise MiddlewareNotUsed("bans are not enabled via settings.py") if self.DEBUG: print "Bans status = enabled" # Populate various 'banish' buckets for ban in Ban.objects.all(): if self.DEBUG: print ban cache.add('BAN:'+ban.address, '1', None)
def __init__(self, param): self.logger.info('Startup: Setup started') call_command('makemigrations', 'management_app') call_command('migrate', 'management_app') call_command('migrate') # load data call_command('loaddata', 'tournament.json') # create users and groups try: self.create_user_groups() self.create_users() self.logger.info('Startup: Created users and groups') except IntegrityError: self.logger.info('Startup: Users already exist') self.logger.info('Startup: Loaded data') set_team_average() set_player_average_score() set_won_by() print('Startup: Setup complete') raise MiddlewareNotUsed('Setup complete')
def __init__(self): """ Middleware init is called once per server on startup - do the heavy lifting here. """ # If disabled or not enabled raise MiddleWareNotUsed so django # processes next middleware. self.ENABLED = getattr(settings, 'ADMIN_ACCESS_WHITELIST_ENABLED', False) self.USE_HTTP_X_FORWARDED_FOR = getattr(settings, 'ADMIN_ACCESS_WHITELIST_USE_HTTP_X_FORWARDED_FOR', False) self.ADMIN_ACCESS_WHITELIST_MESSAGE = getattr(settings, 'ADMIN_ACCESS_WHITELIST_MESSAGE', 'You are banned.') if not self.ENABLED: raise MiddlewareNotUsed("django-admin-ip-whitelist is not enabled via settings.py") log.debug("[django-admin-ip-whitelist] status = enabled") # Prefix All keys in cache to avoid key collisions self.ABUSE_PREFIX = 'DJANGO_ADMIN_ACCESS_WHITELIST_ABUSE:' self.WHITELIST_PREFIX = ADMIN_ACCESS_WHITELIST_PREFIX for whitelist in DjangoAdminAccessIPWhitelist.objects.all(): cache_key = self.WHITELIST_PREFIX + whitelist.ip cache.set(cache_key, "1")
def __init__(self): current_pid = os.getpid() print "Checking for an already running supervisor" if os.path.exists('columbus-supervisor.pid'): with open('columbus-supervisor.pid', 'rb') as handle: existing_pid = int(handle.read()) if existing_pid != current_pid: try: os.kill(existing_pid, 0) print "found a supervisor running in a different process with id " + str( existing_pid) print "killing the existing supervisor" os.kill(existing_pid, signal.SIGTERM) print "killed the existing supervisor successfully" except OSError: pass else: return with open('columbus-supervisor.pid', 'wb') as handle: handle.write(str(current_pid)) from pyedf.coreengine import Supervisor supervisor = Supervisor() supervisor.start() raise MiddlewareNotUsed("Supervisor is up and running")
def __init__(self, get_response: typing.Callable) -> None: if RECORDING_DISABLED: raise MiddlewareNotUsed("UserVisit recording has been disabled") self.get_response = get_response
def __init__(self, get_response): if settings.DEBUG is True: raise MiddlewareNotUsed() self.get_response = get_response
def __init__(self): # If embargoing is turned off, make this middleware do nothing if not settings.FEATURES.get('EMBARGO'): raise MiddlewareNotUsed()
def __init__(self): if not settings.DEBUG: raise MiddlewareNotUsed()