Jared Kuolt hat den StaticGenerator für Django - ein Cache-Script geschafft. Es ist kompakt und einfach zu bedienen. Das Skript aber und die von Jared gezeigte nginx-Konfiguration haben ein paar Nachteile:
1) aktuell nur für die Websites ohne Registrierung;
2) geeignet für die Arbeit mit nur einfachen Links;
3) Generierung ist nur bei der Veränderung/Ergänzung des Kontents und/oder der Kommentare.

Ich habe dies korrigiert, noch etwas zugefügt, daraus ist StaticGenerator Pro gekommen.

Seine zusätzlichen Möglichkeiten:
  • Das Caching nur für Anonymous
    Die Anfragen der registrierten Benutzer, für die die Website anders aussehen kann, werden immer direkt zu Django weitergeleitet, ohne das Caching also, das in diesem Fall keinen Sinn macht. Der StaticGenerator Pro ist also vor allem für die Anonymous-Anfragen nützlich (die in der Regel mehr als 99% sind).

    Die Definition des Benutzers geschieht nicht nur im Script, sondern auch in nginx (sie beruht auf der Anwesenheit des sessionid in Cookies).
    Deshalb habe ich einige Änderungen im Skript-Generator und in der nginx-Konfiguration vornehmen müssen.

    Der Teil der veränderten nginx-Konfiguration, um die Anonymous von den autorisierten Benutzern zu unterscheiden, sieht folgend aus (statt des Apache Backend funktioniert Django bei mir durch fcgi): 
    http {
# [here must be all standard parameters]
    server {
        server_name  example.com;
	listen  80;
        root   /home/mydjangoproject/www;

	# alle von Anfang an direkt zu Django schicken
        set $django 1;

	# Redirect arbeitet falsch mit dem Fragezeichen,
        # deswegen kommt hier eine Zwischenvariable gelegen
        if ($is_args = "?") {
            set $args_old ?$args;
        }
        if ($is_args = "") {
            set $args_old "";
        }

	# wichtig, denn sonst die Files mit den Argumenten
        # im Namen werden falsch zurückgegeben
        default_type text/html;

        location / {
            if (-f $request_filename/index.html$args_old) {
                    set $django 0;
            }

	   # den autorisierten Benutzer defenieren
            if ($http_cookie ~* "sessionid=([^;]+)(?:;|$)" ) {
                set $django 1;
            }

	    # das Cache zurückgeben
            if ($django = 0) {
                rewrite (.*) $1/index.html$args_old break;
            }

	    # Weiterleitung zu Django
            if ($django) {
		fastcgi_pass unix:/home/mydjangoproject/dj.sock;
		break;
            }

            index       index.html;
            include  conf/fastcgi.conf;
            access_log  logs/project.log  main;
        }
    }
}
    Noch mehr dazu:
    in nginx-logs ist es zu sehen, ob die Website aus dem Cache oder durch Django zurückgegeben wurde. Es reicht, log-Format mit $django zu ergänzen.
    Z.B. so: 
    log_format main	'$remote_addr [$time_local] "$request" '
	'$status $bytes_sent $body_bytes_sent $gzip_ratio '
	'$django "$http_referer" "$http_user_agent"';
    In logs
    0 - die Website aus dem Cache
    1 - aus dem Django durch fcgi

  • Middleware, die die statischen Dateien bei der ersten Anfrage generiert. Alle weiteren Anfragen werden aus dem Cache gezogen.
    Die statischen Dateien werden nur bei der positiven Antwort (Code 200) und der GET-Anfrage geschafft.

    Um das Script zu installieren, muss Generatorpro.py in ein Projektordner angebracht sein und MIDDLEWARE_CLASSES in settings.py mit 'generatorpro.ResponseStaticGenerator' ergänzt sein.
    Auch nicht vergessen, den Weg zum Ordner www aufzuzeigen.
    from os import path
WEB_ROOT = path.realpath("www")
    So kann man das Cache in Projektordner unterbringen.

  • Arbeit mit Links mit Argumenten, folgend ausgesehen: http://www.alrond.com/?test=1
    Jede einzelne Variante wird separat cachiert.

  • In settings.py ist es möglich, Anfang den aus dem Cache ausgeschlossenen Wege anzugeben:
    STATIC_GENERATOR_EXCLUDED = (
    '/comments/postfree',
    '/rating',
    '/rss',
    '/admin',
)
    So werden alle Wege ausgeschlossen, die z.B. mit/comments/postfree ,/rating,/rss ,/admin anfangen.

    Man muss natürlich berücksichtigen, dass manchmal die einzigartigen Daten auch den anonymen Benutzern aufgezeigt werden können, in den Fällen kann man diese Wege auch einfach nur ausschließen.

  • "Intelligentes" Entfernen aus dem Cache
    Das Entfernen des bestimmten Weges führt zum Entfernen aller Varianten mit Argumenten (bis zur ersten Anfrage natürlich).

    Beim Entfernen http://www.alrond.com/en/index.html z.B., werden ebenfalls entfernt http://www.alrond.com/en/index.html?test=1 und http://www.alrond.com/en/index.html?tag=django&sort=desc.

  • Die Möglichkeit des Ausschlusses aus dem Cache in Controller views
    Es genügt, in jedem Controller das response['DisableStaticGenerator'] = 1 vor dem return response einzufügen.
Das Skript ist clever: mein Blog z.B. generiert 14,2 Seiten/sec auf meinem HeimPC, mit diesem Skript ist er in der Lage 7500 Seiten/sec zu generieren. Es ist 530 mal schneller!

Hier können Sie das Script download. Die Datei unterscheidet sich nur mit der hinzugefügten Klasse ResponseStaticGenerator und etwas geänderten Funktion delete_from_path.

Möglicherweise möchte Jared diese Änderungen zu seiner Basis-Version anwenden.

13 Votes | Average: 5 out of 513 Votes | Average: 5 out of 513 Votes | Average: 5 out of 513 Votes | Average: 5 out of 513 Votes | Average: 5 out of 5 (13 votes, average: 5 out of 5)
Loading ... Loading ...
 

Top Posts: