Static File Cache: Speed up TYPO3 Frontend

Extension key

staticfilecache

Package name

lochmueller/staticfilecache

Version

main

Language

en

Author

Tim Lochmüller & Contributors

License

This document is published under the Creative Commons BY 4.0 license.

Rendered

Mon, 01 Sep 2025 12:05:16 +0000

This extension brings a very flexible and very, very, very fast cache to TYPO3. It creates temporary HTML files from static pages and redirects the visitor to the HTML file without loading TYPO3. Your server, whether Apache or Nginx, has less work and consumes less power.

Have fun with the extension!

Note: This extension is a fork of EXT:nc_staticfilecache (before EXT:fl_staticfilecache) and has a lot of improvements. Replace the previous ones with this one if possible.

Table of Contents:

Introduction

What does it do?

It slows down the warming of the earth. Really!

Tests with ApacheBench show an increase in performance (requests served per second) by up to a factor of 230!

This extension generates static HTML files from static pages. If a static page exists, mod_rewrite will redirect the visitor to the static page. That means that TYPO3 will not be loaded at all. Your server will have less work to do and will use less power. That helps to keep our earth cool ;-)

This extension works transparently together with the TYPO3 cache. Static files will be generated for all pages that TYPO3 caches in the cache_pages table. It uses the same decision making logic the 'TYPO3CMSFrontendControllerTypoScriptFrontendController::sendCacheHeaders' function uses to decide if a static file will be generated and it uses the same logic as in 'TYPO3CMSCoreDataHandlingDataHandler::clear_cacheCmd' when removing static files.

Static files are created by default (following the sendCacheHeaders logic) but only when the URI contains no '?' (no URI parameters).

What does it not do?

It does not attempt to take into account any conditions and or, timers.

Useful for really static pages only. Expires headers can be sent with the static files by writing a .htaccess file per statically cached file.

Requirements

A webserver with rewrite capabilities. If you use Apache, you will also need mod_rewrite, mod_headers and mod_expires.

Nginx is also fine (but not in the main focus of the extension): http://www.typofree.org/article/archive/2009/august/title/enabling-nc-staticfilecache-in-typo3-nginx/

Recommended

• Apache mod_expires
• TYPO3 routing configuration or TYPO3 realurl (current version >= 2.3.1) or any other speaking URL mechanism

You have to create a smart strategy to avoid editors from hitting the clear cache button all the time (more important in Boost-Mode): I suggest this UserTsConfig:

options.clearCache.pages = 0
options.clearCache.all = 0

The user could use the clear cache in the page module or the admin have to use clearCacheCmd in a smart way.

Try to avoid this configuration:

[backend.user.isLoggedIn]
    config.no_cache = 1
[global]

Need Support?

There are various ways to get support for the StaticFileCache extension!

Sponsoring

This extension and the manual have been created in endless hours, mostly by a single person. It is actively maintained to cover all supported TYPO3 versions. If this extension helps you in any way to meet your business needs, please consider giving something back and find below some ideas to make me happy.

If you want to make sure this extension will be ready in time for the upcoming TYPO3 release, or you need a feature that isn't implemented yet, just let me know and we'll find a way to organize it!

Credits

• Tim Lochmüller – https://typo3blogger.de / https://360friends.de
• Michiel Roos
• Oliver Hader
• Daniel Poetzinger
• Sonja Scholz
• Marc Hörsken for adding simulateStaticDocuments support
• Helmut Hummel for tipping me on the 'external url' bug
• Dr. Hartmut Plehn and Dirk Wildt, Alexey Boriskin, for the tip on fileCreatemask and version_compare()
• All contributors

Installation

1. Download and install the extension

   Recommended way is to use composer:

   composer require lochmueller/staticfilecache

   Copied!

2. Change your .htaccess, vhost or nginx configuration

   Your TYPO3 installation needs to support rewriting to static files according to the templates in Configuration.

3. Check access rights of the cache directory

   Make sure typo3temp/assets/tx_staticfilecache is accessible publicly

4. Clear the TYPO3 cache

   After installation of the extension, you will need to clear the frontend cache and the backend cache. The reason for this is that the extension uses the TYPO3 cache hooks to generate static files. So if a page has already been cached by TYPO3, the hook will not be called and the static file will not be generated.

Verify the functionality

• Check the statcifilecache configuration test in the backend module.
• Enable basic.debugHeaders in the extension settings.
• Open some frontend pages in a different browser than the one you're logged in with TYPO3.
• Check the staticfilecache module - are there cached pages listed? good!
• Check the your typo3temp/assets/tx_staticfilecache folder for content. Is there content? Good!
• In your code, make sure there are no INT objects on pages you want to be cached. A single statically-uncacheable element will make the entire page statically-uncacheable.

• In the second browser, hard reload the pages you previously called and check for x-sfc headers. Loaded? Good!

  x-sfc-state: TYPO3 - already in cache or x-sfc-state: TYPO3 - add to cache Great!

• x-sfc-state: StaticFileCache - via Fallback Middleware That is ok, but there's something missing in the .htaccess.
• x-sfc-state: StaticFileCache - via htaccess Perfect! You're set.

Third Party Extensions

# Full path for redirect
RewriteRule .* - [E=SFC_FULLPATH:typo3temp/assets/tx_staticfilecache/%{ENV:SFC_PROTOCOL}_%{ENV:SFC_HOST}_%{ENV:SFC_PORT}%{ENV:SFC_URI}/index]

# Do not allow direct call the cache entries
RewriteCond %{ENV:SFC_URI} ^/typo3temp/assets/tx_staticfilecache/.*

'overrideCacheDirectory' => '../typo3-secure-web/typo3temp/assets/tx_staticfilecache/',

Configuration

NOTE that no static files will be created when you are logged into the backend in the same browser session as you are doing the frontend requests with (unless you Ctrl Shift Reload).

Some browsers keep the be_typo_user cookie even when you have logged out of the backend. The cookie will only disappear when you completely close the browser session. Some browsers even store session cookies between stopping and restarting a browser. In such a case you will need to remove the cookies by hand and then restart the browser.

I recommend to use two browsers when testing this extension. One for browsing the frontend and one for configuring the extension in TYPO3 (backend).

Page configuration

By default all pages are marked to be cached. The same logic TYPO3 follows to create page cache is used to create static pages. So you should not have to touch the checkbox in the page properties.

If you want to make it very explicit that you don't want a page to be cached, uncheck the 'Cache page as static file' checkbox in the page properties of that page. You want to do this if your page uses 'timing' features or typoscript conditions that do not work properly when caching to static files.

Please keep in mind, that you have to use a smart internal caching strategy to fit all situations incl. plugins.

Global configuration

Please check the extension configuration file or the settings in the TYPO3 Backend.

htaccess file

This is the base .htaccess configuration. Please take a look for the default variables (SFC_ROOT, SFC_GZIP) and read the comments carefully.

### Begin: StaticFileCache (preparation) ####

# Document root configuration
RewriteRule .* - [E=SFC_ROOT:%{DOCUMENT_ROOT}]
# RewriteRule .* - [E=SFC_ROOT:%{DOCUMENT_ROOT}/t3site] # Example if your installation is installed in a directory
# NOTE: There are cases (apache versions and configuration) where DOCUMENT_ROOT do not exists. Please set the SFC_ROOT to the right directory without DOCUMENT_ROOT then!

# Cleanup URI
RewriteCond %{REQUEST_URI} ^.*$
RewriteRule .* - [E=SFC_URI:/%{REQUEST_URI}]
RewriteCond %{REQUEST_URI} ^/.*$
RewriteRule .* - [E=SFC_URI:%{REQUEST_URI}]
RewriteCond %{REQUEST_URI} ^/?$
RewriteRule .* - [E=SFC_URI:/]

# Cleanup HOST
RewriteCond %{HTTP_HOST} ^([^:]+)(:[0-9]+)?$
RewriteRule .* - [E=SFC_HOST:%1]

# Disable cache for EXT:solr indexing requests
RewriteCond %{HTTP:X-Tx-Solr-Iq} .+
RewriteRule .* - [E=SFC_HOST:invalid-host]

# Disable cache for EXT:crawler indexing requests
RewriteCond %{HTTP:X-T3Crawler} .+
RewriteRule .* - [E=SFC_HOST:invalid-host]

# Important Note for scheme and port. TYPO3 handle Reverse proxies by respect
# X-Forwarded-For headers. The Apache do not know this configuration. If there
# is a reverse proxy that e.g. terminate SSL and all requests are "http", please
# Adapt the following lines to force "http".

# Get scheme
RewriteRule .* - [E=SFC_PROTOCOL:http]
RewriteCond %{SERVER_PORT} ^443$ [OR]
RewriteCond %{HTTP:X-Forwarded-Proto} https
RewriteRule .* - [E=SFC_PROTOCOL:https]

# Get port
RewriteRule .* - [E=SFC_PORT:80]
RewriteCond %{ENV:SFC_PROTOCOL} ^https$ [NC]
RewriteRule .* - [E=SFC_PORT:443]
RewriteCond %{SERVER_PORT} ^[0-9]+$
RewriteRule .* - [E=SFC_PORT:%{SERVER_PORT}]
RewriteCond %{HTTP:X-Forwarded-Port} ^[0-9]+$
RewriteRule .* - [E=SFC_PORT:%{HTTP:X-Forwarded-Port}]

# Full path for redirect
RewriteRule .* - [E=SFC_FULLPATH:typo3temp/assets/tx_staticfilecache/%{ENV:SFC_PROTOCOL}_%{ENV:SFC_HOST}_%{ENV:SFC_PORT}%{ENV:SFC_URI}/index]

# Extension (Order: br, gzip, php, default)
RewriteRule .* - [E=SFC_EXT:]
RewriteCond %{HTTP:Accept-Encoding} br [NC]
RewriteRule .* - [E=SFC_EXT:.br]
RewriteCond %{ENV:SFC_ROOT}/%{ENV:SFC_FULLPATH}%{ENV:SFC_EXT} !-f
RewriteRule .* - [E=SFC_EXT:]
RewriteCond %{ENV:SFC_EXT} ^$
RewriteCond %{HTTP:Accept-Encoding} gzip [NC]
RewriteRule .* - [E=SFC_EXT:.gz]
RewriteCond %{ENV:SFC_EXT} ^\.gz$
RewriteCond %{ENV:SFC_ROOT}/%{ENV:SFC_FULLPATH}%{ENV:SFC_EXT} !-f
RewriteRule .* - [E=SFC_EXT:]
RewriteCond %{ENV:SFC_EXT} ^$
RewriteRule .* - [E=SFC_EXT:.php]
RewriteCond %{ENV:SFC_ROOT}/%{ENV:SFC_FULLPATH}%{ENV:SFC_EXT} !-f
RewriteRule .* - [E=SFC_EXT:]

# Write Extension to SFC_FULLPATH
RewriteRule .* - [E=SFC_FULLPATH:%{ENV:SFC_FULLPATH}%{ENV:SFC_EXT}]

### Begin: StaticFileCache (main) ####

# We only redirect URI's without query strings
RewriteCond %{QUERY_STRING} ^$

# It only makes sense to do the other checks if a static file actually exists.
RewriteCond %{ENV:SFC_ROOT}/%{ENV:SFC_FULLPATH} -f

# NO frontend or backend user is logged in. Logged in users may see different
# information than anonymous users. But the anonymous version is cached. So
# don't show the anonymous version to logged in users.
RewriteCond %{HTTP_COOKIE} !staticfilecache [NC]

# Avoid cached versions for workspace preview links of users that are not
# logged in: https://github.com/lochmueller/staticfilecache/issues/395
RewriteCond %{HTTP_COOKIE} !ADMCMD_prev [NC]

# We only redirect GET requests
RewriteCond %{REQUEST_METHOD} GET

# Rewrite the request to the static file.
RewriteRule .* %{ENV:SFC_ROOT}/%{ENV:SFC_FULLPATH} [L]

# Do not allow direct call the cache entries
RewriteCond %{ENV:SFC_URI} ^/typo3temp/assets/tx_staticfilecache/.*
RewriteCond %{ENV:REDIRECT_STATUS} ^$
RewriteRule .* - [F,L]

# Handle application cache
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-l
RewriteRule ^.*\.sfc$ %{ENV:CWD}index.php?eID=sfc_manifest [QSA,L]

### Begin: StaticFileCache (options) ####

# Set proper content type and encoding for gzipped html.
<FilesMatch "\.gzip$">
   SetEnv no-gzip 1
   SetEnv no-brotli 1
   <IfModule mod_headers.c>
      Header set Content-Encoding gzip
   </IfModule>
</FilesMatch>
<FilesMatch "\.gz$">
   SetEnv no-gzip 1
   SetEnv no-brotli 1
   <IfModule mod_headers.c>
      Header set Content-Encoding gzip
   </IfModule>
</FilesMatch>
<FilesMatch "\.br$">
   SetEnv no-gzip 1
   SetEnv no-brotli 1
   <IfModule mod_headers.c>
      Header set Content-Encoding br
   </IfModule>
</FilesMatch>

# if there are same problems with ForceType, please try the AddType alternative
# Set proper content type gzipped html
<FilesMatch "\.gzip$">
   ForceType text/html
   # AddType "text/html" .gzip
</FilesMatch>
<FilesMatch "\.js\.gzip$">
   ForceType text/javascript
   # AddType "text/javascript" .gzip
</FilesMatch>
<FilesMatch "\.js\.gz$">
   ForceType text/javascript
   # AddType "text/javascript" .gzip
</FilesMatch>
<FilesMatch "\.css\.gzip$">
   ForceType text/css
   # AddType "text/css" .gzip
</FilesMatch>
<FilesMatch "\.css\.gz$">
   ForceType text/css
   # AddType "text/css" .gzip
</FilesMatch>
<FilesMatch "\.xml\.gzip$">
   ForceType text/xml
   # AddType "text/xml" .gzip
</FilesMatch>
<FilesMatch "\.rss\.gzip$">
   ForceType text/xml
   # AddType "text/xml" .gzip
</FilesMatch>
<FilesMatch "\.gz$">
   ForceType text/html
   # AddType "text/html" .gz
</FilesMatch>
<FilesMatch "\.js\.gz$">
   ForceType text/javascript
   # AddType "text/javascript" .gz
</FilesMatch>
<FilesMatch "\.css\.gz$">
   ForceType text/css
   # AddType "text/css" .gz
</FilesMatch>
<FilesMatch "\.xml\.gz$">
   ForceType text/xml
   # AddType "text/xml" .gz
</FilesMatch>
<FilesMatch "\.rss\.gz$">
   ForceType text/xml
   # AddType "text/xml" .gz
</FilesMatch>
<FilesMatch "\.br$">
   ForceType text/html
   # AddType "text/html" .br
</FilesMatch>
<FilesMatch "\.xml\.br$">
   ForceType text/xml
   # AddType "text/xml" .br
</FilesMatch>
<FilesMatch "\.rss\.br$">
   ForceType text/xml
   # AddType "text/xml" .br
</FilesMatch>

# Avoid .br files being delivered with Content-Language: br headers
<IfModule mod_mime.c>
   RemoveLanguage .br
</IfModule>

### End: StaticFileCache ###

If you use the default .htaccess rewrite rules that come with the TYPO3 dummy, then the relevant StaticFileCache configuration should be inserted in the .htaccess file just before these lines:

# If the file/symlink/directory does not exist => Redirect to index.php.
# For httpd.conf, you need to prefix each '%{REQUEST_FILENAME}' with '%{DOCUMENT_ROOT}'.
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-l
RewriteRule ^.*$ %{ENV:CWD}index.php [QSA,L]

If the TYPO3 Installation isn´t in your root directory (say your site lives in https://some.domain.com/t3site/), then you have to add the '/t3site' part to the configuration snippet. It must be placed right after %{DOCUMENT_ROOT}. Here is the line of the ruleset to illustrate:

RewriteRule .* - [E=SFC_ROOT:%{DOCUMENT_ROOT}/t3site]

You are of course free to make the rules as complex as you like.

There might be some files you never want to pull from cache even if they are indexed. For example you might have some custom speaking url rules that make your RSS feed accessible as rss.xml. You can skip rewriting to static file with the following condition:

RewriteCond %{REQUEST_FILENAME} !^.*\.xml$

Keep in mind: If you are using the gzip feature of StaticFileCache you have to take care, that the output is not encoded twice. If the result of the page are cryptic chars like "�‹��í[krÛH’þ-Eô�ª¹±-¹[ À—�É${dùÙkÙ�[îé..." remove the "text/html " in the mod_deflate section of the default TYPO3 .htaccess rules.

Troubleshooting: It is also necessary that the autogenerated .htaccess files in the StaticFileCache directory (by default typo3temp/assets/tx_staticfilecache) will be not ignored by the server. Sometimes in the vHost configuration various directories could be marked to deny an overwrite by an additional .htaccess file for performance reasons.

Nginx configuration

Configuration file changes

This configuration example adds a named location called @sfc which replaces the usual invocation of TYPO3's index.php. The @sfc location includes all checks necessary to decide whether the current request can be handled with a static file or needs to be directed to TYPO3. If all checks pass, the try_files_ directive is used to find the files in typo3temp/assets/tx_staticfilecache/ and if unavailable, redirect to index.php.

In your nginx configuration you need to replace your '/' location, which probably looks like the following:

location / {
    try_files $uri $uri/ /index.php$is_args$args;
}

By the following configuration:

location / {
    try_files $uri $uri/ @sfc;
}

# Special root site case. prevent "try_files $uri/" + "index" from skipping the cache
# by accessing /index.php directly
location =/ {
    recursive_error_pages on;
    error_page 405 = @sfc;
    return 405;
}

location @t3frontend {
    # Using try_files for ease of configuration demonstration here,
    # you can also fastcgi_pass directly to php here
    try_files $uri /index.php$is_args$args;
}

location @sfc {
    # Perform an internal redirect to TYPO3 if any of the required
    # conditions for StaticFileCache don't match
    error_page 405 = @t3frontend;

    # Query String needs to be empty
    if ($args != '') {
        return 405;
    }

    # We can't serve static files for logged-in BE/FE users
    if ($cookie_staticfilecache = 'typo_user_logged_in') {
        return 405;
    }

    if ($cookie_be_typo_user != '') {
        return 405;
    }

    # Ensure we redirect to TYPO3 for non GET/HEAD requests
    if ($request_method !~ ^(GET|HEAD)$ ) {
        return 405;
    }

    # Disable cache for EXT:solr indexing requests
    if ($http_x_tx_solr_iq) {
        return 405;
    }

    # Disable cache for EXT:crawler indexing requests
    if ($http_x_t3crawler) {
        return 405;
    }

    charset utf-8;
    default_type text/html;
    try_files /typo3temp/assets/tx_staticfilecache/${scheme}_${host}_${server_port}${uri}/index
          /typo3temp/assets/tx_staticfilecache/${scheme}_${host}_${server_port}${uri}
          =405;
}

location /typo3temp/assets/tx_staticfilecache {
    deny all;
}

If you activate the php generator you need to use this block accepting urls with trailing slashes only

if (!-f $document_root/typo3temp/assets/tx_staticfilecache/${scheme}_${host}_${server_port}${uri}index.php) {
    return 405;
}

include /etc/nginx/fastcgi_params;
fastcgi_pass unix:/var/run/php/php-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root/typo3temp/assets/tx_staticfilecache/${scheme}_${host}_${server_port}${uri}/index.php;

or this block accepting urls with or without trailing slashes

if (!-f $document_root/typo3temp/assets/tx_staticfilecache/${scheme}_${host}_${server_port}${uri}/index.php) {
    return 405;
}

include /etc/nginx/fastcgi_params;
fastcgi_pass unix:/var/run/php/php-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root/typo3temp/assets/tx_staticfilecache/${scheme}_${host}_${server_port}${uri}/index.php;

instead of

charset utf-8;
default_type text/html;
try_files /typo3temp/assets/tx_staticfilecache/${scheme}_${host}_${server_port}${uri}/index
      /typo3temp/assets/tx_staticfilecache/${scheme}_${host}_${server_port}${uri}
      =405;

Extension configuration

Nginx does not support .htaccess files and therefore cannot transfer HTML headers for the statically cached files. You should therefore activate the PHP generator, so that the static content is written to a PHP file via which the correct HTML headers are set.

Routing

Since TYPO3 there is a modern routing mechanims. Please use this to create real/speaking urls.

It is also possible to handle e.g. the XML sitemp. This is the example configuration for a /sitemap.xml incl. sub sitemaps without cHash to get this sitemaps to the StaticFileCache:

routeEnhancers:
  PageTypeSuffix:
    type: PageType
    default: .html
    index: index
    map:
      sitemap.xml: '1533906435'
  SitemapNames:
    type: Simple
    routePath: '/s/{sitemap}'
    requirements:
      sitemap: '.*'
    _arguments:
      sitemap: 'sitemap'
    aspects:
      sitemap:
        type: StaticValueMapper
        map:
          pages: 'pages'
          news: 'news'
          xxxx: 'xxxxx'
  SitemapNamesPage:
    type: Simple
    routePath: '/s/{sitemap}/{page}'
    requirements:
      sitemap: '.*'
      page: '\d+'
    _arguments:
      sitemap: 'sitemap'
      page: page
    aspects:
      sitemap:
        type: StaticValueMapper
        map:
          pages: 'pages'
          news: 'news'
          xxxx: 'xxxxx'
      page:
        type: StaticRangeMapper
        start: '1'
        end: '100'

TypoScript

You can disable the StaticFileCache by adding one line of TS:

config.tx_staticfilecache.disableCache = 1

This is also useful, if you want to disable StaticFileCache for specific page types or other conditions, for example:

[getTSFE().type == <type>]
config.tx_staticfilecache.disableCache = 1
[global]

Extended

Monitoring

The state of the indexing table can be monitored using the 'StaticFileCache' module.

A list will appear which you can use to monitor the state of the indexing process. It will tell you if a file has been cached statically, if so when it was cached and when it is set to expire. If you have any other ideas, let me know.

But most importantly, when a file has been hit but has not been cached, the explanation column will explain why. This can be very useful when you are trying to optimize your site. You might find out that a whole tree has been set to no_cache for example.

|monitoring|

Static dynamic extensions

You can write static-dynamic extensions. These are set to USER, but still display 'dynamic' data (. . . like most visited pages, news, rss feeds etc.). The TYPO3 and static cache will have to be cleared actively as soon as the content of the page changes.

In the case of a news page this may be done using the page TSConfig clearCacheCmd setting for example. You can set the page TSConfig on your news folder so it will automagically clear the cache (and the static page) of your news page.

FAQ

The need for speed

Here are some test results for a USER page generated from cache by TYPO3 and one pushed from static html. The test tool used is apache bench. The “-c” means that 10 simultaneous users are simulated, “-n 500” means that a thousand unique requests are generated.

By default apachebench uses NoKeepAlive which means that every image and css file will use a new apache connection.

Future test may include measurements done sucking a complete site (static + dynamic pages) once with static cache enabled and once without static cache enabled. Sucking tools:

• crawler extension (TYPO3)
• curl
• httrack
• wget
• siege
• ... need to check

Tests were run on a Unibody MacBook Pro with 4GB of ram and a tweaked out apache and mysql configuration.

The USER cached page

ab -c 10 -n 100 http://some.fictive.domain.org/gnu-gpl-short/

This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking some.fictive.domain.org (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Finished 500 requests


Server Software:        Apache
Server Hostname:        some.fictive.domain.org
Server Port:            80

Document Path:          /gnu-gpl-short/
Document Length:        12088 bytes

Concurrency Level:      10
Time taken for tests:   48.854 seconds
Complete requests:      500
Failed requests:        28
   (Connect: 0, Receive: 0, Length: 28, Exceptions: 0)
Write errors:           0
Total transferred:      6240528 bytes
HTML transferred:       6044028 bytes
Requests per second:    10.23 [#/sec] (mean)
Time per request:       977.077 [ms] (mean)
Time per request:       97.708 [ms] (mean, across all concurrent requests)
Transfer rate:          124.74 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:       12   25  15.5     19     117
Processing:   492  945 182.0    924    1624
Waiting:      462  903 174.3    874    1546
Total:        520  970 184.1    944    1673

Percentage of the requests served within a certain time (ms)
  50%    944
  66%   1021
  75%   1071
  80%   1104
  90%   1217
  95%   1314
  98%   1414
  99%   1553
  100%   1673 (longest request)

The static html page pushed by mod_rewrite

ab -c 100 -n 1000 http://some.fictive.domain.org/gnu-gpl-short/

This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking some.fictive.domain.org (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Finished 500 requests


Server Software:        Apache
Server Hostname:        some.fictive.domain.org
Server Port:            80

Document Path:          /gnu-gpl-short/
Document Length:        12038 bytes

Concurrency Level:      10
Time taken for tests:   3.697 seconds
Complete requests:      500
Failed requests:        0
Write errors:           0
Total transferred:      6194000 bytes
HTML transferred:       6019000 bytes
Requests per second:    135.24 [#/sec] (mean)
Time per request:       73.945 [ms] (mean)
Time per request:       7.394 [ms] (mean, across all concurrent requests)
Transfer rate:          1636.04 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:       12   20   6.8     19      83
Processing:    38   53  17.3     49     149
Waiting:       19   30  13.8     28     126
Total:         55   73  18.4     69     168

Percentage of the requests served within a certain time (ms)
  50%     69
  66%     72
  75%     74
  80%     75
  90%     83
  95%    116
  98%    157
  99%    163
 100%    168 (longest request)

Test result

Quick calculation show us a performance increase factor of: 135.24 / 10.23 = 13.22 Let's see that again, but with more energy: 1322 %

Wow!

That figure used to read 23000%. But this test was done on a server running on a cluster and not running a PHP accelerator. You may have even more performance increase on a machine running in 'bare metal' mode and running a PHP opcode cache.

Here is an example of my own server running Nginx and APC. It's a lightweight XEN box with 720MB of ram and 4 cores:

The USER cached page served by Nginx

This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking www.typofree.org (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests


Server Software:        nginx
Server Hostname:        www.typofree.org
Server Port:            80

Document Path:          /articles/optimizing-typo3-backend-responsiveness/
Document Length:        63637 bytes

Concurrency Level:      100
Time taken for tests:   12.341 seconds
Complete requests:      1000
Failed requests:        24
   (Connect: 0, Receive: 0, Length: 24, Exceptions: 0)
Write errors:           0
Total transferred:      64233296 bytes
HTML transferred:       63836716 bytes
Requests per second:    81.03 [#/sec] (mean)
Time per request:       1234.098 [ms] (mean)
Time per request:       12.341 [ms] (mean, across all concurrent requests)
Transfer rate:          5082.89 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:       27  104 403.0     47    3620
Processing:   387 1088 372.9   1015    2776
Waiting:       82  545 324.5    516    1553
Total:        422 1192 573.9   1061    5080

Percentage of the requests served within a certain time (ms)
  50%   1061
  66%   1139
  75%   1234
  80%   1310
  90%   1898
  95%   2030
  98%   2691
  99%   4376
 100%   5080 (longest request)

The static html page pushed by Nginx rewrite

This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking www.typofree.org (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests


Server Software:        nginx
Server Hostname:        www.typofree.org
Server Port:            80

Document Path:          /articles/optimizing-typo3-backend-responsiveness/
Document Length:        63588 bytes

Concurrency Level:      100
Time taken for tests:   11.679 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      64305368 bytes
HTML transferred:       64006704 bytes
Requests per second:    85.63 [#/sec] (mean)
Time per request:       1167.861 [ms] (mean)
Time per request:       11.679 [ms] (mean, across all concurrent requests)
Transfer rate:          5377.20 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:       30  191 592.3     58    4191
Processing:   330  920 350.0    837    3245
Waiting:       30   72  68.2     61    1929
Total:        494 1111 689.3    917    5254

Percentage of the requests served within a certain time (ms)
  50%    917
  66%   1106
  75%   1232
  80%   1324
  90%   1553
  95%   2216
  98%   3821
  99%   4270
 100%   5254 (longest request)

That's a slight improvement. But altogether Nginx can take on much more of a beating than Apache. The CPU rises to a load of 0.4 when taking this beating without StaticFileCache and it idles at 0.0 when StaticFileCache is enabled.

Soo ... bring on those success reports!

Static tt_news setup

Normally tt_news is a USER_INT plugin. You can set it to USER using TypoScript:

plugin.tt_news = USER

Now you need to manually clear the pages on which you have the tt_news plugin installed. Luckily for you this can be accomplished easily using:

TCEMAIN.clearCacheCmd = pid,pid,pid

Where pid is the pid of the pages on which you have the news plugin installed. You place this snippet as TSconfig on your news folder.

|news|

Now, if you create a new news item in the news folder, the cache for the given pid's will automatically be cleared. This means of couse that the static files will also be cleared.

There are more TSconfig settings you might want to look into:

clearCacheCmd / List of values (integers, "all", "pages")

This can allow you to have the cache for additional pages cleared when saving to some page or branch of the page tree. Examples: # Will clear the cache for page ID 12 and 23 # when saving a record in this page: TCEMAIN.clearCacheCmd = 12,23

# Will clear all pages cache: TCEMAIN.clearCacheCmd = pages

# Will clear ALL cache: TCEMAIN.clearCacheCmd = all

clearCache_pageSiblingChildren / boolean

If set, then children of all siblings of a page being edited will have the page cache cleared. (Default is that when a page record is edited, the cache for itself and siblings (same level) is cleared.)

clearCache_pageGrandParent / boolean

If set, then the grand parent of a page being edited will have the page cache cleared.

Known problems

Apache 2.4.7 has a bug in the mod_dir-mod_rewrite combination. This is the reason why the homepage (just "/") could not be redirected to the generated static file (all other links should work). More information in this bugreport: https://bz.apache.org/bugzilla/show_bug.cgi?id=56434

mnoGoSearch extension uses content post processing hook to modify the content when indexer fetches pages. This is necessary to respect TYPO3SEARCH_xxx markers. StaticFileCache bypasses the hook and always returns original content. Thus mnogosearch does not work properly.

In order to solve the problem, the following should be added to .htaccess file of the web site:

RewriteCond %{HTTP:X-TYPO3-mnogosearch} ^$

If you find any other problems, please create an according GitHub issue.

Please take some time and make a proper report stating at least:

• version of the extension
• reproducibility
• steps to reproduce
• observed behavior
• expected behavior

Writing a good bug report will help us to fix the bugs faster and better.

insertPageIncache hook problem

There are situations, where the page is created with a new URL, but TYPO3 could fetch the page via cache already. In this case the insertPageIncache hook is not called again and the page will not cached staticly.

config.linkVars = L
config.defaultGetVars {
    L = 0
}

In this configuration example you get two pages like http://www.domain.org/ and http://www.domain.org/en/ but TYPO3 call the hook only once.

Find more details and a workaround of this problem in this comment of GitHub issue #7.

ChangeLog

2015-12-28 Tim Lochmüller <tim@fruit-lab.de>

• [BUGFIX] Fix the "Illegal link configuration." check
• [BUGFIX] Fix the security rule to allow the redirect but disallow the direct access
• [TASK] Format the htaccess file (one comment)
• [TASK] Migrate Cookie related stuff to the CookieUtility
• [TASK] Format the code by PSR-2
• [BUGFIX] There is no first parameter for the GeneralUtility::milliseconds function
• [TASK] Convert array to short syntax (need PHP 5.4.x)
• [BUGFIX] #70673 No static file after FE user logged out
• [BUGFIX] #70994 Tree view in info module just one entry (TYPO3 7.x)
• [BUGFIX] Fix the remove expired pages button
• Add comment about the core bug
• Prepare Release 3.5.0

2015-09-09 Tim Lochmüller <tim@fruit-lab.de>

• [BUGFIX] Fix the ValidUri Rule. Also check for "index.php" in the URI
• Introduce REQUEST_URI wrapper in the htaccess file. Fix problem of empty URI #59182
• Fix typo in the htaccess file
• Streamline the htaccess configuration
• Put the document root also in a env variable (.htaccess)
• [BUGFIX] Fix the security rule
• [BUGFIX] don't delete cache, when editor changes content in workspaces
• [BUGFIX] Add one more rule check for the valid cache URI

2015-08-20 Tim Lochmüller <tim@fruit-lab.de>

• #68473 Fix compatibility bug for 7.x
• Prepare Release 3.4.1

2015-07-13 Tim Lochmüller <tim@fruit-lab.de>

• Prepare Release 3.4.0
• Set TYPO3 compatibility to 6.2.x - 7.x.x

2015-07-10 Tim Lochmüller <tim@fruit-lab.de>

• [!!!] Add the scheme/protocol to the Cache path and to the htaccess rules file
• Migrate teh gzip htaccess and the plain htaccess to one file. If you do not use gzip, you just have to comment out one line
• Remove the dummy htaccess file and migrate them to the documentation file
• Add a security rule to prevent direct calls of static cache entries
• Remove the ValidProtocol Rule
• Fix https://forge.typo3.org/issues/66842

2015-06-17 Tim Lochmüller <tim@fruit-lab.de>

• Fix https://forge.typo3.org/issues/67373
• Fix https://forge.typo3.org/issues/67526

2015-05-08 Tim Lochmüller <tim@fruit-lab.de>

• Prepare Release 3.3.1

2015-05-05 Tim Lochmüller <tim@fruit-lab.de>

• Fix #56519 Add notice about AddType in the .htaccess
• Fix #66779 (partly) wrong empty Space in .htaccess template
• Add lines of #58315 to the cookie hook, to check if a FE cookie already exists (disabled)
• Remove the double .htaccess files, because realurl and simulateStaticDocuments use the same structure
• Add one separate explanation for every single INT script in the page
• Split up the Slot handling and the rule checking in the rules

2015-05-04 Tim Lochmüller <tim@fruit-lab.de>

• Prepare Release 3.3.0

2015-04-30 Tim Lochmüller <tim@fruit-lab.de>

• Enable clearCacheForAllDomains again
• Set clearcacheonload to TRUE and set the Version compat to 6.2.x - 7.2.x
• Migrate the last two caching rules
• Move More backend module HTML to template file
• Introduce the CacheUtility
• Use the PathUtility to call pathinfo functions
• Avoid double slash in the cache filename path
• Add class information to the explanation
• Remove all the HTML in the backend module class
• Cache the meta information as serialized array
• Code cleanups

2015-04-28 Tim Lochmüller <tim@fruit-lab.de>

• Move ClearCachePostProc.php to separate class
• Move HeaderNoCache to separate class
• Move the decision if the page is cachable to a rule based system (first two rules)
• Fix documentation against http://docs.typo3.org/typo3cms/extensions/staticfilecache/3.2.0/warnings.txt
• Move the WorkspacePreview Rule to a separate class
• Speed up the flushByTag function of the StaticFileBackend
• Remove the overhead of the debugger. Code checks should be done via e.g. xDebug and not with inline code rubbish
• Move the UserOrGroup Rule to a separate class
• Move the NoIntScripts Rule to a separate class
• Remove old ClearCacheProcessing variable and handling
• Fix #66651 Missing %{TIME} in RewritCond for Cache-Control header
• Move the LoginDeniedConfiguration Rule to a separate class
• Move the PageCacheable Rule to a separate class
• Replace Hooks with more modern Signals
• Move the ValidProtocol Rule to a separate class
• Move the setFeUserCookie Hook to separate class
• Code cleanup and fix typos

2015-04-28 Klaus Bitto <klaus@netcreators.nl>

• Release of v3.2.0 to TER. Thanks to Tim Lochmüller for his extensive work.

2015-04-22 Tim Lochmüller <tim@fruit-lab.de>

• Start to migrate the DB structure to the TYPO3 Caching framework
• Add collectGarbage to CommandController
• Remove "removeCacheDirectory" - files are deleted via CF now
• Migrate one deleteStaticCacheDirectory to CF
• Reduce the load of the CF frontend
• Fix the order of the CF calls
• [!!!] Remove the handling of 'dirty' cache entries. We switch to the CF and dirty entries are expired ones.
• Fix flush cache
• Delete cache via caching framework
• Move the creation of the htaccess to the StaticFileBackend
• Move the .htaccess content to a separate template file
• Move Backend module to a separate template file (partly)
• StaticFileCache.php Singleton
• Split up the StaticFileBackend into General/Abstract and File related functions
• Remove old cacheDir variable in StaticFileCache class
• Update PhpDoc comments
• Move more HTML to the templates of the Backend module
• removed unused function getContentObject
• Integration SFC Backend functions for the cache
• [!!!] Migrate the backend module and all functions to the new Caching Framework mechanism
• Migrate one manually clear cache to the core mechanism, by tagging the pages with the right pageId_X tag
• Remove old functions (more migration to CF)
• Move LogNoCache to separate class
• Cleanup the clearCachePostProc function

2015-04-20 Tim Lochmüller <tim@fruit-lab.de>

• Migration of the documentation to basic RestructuredText

2015-04-17 Tim Lochmüller <tim@fruit-lab.de>

• Fix #6648 The explanation database table field should be emptied while an update
• Fix #42734 recreateURI() should keep realurl encoded parameter
• Migration first documentation blocks
• Use the caching framework for creating the cache files
• Fix the backend module for the new Configuration class
• Feature #9510 Add the expiration date to the html footer comment (configuration strftime should just the date format. "strftime" is used for both dates now)
• Fix #56519 Gzipped output broken when compressionLevel is set to 0

2015-04-16 Klaus Bitto <klaus@netcreators.nl>

• Release of v3.0.0 for TYPO3 6.2.x - 7.1.x to TER. Thanks to the contributors Tim Lochmüller and Jürgen Kußmann!

2015-04-16 Tim Lochmüller <tim@fruit-lab.de>

• [!!!] Create a command controller and mark the CLI and Tasks class as deprecated. The classes are removed in a few versions
• Move the crawler hook to the new (namespace based) location
• Move the Info module to the new (namespace based) location
• Migrate the L10N file in the root folder to the new L10N file in Resources/Private/Language/locallang.xml
• Change extension icon from gif to png
• Move the main class to the new (namespace based) location
• Remove the old CLI and the old tasks, because the scheduler do not break directly. Please create the tasks as extbase command controller tasks and change your env
• Move ChangeLog to new ReSt documentation
• Move Readme to new ReSt documentation
• Fix #58178 Handling of non-ASCII URIs
• Fix #65700 StaticFileCache module not working correctly on latest TYPO3 7.1
• Increase compatibility to 6.2.x - 7.1.x
• Fix #64769 Enable HTTPS caching impossible
• Release of v3.0.0 to TER

2015-04-15 Tim Lochmüller <tim@fruit-lab.de>

• Remove closing PHP Tags (CGL)
• Format the PHP classes (CGL)
• Remove old XCLASS code lines in the footer of the classes
• Remove $GLOBALS['TYPO3_DB'] to helper method
• Fix PhpDoc
• import namespace classes
• handle GeneralUtility::mkdir_deep in the right way
• fix undefined variable notice

2015-01-12 Jürgen Kußmann <juergen.kussmann@aoe.com>

• Add/Update dependency to TYPO3 6.2 and PHP 5.3
• Use TYPO3-CORE-classes with namespaces

2014-11-11 Klaus Bitto <klaus@netcreators.nl>

• Release of v2.5.2 to TER.

2014-11-01 Tim Lochmueller <tim@fruit-lab.de>

• Fix #61980: Use M code for ExpireByType instead of A (https://forge.typo3.org/issues/61980)
• Fix #62538: URLs ending with "/" not handled properly (https://forge.typo3.org/issues/62538)

2014-04-10 Klaus Bitto <klaus@netcreators.nl>

• Release of v2.5.1 to TER.

2014-03-26 Tim Lochmueller <tim@fruit-lab.de>

• Remove global statements and use $GLOBAL
• Smarter explanation for plugins like ExtBase plugins, if the page is not cacheable. More details about extensionName, pluginName...

2014-03-25 Tim Lochmueller <tim@fruit-lab.de>

• Wrong severity in call to t3lib_div::devLog()
• Wrap removed function t3lib_div::intval_positive in the Scheduler task to support 6.x
• Fix old PHP4 constructor call in the cleaner task
• Backport changes from TER version to trunk
• Set dependencies to TYPO3 4.5 minimum
• Wrap testInt once more, to prefer the TYPO3 CMS 4.7 t3lib_utility_Math function
• Cleanup and add same classes to the ext_autoload.php
• Remove PATH_t3lib usage to fit 6.x

2014-03-11 Klaus Bitto <klaus@netcreators.nl>

• Fixed bug: Call to undefined method TYPO3CMSCoreUtilityGeneralUtility::intval_positive() in class.tx_ncstaticfilecache_tasks_processDirtyPages_AdditionalFieldProvider.php (Thank you, Hendrik Reimers)
• Increased compatibility to TYPO3 6.2.

2014-03-07 Klaus Bitto <klaus@netcreators.nl>

• Integrated TYPO3 6 compatibility adjustments for TER release as v2.4.0. (Selective merge from https://svn.typo3.org/TYPO3v4/Extensions/staticfilecache/trunk/.)

2010-10-13 Oliver Hader <oliver@typo3.org>

• Fixed bug: Database elements are removed if directory on the filesystem exists, but could not be accessed

2010-09-20 Oliver Hader <oliver@typo3.org>

• Fixed bug: Removing of static files returned wrong boolean value
• Fixed bug #9850: Small coding errors (thanks to Axel Jung)
• Raised version to 2.3.3

2010-09-08 Oliver Hader <oliver@typo3.org>

• Cleanup: Fixed svn:eol-style of PHP and text files
• Fixed bug: Only remove database elements if removal in filesystem was successful
• Added feature: Integrate logging to devLog if clearing static caches failes
• Raised version to 2.3.2

2010-07-19 Oliver Hader <oliver@typo3.org>

• Fixed bug: Typing error in hook name
• Fixed bug: Infomodule shows creation time instead of last modification

2010-07-15 Oliver Hader <oliver@typo3.org>

• Cleanup: Fixed naming and formatting
• Cleanup: Removed superfluous hook in processDirtyPages() method that was only available in Trunk

2010-07-14 Franz Ripfel <franz.ripfel@abezet.de>

• Fixed bug: Clearing cache of a single page deleted also all folders and files of subpages

2010-07-13 Oliver Hader <oliver@typo3.org>

• Fixed bug: TYPO3 cache gets cleared on removing expired pages with the markDirtyInsteadOfDeletion setting enabled (thanks to Juergen Kussmann)

2010-05-28 Oliver Hader <oliver@typo3.org>

• Added feature: Integrate possibility to disable the clear cache post processing on deman during runtime

2010-05-27 Oliver Hader <oliver@typo3.org>

• Fixed bug: markDirtyInsteadOfDeletion property shall only consider specific pages - thus not clear all or pages cache
• Cleanup: Fixed formatting and inline type hints
• Fixed bug: Database element is not removed if clearing files did not succeed
• Fixed bug: Pages with an endtime that would expire a page before the general expiration time is not considered
• Fixed bug: Additional hash is not written for database elements
• Fixed bug: Additional hash is not considered for lookups when empty

2010-05-25 Oliver Hader <oliver@typo3.org>

• Added feature: Integrate hook to post process the cache scenario after (no matter whether static cache was written)

2010-04-30 Oliver Hader <oliver@typo3.org>

• Added feature: Integrate hook to handle deleting a static cached directory

2010-04-19 Oliver Hader <oliver@typo3.org>

• Follow-up to bug #5290: Expect the scheme name at first position and allow to modifiy with hook

2010-04-15 Oliver Hader <oliver@typo3.org>

• Follow-up to feature of predefining/extending values that are stored in the database
• Added feature: Add additionalhash to implement individual and more specific database elements (utilized by hooks)
• Fixed bug: removeExpiredPages triggeres clearing cache of a page multiple times

2010-04-14 Oliver Hader <oliver@typo3.org>

• Cleanup: Moved logging part of writing cache files to accordant place
• Cleanup: Moved information that determine whether a page is cachable and added to them to hook parameters
• Cleanup: Moved implementation to write compressed content to separate method
• Cleanup: Extended parameters of createFile_processContent hook by URI and hostname
• Cleanup: Renamed internal variable name
• Added feature: Add possibility to predefine/extend values that are stored in the database

2010-02-22 Michiel Roos <michiel@netcreators.com>

• Updated the manual

2010-02-20 Michiel Roos <michiel@netcreators.com>

• Feature #3286: Enable usage of value 'reg1' from cache pages (Thanks to Alienor.net)

2010-02-19 Michiel Roos <michiel@netcreators.com>

• Feature #4179: Create gzipped versions of cache files (Thanks to Steffen Gebert)
• Fixed bug #5290: nc_staticfilecache caches contents of https pages! (Thanks to Stefan Galinski)
• Fixed bug #6525: EM refers to cc_devlog (Thanks to Steffen Gebert)

2010-02-17 Michiel Roos <michiel@netcreators.com>

• Fixed bug #6504: port based installations doesn't work (Thanks to Stefan Galinski)

2010-01-30 Michiel Roos <michiel@netcreators.com>

• Change: Show original URI on hover in infomodule

2010-01-22 Michiel Roos <michiel@netcreators.com>

• Fixed bug #6158: Scheduler tasks: missing ext_autoload (Thanks to Peter Schuster)

2010-01-14 Michiel Roos <michiel@netcreators.com>

• Fixed bug #4715: List what element are of INT type. (Thanks to Mads Jensen)
• Added feature #6026: Provide scheduler tasks (Thanks to Michael Klapper)

2010-01-14 Oliver Hader <oliver@typo3.org>

• Fixed bug: tx_ncstaticfilecache::processDirtyPages() removes entries from diry queue even if the processing did not succeed

2009-08-31 Oliver Hader <oliver@typo3.org>

• Fixed bug: Method tx_ncstaticfilecache::deleteStaticCacheDirectory() is protected but should be public

2009-08-13 Oliver Hader <oliver@typo3.org>

• Fixed bug: Current page Id is not outputted in form of backend info module

2009-08-10 Oliver Hader <oliver@typo3.org>

• Fixed bug: Visualization of tree in backend info module
• Fixed bug: Visaulization does not depend on selected page of real page branch in backend info module
• Fixed bug: Markup is incorrect on rendering the table in the backend info module
• Fixed bug: Expanding/collapsing did not stay at the selected page in the backend info module

2009-08-07 Oliver Hader <oliver@typo3.org>

• Added feature: Integrate possibility to disable static caching for a page branch (tx_ncstaticfilecache.disableCache)

2009-07-21 Oliver Hader <oliver@typo3.org>

• Added feature: New hook 'createFile_initializeVariables' to initialize variabled before starting the processing

2009-06-30 Oliver Hader <oliver@typo3.org>

• Fixed bug: CLI debug output in processDirtyPages() does not contain directory name
• Fixed bug: Clearing cached pages (clear_cacheCmd=pages) does not trigger clearing static cache
• Cleanup: Added methods to determine extension configuration and select specific properties
• Fixed bug: Processing of dirty pages is shown in info module even if using the dirty flag is not enabled
• Fixed bug: If necessary, the root of the cache directory should be deleted first

2009-06-23 Daniel Poetzinger <dev@aoemedia.de>

• Added feature: Integrate processing instruction for crawler extension

2009-06-23 Oliver Hader <oliver@typo3.org>

• Cleanup: Added method to be used on delegating actions to the static cache data manipulation object
• Cleanup: Fixed ChangeLog and formatting of processing instruction for crawler extension

2009-06-22 Oliver Hader <oliver@typo3.org>

• Fixed bug: Information whether page is marked dirty is missing in info module
• Added feature: Integrate possibility to remove all expired pages in the info module
• Added feature: Moved rendering of rows in info module to own method to be overridable by XCLASSes
• Cleanup: Refactored clean dirty pages parts
• Cleanup: Added method to determine the table name used to store cache information
• Added feature: Integrate possibility to process all dirty pages in the info module

2009-06-12 Oliver Hader <oliver@typo3.org>

• Fixed bug: Info module does not show pages with a dokType above 199

2009-05-08 Oliver Hader <oliver@typo3.org>

• Added feature: Changed database table to use InnoDB engine
• Follow-up to feature #2598: Added missing 'isdirty' field to SQL definitions
• Follow-up to feature #2598: Added new CLI task 'processDirtyPages' to process elements marked as dirty
• Follow-up to feature #2598: Set 'isdirty' flag zero when database element gets updated

2009-05-07 Oliver Hader <oliver@typo3.org>

• Cleanup: Changed formatting of class tx_ncstaticfilecache and SQL file (non-functional changes)
• Set version to 2.4.0-dev
• Set version to 3.0.0-dev
• Cleanup: Added protected/public definitions and set min. requirement to TYPO3 4.2.0
• Cleanup: Removed superfluous class for debug output and integrated it to regular class
• Cleanup: Removed CLI cleaner for elderly TYPO3 releases (< 4.1)
• Fixed bug: Fixed some hanging record sets
• Fixed bug: Info module does not work anymore due to calls to protected methods/variables
• Added feature: Store original URI of request and possibility to recreate the URI by typoLink
• Added feature #2598: Keep static cache files even if the cache gets flushed by TYPO3
• Fixed bug: Show generation signature only when the request is served by static cache
• Added feature: New hook 'createFile_processContent' to modify content before being written to cached file

2008-02-22 Michiel Roos <michiel@netcreators.com>

• Added Changelog ;-)
• Removed version_compare() from insertPageInCache()
• Rename modfunc1 to infomodule

Sitemap

Index