Module Apache mod_lua

Configuration de base

La directive de base pour le chargement du module est

    LoadModule lua_module modules/mod_lua.so

mod_lua fournit un gestionnaire nommé lua-script qui peut être utilisé avec une directive AddHandler :

AddHandler lua-script .lua

Ceci aura pour effet de faire traiter les requêtes pour les fichiers dont l'extension est .lua par mod_lua en invoquant cette fonction de gestion de fichier.

Ecrire des gestionnaires

Dans l'API du serveur HTTP Apache, un gestionnaire est une sorte de point d'accroche (hook) spécifique responsable de la génération de la réponse. mod_proxy, mod_cgi et mod_status sont des exemples de modules comportant un gestionnaire.

mod_lua cherche toujours à invoquer une fonction Lua pour le gestionnaire, plutôt que de simplement évaluer le corps d'un script dans le style de CGI. Une fonction de gestionnaire se présente comme suit :

example.lua
-- exemple de gestionnaire

require "string"

--[[
     Il s'agit du nom de méthode par défaut pour les gestionnaires Lua ;
     voir les noms de fonctions optionnels dans la directive
     LuaMapHandler pour choisir un point d'entrée différent.
--]]
function handle(r)
    r.content_type = "text/plain"
    r:puts("Hello Lua World!\n")

    if r.method == 'GET' then
        for k, v in pairs( r:parseargs() ) do
            r:puts( string.format("%s: %s\n", k, v) )
         end
    elseif r.method == 'POST' then
        for k, v in pairs( r:parsebody() ) do
            r:puts( string.format("%s: %s\n", k, v) )
        end
	
    else
        r:puts("Unsupported HTTP method " .. r.method)
    end
end

Ce gestionnaire se contente d'afficher les arguments codés d'un uri ou d'un formulaire dans un page au format texte.

Cela signifie que vous pouvez (et êtes encouragé à) avoir plusieurs gestionnaires (ou points d'entrée, ou filtres) dans le même script.

Ecriture de fournisseurs d'autorisation

mod_authz_core fournit une interface d'autorisation de haut niveau bien plus facile à utiliser que dans les hooks correspondants. Le premier argument de la directive Require permet de spécifier le fournisseur d'autorisation à utiliser. Pour chaque directive Require, mod_authz_core appellera le fournisseur d'autorisation spécifié, le reste de la ligne constituant les paramètres. Le fournisseur considéré va alors vérifier les autorisations et fournir le résultat dans une valeur de retour.

En général, le fournisseur authz est appelé avant l'authentification. S'il doit connaître le nom d'utilisateur authentifié (ou si l'utilisateur est appelé à être authentifié), le fournisseur doit renvoyer apache2.AUTHZ_DENIED_NO_USER, ce qui va déclancher le processus d'authentification et un deuxième appel du fournisseur authz.

La fonction du fournisseur authz ci-dessous accepte deux arguments, une adresse IP et un nom d'utilisateur. Elle autorise l'accès dans le cas où la requête provient de l'adresse IP spécifiée, ou si l'utilisateur authentifié correspond au second argument :

authz_provider.lua


require 'apache2'

function authz_check_foo(r, ip, user)
    if r.useragent_ip == ip then
        return apache2.AUTHZ_GRANTED
    elseif r.user == nil then
        return apache2.AUTHZ_DENIED_NO_USER
    elseif r.user == user then
        return apache2.AUTHZ_GRANTED
    else
        return apache2.AUTHZ_DENIED
    end
end

La configuration suivante enregistre cette fonction en tant que fournisseur foo, et la configure por l'URL / :

LuaAuthzProvider foo authz_provider.lua authz_check_foo
<Location />
  Require foo 10.1.2.3 john_doe
</Location>

Ecriture de fonctions d'accroche (hooks)

Les fonctions d'accroche déterminent la manière dont les modules (et les scripts Lua) participent au traitement des requêtes. Chaque type d'accroche proposé par le serveur a un rôle spécifique, comme l'association de requêtes au système de fichiers, le contrôle d'accès, ou la définition de types MIME. Il existe aussi des accroches à usage général qui s'exécutent simplement à des moments opportuns du cycle de vie de la requête.

Les fonctions d'accroche acceptent l'objet de la requête comme seul et unique argument. Elles peuvent renvoyer une valeur, selon la fonction, mais il s'agit en général d'un code d'état HTTP ou des valeurs OK, DONE, ou DECLINED, que vous pouvez écrire dans lua sous la forme apache2.OK, apache2.DONE, ou apache2.DECLINED.

translate_name.lua
-- exemple d'accroche qui réécrit un URI en chemin du système de
fichiers.

require 'apache2'

function translate_name(r)
    if r.uri == "/translate-name" then
        r.filename = r.document_root .. "/find_me.txt"
        return apache2.OK
    end
    -- on ne gère pas cette URL et on donne sa chance à un autre module
    return apache2.DECLINED
end

