Lua - Programmation Web

Lua est un langage très flexible et il est souvent utilisé dans plusieurs plates-formes, y compris des applications Web. La communauté Kepler qui a été formée en 2004 pour fournir des composants Web open source dans Lua.

Même s'il existe d'autres frameworks Web utilisant Lua qui ont été développés, nous nous concentrerons principalement sur les composants fournis par la communauté Kepler.

Applications et cadres

Orbit est un framework Web MVC pour Lua, basé sur WSAPI.
WSAPI est l'API qui extrait le serveur hôte Web des applications Web Lua et constitue la base de nombreux projets.
Xavante est un serveur Web Lua qui offre une interface WSAPI.
Sputnik est un wiki / CMS développé sur WSAPI sur Kepler Project utilisé pour l'humour et le divertissement.
CGILuapropose la création de pages Web LuaPages et LuaScripts, basée sur WSAPI mais qui n'est plus prise en charge. Utilisez plutôt Orbit, Sputnik ou WSAPI.

Dans ce tutoriel, nous allons essayer de vous faire comprendre ce que Lua peut faire et pour en savoir plus sur son installation et son utilisation, référez-vous au site kepler

Orbite

Orbit est un framework Web MVC pour Lua. Il abandonne complètement le modèle CGILua des «scripts» au profit des applications, où chaque application Orbit peut tenir dans un seul fichier, mais vous pouvez le diviser en plusieurs fichiers si vous le souhaitez.

Toutes les applications Orbit suivent le protocole WSAPI, elles fonctionnent donc actuellement avec Xavante, CGI et Fastcgi. Il comprend un lanceur qui facilite le lancement d'une instance Xavante pour le développement.

Le moyen le plus simple d'installer Orbit est d'utiliser LuaRocks. Luarocks install orbit est la commande pour l'installation. Pour cela, vous devez d'abord installer LuaRocks .

Si vous n'avez pas installé toutes les dépendances, voici les étapes à suivre pour configurer Orbit dans un environnement Unix / Linux.

Installer Apache

Connectez-vous à votre serveur. Installez Apache2, ses modules de support et activez les modules Apache2 requis en utilisant -

$ sudo apt-get install apache2 libapache2-mod-fcgid libfcgi-dev build-essential
$ sudo a2enmod rewrite
$ sudo a2enmod fcgid
$ sudo /etc/init.d/apache2 force-reload

Installez LuaRocks

$ sudo apt-get install luarocks

Installez WSAPI, FCGI, Orbit et Xavante

$ sudo luarocks install orbit
$ sudo luarocks install wsapi-xavante
$ sudo luarocks install wsapi-fcgi

Configurer Apache2

$ sudo raj /etc/apache2/sites-available/default

Ajoutez cette section suivante sous la section <Directory / var / www /> du fichier de configuration. Si cette section a un 'AllowOverride None', vous devez changer le 'None' en 'All' afin que le fichier .htaccess puisse remplacer la configuration localement.

<IfModule mod_fcgid.c>

   AddHandler fcgid-script .lua
   AddHandler fcgid-script .ws
   AddHandler fcgid-script .op
	
   FCGIWrapper "/usr/local/bin/wsapi.fcgi" .ws
   FCGIWrapper "/usr/local/bin/wsapi.fcgi" .lua
   FCGIWrapper "/usr/local/bin/op.fcgi" .op
	
   #FCGIServer "/usr/local/bin/wsapi.fcgi" -idle-timeout 60 -processes 1
   #IdleTimeout 60
   #ProcessLifeTime 60
	
</IfModule>

Redémarrez le serveur pour vous assurer que les modifications apportées prennent effet.

Pour activer votre application, vous devez ajouter + ExecCGI à un fichier .htaccess à la racine de votre application Orbit - dans ce cas, / var / www.

Options +ExecCGI
DirectoryIndex index.ws

Exemple simple - Orbite

#!/usr/bin/env index.lua

-- index.lua
require"orbit"

-- declaration
module("myorbit", package.seeall, orbit.new)

-- handler

function index(web)
   return my_home_page()
end

-- dispatch
myorbit:dispatch_get(index, "/", "/index")

-- Sample page

function my_home_page()

   return [[
      <head></head>
      <html>
         <h2>First Page</h2>
      </html>
   ]]
	
end

Vous devriez maintenant pouvoir lancer votre navigateur Web. Accédez à http: // localhost: 8080 / et vous devriez voir la sortie suivante -

First Page

Orbit fournit une autre option, c'est-à-dire que le code Lua peut générer du HTML.

#!/usr/bin/env index.lua

-- index.lua
require"orbit"

function generate()
   return html {
      head{title "HTML Example"},
		
      body{
         h2{"Here we go again!"}
      }
   }
end

orbit.htmlify(generate)

print(generate())

Créer des formulaires

Un exemple de formulaire simple est présenté ci-dessous -

#!/usr/bin/env index.lua
require"orbit"

function wrap (inner)
   return html{ head(), body(inner) }
end

