edmorley ( Ed Morley )

Ed Morley edmorley @heroku London, UK https://www.linkedin.com/in/edmorley Hi! I'm the Python language owner at Heroku.

repos

116

gists

followers

185

following

edmorley/django-environ 1

Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application.

edmorley/alpinehelloworld 0

An Alpine-based Docker example

edmorley/arewefastyet 0

AreWeFastYet is a set of tools used for benchmarking the major browser's JavaScript virtual machines against each other, as well as reporting the results on a website as insightful graphs showing the evolution of performance over time.

edmorley/autolander 0

Tools for integrating bugzilla and github workflows.

edmorley/babel-eslint 0

:tokyo_tower: A wrapper for Babel's parser used for ESLint

edmorley/bento 0

Packer templates for building minimal Vagrant baseboxes

edmorley/bmo 0

Read-only mirror of bugzilla.mozilla.org source from git.mozilla.org/webtools/bmo/bugzilla.git

edmorley/boot2docker 0

Lightweight Linux for Docker

edmorley/bootstrap 0

The most popular HTML, CSS, and JavaScript framework for developing responsive, mobile first projects on the web.

edmorley/boto 0

For the latest version of boto, see https://github.com/boto/boto3 -- Python interface to Amazon Web Services

issue closedevansd/whitenoise

Everything BUT Staticfile Requests are routing through Whitenoise Middleware

Hello, and apologies in advanced for being a Django noob,

I think that perhaps this might be a noob question, but I am using Whitenoise with the django-cookie-cutter project setup with Docker to serve only my static files. One caveat though: I am using ASGI, but as seen in issue #251 it seems as if Whitenoise effectively simulates synchronous loading perhaps ruling out ASGI as the source of my problems.

I'm trying to implement a system in which only authenticated users can access certain static files, as detailed here, but cut-down to show a demonstration. In addition, I am not worrying about performance as this is just for a very specific demo purpose that unfortunately I am having a lot more difficulty than I expected:

https://stackoverflow.com/questions/43271275/django-restrict-static-folder-access-to-non-logged-in-users
https://github.com/evansd/whitenoise/issues/124

Here's the middleware I'm using:

from whitenoise.middleware import WhiteNoiseMiddleware
import datetime
# this is a sample code, you can change for your use case
class ProtectedStaticFileMiddleware(WhiteNoiseMiddleware):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def __call__(self, request):
        response = super().__call__(request)
        print("Request: ", request)
        print("Response ", response)
       # This is where I would check if the response is from a authorized user
        response = self.process_response(request, response)
        return response

    def process_response(self, request, response):
        print("Response, Completed: ", response)
        # Resetting cache as you said in #124 
        response['Cache-Control'] = datetime.datetime.now()
        response['Expires'] = datetime.datetime.now()
        return response

I was expecting to see for every static file a printed print(response) and print(request) output, but here's what I receive:

The only request the comes through the middleware is the GET request to "/", or 127.0.0.1:8000 (the main path), which means that I can't control who is authorized and who isn't. However - as you can see - my static files are being handled correctly! However, I can't get a hold of any of the static file request using even #124 which you said was a good idea to be able to authorize them.

Here are the relevant settings:

Running this only 127.0.0.1 using uvicorn, collect static has been run with CompressedManifestStaticFilesStorage.

whitenoise==5.2.0  # https://github.com/evansd/whitenoise
django==3.0.11  # https://www.djangoproject.com/
DEBUG = False

ROOT_DIR = Path(__file__).resolve(strict=True).parent.parent.parent
APPS_DIR = ROOT_DIR / "edsproject"
STATIC_ROOT = str(ROOT_DIR / "staticfiles")
STATIC_URL = "/static/"
STATICFILES_DIRS = [str(APPS_DIR / "static"), str(ROOT_DIR / "ui" /"dist")]
STATICFILES_FINDERS = [
    "django.contrib.staticfiles.finders.FileSystemFinder",
    "django.contrib.staticfiles.finders.AppDirectoriesFinder",
MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "whitenoise.middleware.WhiteNoiseMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.locale.LocaleMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
    "django.middleware.common.BrokenLinkEmailsMiddleware",
    "django.middleware.clickjacking.XFrameOptionsMiddleware",
    # Must go down here to pick up request object
    "users.middleware.ProtectedStaticFileMiddleware",
]
INSTALLED_APPS = ["whitenoise.runserver_nostatic"] + INSTALLED_APPS
STATICFILES_STORAGE = "whitenoise.storage.CompressedManifestStaticFilesStorage"```

closed time in 4 hours

omarsumadi

PR opened evansd/whitenoise

Add webp support for when a webp version of an image is available (with fallback for older browsers and CDN support).

Added a webp whitenoise middleware. It checks whether a webp version of an image is available and then serves that instead of the image itself. Also include the "Vary: Accept" header for CDNs.

+42 -0

1 commit in gabn88/whitenoise/tree/patch-1 evansd/whitenoise/tree/master

0 comment

1 changed file

pr created time in 13 hours

startednwtgck/actions-comment-run

started time in a day

issue commentneutrinojs/webpack-chain

How to config pnp-webpack-plugin for yarn 2 pnp mode

This is what I use

config.resolve.plugin('pnp').use({ ...require(`pnp-webpack-plugin`) });
config.resolveLoader.plugin('pnp-loaders').use({ ...require('pnp-webpack-plugin').topLevelLoader });

lotosbin