translate_name2.lua
--[[ exemple d'accroche qui réécrit un URI vers un autre URI. Il renvoie
	un apache2.DECLINED pour permettre à un autre interpréteur d'URL de
	travailler sur la substitution, y compris l'accroche translate_name
	de base dont les tables de correspondances se basent sur DocumentRoot.

     Note: actuellement, il est impossible de prévoir si cette action
     s'exécute avant ou après mod_alias.
--]]

require 'apache2'

function translate_name(r)
    if r.uri == "/translate-name" then
        r.uri = "/find_me.txt"
        return apache2.DECLINED
    end
    return apache2.DECLINED
end

Structures de données

request_rec

request_rec est considérée en tant que donnée utilisateur. Elle possède une métatable qui vous permet d'accomplir des choses intéressantes. Pour la plus grande partie, elle possède les mêmes champs que la structure request_rec (voir httpd.h en attendant que cette documentation soit plus complète), la plupart d'entre eux étant accessibles en lecture et écriture (le contenu des champs de la table peut être modifié, mais les champs eux-mêmes ne peuvent pas être établis en tant que tables distinctes).

Nom	Type Lua	Modifiable
ap_auth_type	string	non
args	string	oui
assbackwards	boolean	non
canonical_filename	string	non
content_encoding	string	non
content_type	string	oui
context_prefix	string	non
context_document_root	string	non
document_root	string	non
err_headers_out	table	non
filename	string	oui
handler	string	oui
headers_in	table	oui
headers_out	table	oui
hostname	string	non
log_id	string	non
method	string	non
notes	table	oui
path_info	string	non
protocol	string	non
proxyreq	string	oui
range	string	non
subprocess_env	table	oui
status	number	oui
the_request	string	non
unparsed_uri	string	non
uri	string	oui
user	string	oui
useragent_ip	string	non

La structure request_rec possède (au minimum) les méthodes suivantes :

        r:addoutputfilter(name|function) -- ajoute un filtre en sortie
        

        r:parseargs() -- renvoie une table lua contenant la chaîne
	d'arguments de la requête
        

        r:parsebody()([sizeLimit]) -- interprète le corps de la requête
	en tant que POST et renvoie une table lua. Un nombre optionnel
	peut être fourni pour spécifier le nombre maximal d'octets à
	interpréter. La valeur par défaut est 8192.
        

        r:puts("bonjour", " le monde", "!") -- affichage dans le corps de la réponse
        

        r:write("une simple chaîne") -- affichage dans le
	corps de la réponse
        

	r:dbacquire(dbType[, dbParams]) -- Acquiert une connexion à une
base de données et renvoie une classe database. Voir 'Connectivité aux bases de données' pour plus de
détails.
        