function test ()
   return wrap(form (H'table' {
      tr{td"First name",td( input{type = 'text', name='first'})},
      tr{td"Second name",td(input{type = 'text', name='second'})},
      tr{ td(input{type = 'submit', value = 'Submit!'}),
         td(input{type = 'submit',value = 'Cancel'})
      },
   }))
end

orbit.htmlify(wrap,test)

print(test())

WSAPI

Comme mentionné précédemment, WSAPI sert de base à de nombreux projets et intègre plusieurs fonctionnalités. Vous pouvez utiliser WSAPI et prendre en charge les plates-formes suivantes,

Windows
Systèmes basés sur UNIX

Les serveurs et interfaces pris en charge par WSAPI comprennent,

CGI
FastCGI
Xavante

WSAPI fournit un certain nombre de bibliothèques, ce qui nous facilite la tâche dans la programmation Web à l'aide de Lua. Certaines des fonctionnalités prises en charge dans Lua comprennent,

Traitement de la demande
Tampon de sortie
Authentication
Téléchargements de fichiers
Demander l'isolement
Multiplexing

Un exemple simple de WSAPI est présenté ci-dessous -

#!/usr/bin/env wsapi.cgi

module(..., package.seeall)
function run(wsapi_env)
   local headers = { ["Content-type"] = "text/html" }
   
   local function hello_text()
      coroutine.yield("<html><body>")
      coroutine.yield("<p&gtHello Wsapi!</p>")
      coroutine.yield("<p&gtPATH_INFO: " .. wsapi_env.PATH_INFO .. "</p>")
      coroutine.yield("<p&gtSCRIPT_NAME: " .. wsapi_env.SCRIPT_NAME .. "</p>")
      coroutine.yield("</body></html>")
   end

   return 200, headers, coroutine.wrap(hello_text)
end

Vous pouvez voir dans le code ci-dessus qu'une simple page html est formée et renvoyée. Vous pouvez voir l'utilisation des coroutines qui permet de renvoyer instruction par instruction à la fonction appelante. Enfin, le code d'état html (200), les en-têtes et la page html sont renvoyés.

Xavante

Xavante est un serveur Web Lua HTTP 1.1 qui utilise une architecture modulaire basée sur des gestionnaires mappés par URI. Xavante propose actuellement,

Gestionnaire de fichiers
Gestionnaire de redirection
Gestionnaire WSAPI

Le gestionnaire de fichiers est utilisé pour les fichiers généraux. Le gestionnaire de redirection active le remappage d'URI et le gestionnaire WSAPI pour la gestion des applications WSAPI.

Un exemple simple est présenté ci-dessous.

require "xavante.filehandler"
require "xavante.cgiluahandler"
require "xavante.redirecthandler"

-- Define here where Xavante HTTP documents scripts are located
local webDir = XAVANTE_WEB

local simplerules = {

   { -- URI remapping example
      match = "^[^%./]*/$",
      with = xavante.redirecthandler,
      params = {"index.lp"}
   }, 

   { -- cgiluahandler example
      match = {"%.lp$", "%.lp/.*$", "%.lua$", "%.lua/.*$" },
      with = xavante.cgiluahandler.makeHandler (webDir)
   },
    
   { -- filehandler example
      match = ".",
      with = xavante.filehandler,
      params = {baseDir = webDir}
   },
} 

xavante.HTTP{
   server = {host = "*", port = 8080},
    
   defaultHost = {
      rules = simplerules
   },
}

Pour utiliser des hôtes virtuels avec Xavante, l'appel à xavante.HTTP serait changé en quelque chose comme suit -

xavante.HTTP{
   server = {host = "*", port = 8080},
    
   defaultHost = {},
    
   virtualhosts = {
      ["www.sitename.com"] = simplerules
   }
}

Composants Web Lua

Copas, un répartiteur basé sur des coroutines utilisables par les serveurs TCP / IP.
Cosmo, un moteur de "modèles sûrs" qui protège votre application du code arbitraire dans les modèles.
Coxpcall encapsule pcall natif Lua et xpcall avec ceux compatibles coroutine.
LuaFileSystem, un moyen portable d'accéder à la structure de répertoires et aux attributs de fichier sous-jacents.
Rings, une bibliothèque qui fournit un moyen de créer de nouveaux états Lua à partir de Lua.

Note de fin

Il y a tellement de frameworks et de composants Web basés sur Lua disponibles pour nous et en fonction des besoins, ils peuvent être choisis. Il existe d'autres frameworks Web disponibles, notamment:

Moonstalkpermet le développement et l'hébergement efficaces de projets Web générés dynamiquement et construits avec le langage Lua; des pages basiques aux applications complexes.
Lapis, un framework pour créer des applications Web à l'aide de MoonScript (ou Lua) qui s'exécute dans une version personnalisée de Nginx appelée OpenResty.
Lua Server Pages, un plug-in de moteur de script Lua qui supprime toute autre approche du développement Web intégré, offre un raccourci spectaculaire vers les pages de serveur C traditionnelles.

Ces frameworks Web peuvent exploiter vos applications Web et vous aider à effectuer des opérations puissantes.