FCGI Buffer

NOMBRE

FCGI::Buffer: verificar, almacenar en caché y optimizar la salida FCGI

VERSIÓN

Versión 0.19

SINOPSIS

FCGI::Buffer verifica el HTML que usted produce pasándolo a través de HTML::Lint .

FCGI::Buffer optimiza los programas FCGI reduciendo, filtrando y comprimiendo la salida para acelerar la transmisión y haciendo uso casi sin problemas de las cachés del cliente y del servidor.

Para hacer uso de las cachés del cliente, es decir para reducir las llamadas innecesarias a tu servidor solicitando los mismos datos:

 use FCGI;
use FCGI::Buffer;
# ...
my $request = FCGI::Request();
while($request->FCGI::Accept() >= 0) {
    my $buffer = FCGI::Buffer->new();
    $buffer->init(
            optimise_content => 1,
            lint_content => 0,
    );
    # ...
}

Para hacer uso también de las cachés del servidor, es decir, para guardar la salida regenerada cuando diferentes clientes le soliciten los mismos datos, necesitará crear una caché. Pero eso es simple:

 use FCGI;
use CHI;
use FCGI::Buffer;

# ...
my $request = FCGI::Request();
while($request->FCGI::Accept() >= 0) {
    my $buffer = FCGI::Buffer->new();
    $buffer->init(
        optimise_content => 1,
        lint_content => 0,
        cache => CHI->new(driver => 'File')
    );
    if($buffer->is_cached()) {
        # Nothing has changed - use the version in the cache
        $request->Finish();
        next;
    # ...
    }
}

Para evitar temporalmente el uso de cachés del lado del servidor, por ejemplo, durante la depuración antes de publicar un cambio de código, establezca la variable de entorno NO_CACHE en cualquier valor distinto de cero. Esto también evitará que se agregue ETag al encabezado. Si recibe errores sobre caracteres anchos impresos, significa que ha olvidado emitir HTML puro en caracteres que no son ASCII. Ver HTML::Entidades. Como solución alternativa, también puedes eliminar acentos y similares usando Text::Unidecode, que funciona bien pero no es realmente lo que deseas.

SUBRUTINAS/MÉTODOS

nuevo

Cree un objeto FCGI::Buffer. Haga uno de estos para cada FCGI::Aceptar.

inicio

Establezca varias opciones y anule los valores predeterminados.

 # Put this toward the top of your program before you do anything
# By default, generate_tag, generate_304 and compress_content are ON,
# optimise_content and lint_content are OFF.  Set optimise_content to 2 to
# do aggressive JavaScript optimisations which may fail.
use FCGI::Buffer;

my $buffer = FCGI::Buffer->new()->init({
    generate_etag => 1,     # make good use of client's cache
    generate_last_modified => 1,    # more use of client's cache
    compress_content => 1,  # if gzip the output
    optimise_content => 0,  # optimise your program's HTML, CSS and JavaScript
    cache => CHI->new(driver => 'File'),    # cache requests
    cache_key => 'string',  # key for the cache
    cache_age => '10 minutes',      # how long to store responses in the cache
    logger => $self->{logger},
    lint_content => 0,      # Pass through HTML::Lint
    generate_304 => 1,      # When appropriate, generate 304: Not modified
    save_to => { directory => '/var/www/htdocs/save_to', ttl => 600, create_table => 1 },
    info => CGI::Info->new(),
    lingua => CGI::Lingua->new(),
});

Si no se proporciona ninguna clave_caché, se generará una que puede no ser única. La cache_key debe ser un valor único que dependa de los valores establecidos por el navegador.

El objeto de caché será un objeto que comprenda los mensajes get_object(), set(), remove() y create_at(), como un objeto CHI. Se utiliza como caché del lado del servidor para reducir la necesidad de volver a ejecutar los accesos a la base de datos.