Fonctions de journalisation

	-- exemples de messages de journalisation
	r:trace1("Ceci est un message de journalisation de niveau
	trace") -- les niveaux valides vont de trace1 à trace8 

        r:debug("Ceci est un message de journalisation de niveau debug")

        r:info("Ceci est un message de journalisation de niveau info")

        r:notice("Ceci est un message de journalisation de niveau notice")

        r:warn("Ceci est un message de journalisation de niveau warn")

        r:err("Ceci est un message de journalisation de niveau err")

        r:alert("Ceci est un message de journalisation de niveau alert")

        r:crit("Ceci est un message de journalisation de niveau crit")

        r:emerg("Ceci est un message de journalisation de niveau emerg")

Paquet apache2

Le paquet nommé apache2 est fourni avec (au minimum) le contenu suivant :

apache2.OK

Constante interne OK. Les gestionnaires renverront cette valeur s'ils ont traité la requête.

apache2.DECLINED

Constante interne DECLINED. Les gestionnaires renverront cette valeur s'ils n'ont pas l'intention de traiter la requête.

apache2.DONE

Constante interne DONE.

apache2.version

Chaîne contenant la version du serveur HTTP Apache

apache2.HTTP_MOVED_TEMPORARILY

Code d'état HTTP

apache2.PROXYREQ_NONE, apache2.PROXYREQ_PROXY, apache2.PROXYREQ_REVERSE, apache2.PROXYREQ_RESPONSE

Constantes internes utilisées par mod_proxy

Les autres codes d'état HTTP ne sont pas encore implémentés.

Connectivité aux bases de données

Mod_lua implémente une fonctionnalité basique de connexion aux bases de données permettant d'envoyer des requêtes ou d'exécuter des commandes auprès des moteurs de base de données les plus courants (mySQL, PostgreSQL, FreeTDS, ODBC, SQLite, Oracle), ainsi que mod_dbd.

L'exemple suivant montre comment se connecter à une base de données et extraire des informations d'une table :

function handler(r)
    -- connexion à la base de données
    local database, err = r:dbacquire("mysql", "server=localhost,user=root,dbname=mydb")
    if not err then
        -- Sélection de certaines informations
        local results, err = database:select(r, "SELECT `name`, `age` FROM `people` WHERE 1")
        if not err then
            local rows = results(0) -- extrait tous les enregistrements en mode synchrone
            for k, row in pairs(rows) do
                r:puts( string.format("Name: %s, Age: %s<br/>", row[1], row[2]) )
            end
        else
            r:puts("Database query error: " .. err)
        end
        database:close()
    else
        r:puts("Connexion à la base de données impossible : " .. err)
    end
end
    

Pour utiliser mod_dbd, spécifiez mod_dbd comme type de base de données, ou laissez le champ vide :

    local database = r:dbacquire("mod_dbd")
    

L'objet database et ses méthodes

L'objet database renvoyé par dbacquire possède les méthodes suivantes :

Sélection normale et requête vers une base de données :

-- Exécution d'une requête et renvoie du nombre d'enregistrements
affectés :
local affected, errmsg = database:query(r, "DELETE FROM `tbl` WHERE 1")

-- Exécution d'une requête et renvoie du résultat qui peut être utilisé
en mode synchrone ou asynchrone :
local result, errmsg = database:select(r, "SELECT * FROM `people` WHERE 1")
    

Utilisation de requêtes préparées (recommandé) :

-- Création et exécution d'une requête préparée :
local statement, errmsg = database:prepare(r, "DELETE FROM `tbl` WHERE `age` > %u")
if not errmsg then
    local result, errmsg = statement:query(20) -- exécute la requête pour age > 20
end

-- Extrait une requête préparée depuis une directive DBDPrepareSQL :
local statement, errmsg = database:prepared(r, "someTag")
if not errmsg then
    local result, errmsg = statement:select("John Doe", 123) -- injecte les valeurs "John Doe" et 123 dans la requête
end

Echappement de valeurs, fermeture de la base données, etc...

-- Echappe une valeur pour pouvoir l'utiliser dans une requête :
local escaped = database:escape(r, [["'|blabla]])

-- Ferme une base de données et libère les liens vers cette dernière :
database:close()

-- Vérifie si une connexion à une base de données est en service et
opérationnelle :
local connected = database:active()
    

Travail avec les jeux d'enregistrements renvoyés par les requêtes

Les jeux d'enregistrements renvoyés par db:select ou par des requêtes préparées créées par db:prepare permettent de sélectionner des enregistrements en mode synchrone ou asynchrone, selon le nombre d'enregistrements spécifié :
result(0) sélectionne tous les enregistrements en mode synchrone en renvoyant une table d'enregistrements.
result(-1) sélectionne le prochain enregistrement disponible en mode asynchrone.
result(N) sélectionne l'enregistrement numéro N en mode asynchrone.

-- extrait un jeu d'enregistrements via une requête régulière :
local result, err = db:select(r, "SELECT * FROM `tbl` WHERE 1")

local rows = result(0) -- sélectionne tous les enregistrements en mode synchrone
local row = result(-1) -- sélectionne le prochain enregistrement disponible en mode asynchrone
local row = result(1234) -- sélectionne l'enregistrement 1234 en mode asynchrone
    

Il est possible de construire une fonction qui renvoie une fonction itérative permettant de traiter tous les enregistrement en mode synchrone ou asynchrone selon la valeur de l'argument async :

function rows(resultset, async)
    local a = 0
    local function getnext()
        a = a + 1
        local row = resultset(-1)
        return row and a or nil, row
    end
    if not async then
        return pairs(resultset(0))
    else
        return getnext, self
    end
end

local statement, err = db:prepare(r, "SELECT * FROM `tbl` WHERE `age` > %u")
if not err then
     -- sélectionne des enregistrements en mode asynchrone :
    local result, err = statement:select(20)
    if not err then
        for index, row in rows(result, true) do
            ....
        end
    end

     -- sélectionne des enregistrements en mode synchrone :
    local result, err = statement:select(20)
    if not err then
        for index, row in rows(result, false) do
            ....
        end
    end
end
    

Fermeture d'une connexion à une base de données

Lorsqu'elles ne sont plus utilisées, les connexions aux bases de données doivent être fermées avec database:close(). Si vous ne les fermez pas manuellement, mod_lua les fermera peut-être en tant que résidus collectés, mais si ce n'est pas le cas, vous pouvez finir pas avoir trop de connexions vers la base de données inutilisées. Les deux mesures suivantes sont pratiquement identiques :

-- Méthode 1 : fermeture manuelle de la connexion
local database = r:dbacquire("mod_dbd")
database:close() -- c'est tout

-- Méthode 2 : on laisse le collecteur de résidus la fermer
local database = r:dbacquire("mod_dbd")
database = nil -- on coupe le lien
collectgarbage() -- fermeture de la connexion par le collecteur de résidus

Précautions à prendre lorsque l'on travaille avec les bases de données

Bien que les fonctions query et run soient toujours disponibles, il est recommandé d'utiliser des requêtes préparées chaque fois que possible, afin d'une part d'optimiser les performances (si votre connexion reste longtemps en vie), et d'autre part minimiser le risque d'attaques par injection SQL. Les fonctions run et query ne doivent être utilisées que lorsque la requête ne contient pas de variables (requête statique). Dans le cas des requêtes dynamiques, utilisez db:prepare ou db:prepared.