Los elementos permanecen en la caché del servidor de forma predeterminada durante 10 minutos. Esto puede anularse mediante el encabezado HTTP cache_control en la solicitud, y el valor predeterminado se puede cambiar mediante el argumento cache_age a init().

Save_to es una característica que almacena la salida de páginas dinámicas en su árbol htdocs y reemplaza enlaces futuros que apuntan a esa página con enlaces estáticos para evitar pasar por CGI en absoluto. Ttl se establece en la cantidad de segundos que se considera que las páginas estáticas están activas; el valor predeterminado es 10 minutos. Si se establece en 0, la página estará activa para siempre. Para habilitar save_to, también se deben proporcionar argumentos de información y lengua. Funciona mejor cuando también se proporciona caché. Utilícelo únicamente cuando se garantice que la salida será la misma con un conjunto determinado de argumentos (los mismos criterios para habilitar generate_304). Puede desactivarlo caso por caso de la siguiente manera:

 my $params = CGI::Info->new()->params();
if($params->{'send_private_email'}) {
    $buffer->init('save_to' => undef);
}

Info es un argumento opcional para dar información sobre el entorno FCGI, por ejemplo, un objeto CGI::Info.

Logger será un objeto que comprenda debug() como un objeto Log::Log4perl.

Para generar un encabezado last_modified, debes proporcionar un objeto de caché.

Init permite pasar una referencia de las opciones. Entonces ambos funcionan: use FCGI::Buffer; #... mi $buffer = FCGI::Buffer->new(); $b->init(generate_etag => 1); $b->init({ generate_etag => 1, información => CGI::Info->new() });

En términos generales, pasar por referencia es mejor ya que se copia menos en la pila.

Si le da un caché a init() y luego le da cache => undef, el caché del lado del servidor ya no se usa. Esto es útil cuando encuentra una condición de error al crear su HTML y decide que ya no desea almacenar el resultado en el caché.

establecer_opciones

Sinónimo de init, conservado por motivos históricos.

can_cache

Devuelve verdadero si el servidor puede almacenar los resultados localmente. Este es el valor de X-Cache en el encabezado devuelto.

está_cached

Devuelve verdadero si la salida está almacenada en caché. Si es así, significa que todas las costosas rutinas del script FCGI se pueden omitir porque ya tenemos el resultado almacenado en la caché.

 # Put this toward the top of your program before you do anything

# Example key generation - use whatever you want as something
# unique for this call, so that subsequent calls with the same
# values match something in the cache
use CGI::Info;
use CGI::Lingua;
use FCGI::Buffer;

my $i = CGI::Info->new();
my $l = CGI::Lingua->new(supported => ['en']);

# To use server side caching you must give the cache argument, however
# the cache_key argument is optional - if you don't give one then one will
# be generated for you
my $buffer = FCGI::Buffer->new();
if($buffer->can_cache()) {
    $buffer->init(
        cache => CHI->new(driver => 'File'),
        cache_key => $i->domain_name() . '/' . $i->script_name() . '/' . $i->as_string() . '/' . $l->language()
    );
    if($buffer->is_cached()) {
        # Output will be retrieved from the cache and sent automatically
        exit;
    }
}
# Not in the cache, so now do our expensive computing to generate the
# results
print "Content-type: text/htmln";
# ...

AUTOR

Nigel Horne,

INSECTOS

FCGI::Buffer debería ser seguro incluso en scripts que producen muchos resultados diferentes, por ejemplo, situaciones de comercio electrónico. Sin embargo, en dichas páginas, recomiendo encarecidamente configurar generate_304 en 0 y enviar el encabezado HTTP "Cache-Control: no-cache".

Cuando utilice Plantilla, asegúrese de no utilizarla para generar salida a STDOUT; en su lugar, deberá capturarla en una variable e imprimirla. Por ejemplo:

 my $output;
$template->process($input, $vars, $output) || ($output = $template->error());
print $output;

Puede producir JavaScript con errores si utiliza la técnica