Lua - Programación web

Lua es un lenguaje muy flexible y a menudo se usa en múltiples plataformas, incluidas aplicaciones web. La comunidad de Kepler que se formó en 2004 para proporcionar componentes web de código abierto en Lua.

Aunque hay otros marcos web que utilizan Lua que se han desarrollado, nos centraremos principalmente en los componentes proporcionados por la comunidad de Kepler.

Aplicaciones y marcos

  • Orbit es un marco web MVC para Lua, basado en WSAPI.

  • WSAPI es la API que abstrae el servidor de alojamiento web de las aplicaciones web de Lua y es la base para muchos proyectos.

  • Xavante es un servidor web Lua que ofrece una interfaz WSAPI.

  • Sputnik es un wiki / CMS desarrollado sobre WSAPI en Kepler Project que se utiliza para el humor y el entretenimiento.

  • CGILuaofrece creación de páginas web LuaPages y LuaScripts, basadas en WSAPI pero que ya no son compatibles. Utilice Orbit, Sputnik o WSAPI en su lugar.

En este tutorial, intentaremos hacerle comprender lo que puede hacer Lua y para saber más sobre su instalación y uso, consulte kepler en el sitio web.

Orbita

Orbit es un marco web MVC para Lua. Abandona por completo el modelo CGILua de "scripts" en favor de las aplicaciones, donde cada aplicación de Orbit puede caber en un solo archivo, pero puede dividirlo en varios archivos si lo desea.

Todas las aplicaciones de Orbit siguen el protocolo WSAPI, por lo que actualmente funcionan con Xavante, CGI y Fastcgi. Incluye un lanzador que facilita el lanzamiento de una instancia de Xavante para su desarrollo.

La forma más sencilla de instalar Orbit es utilizando LuaRocks. Luarocks install orbit es el comando para la instalación. Para ello, primero debe instalar LuaRocks .

Si no ha instalado todas las dependencias, estos son los pasos a seguir para configurar Orbit en un entorno Unix / Linux.

Instalación de Apache

Conéctese a su servidor. Instale Apache2, sus módulos de soporte y habilite los módulos Apache2 requeridos usando -

$ 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

Instalar LuaRocks

$ sudo apt-get install luarocks

Instale WSAPI, FCGI, Orbit y Xavante

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

Configuración de Apache2

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

Agregue la siguiente sección debajo de la sección <Directory / var / www /> del archivo de configuración. Si esta sección tiene un 'AllowOverride None', entonces debe cambiar 'None' a 'All' para que el archivo .htaccess pueda anular la configuración localmente.

<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>

Reinicie el servidor para asegurarse de que los cambios realizados entren en vigor.

Para habilitar su aplicación, debe agregar + ExecCGI a un archivo .htaccess en la raíz de su aplicación Orbit, en este caso, / var / www.

Options +ExecCGI
DirectoryIndex index.ws

Ejemplo simple: órbita

#!/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

Ahora, debería poder iniciar su navegador web. Vaya a http: // localhost: 8080 / y debería ver el siguiente resultado:

First Page

Orbit ofrece otra opción, es decir, el código Lua puede generar 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())

Crear formularios

A continuación se muestra un ejemplo de formulario simple:

#!/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

Como se mencionó anteriormente, WSAPI actúa como base para muchos proyectos y tiene múltiples características integradas. Puede utilizar WSAPI y admitir las siguientes plataformas,

  • Windows
  • Sistemas basados ​​en UNIX

Los servidores e interfaces compatibles con WSAPI incluyen,

  • CGI
  • FastCGI
  • Xavante

WSAPI proporciona una serie de bibliotecas, lo que nos facilita la programación web con Lua. Algunas de las funciones admitidas en Lua incluyen,

  • Procesamiento de solicitudes
  • Almacenamiento en búfer de salida
  • Authentication
  • Cargas de archivos
  • Solicitar aislamiento
  • Multiplexing

A continuación, se muestra un ejemplo simple de WSAPI:

#!/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>Hello Wsapi!</p>")
      coroutine.yield("<p>PATH_INFO: " .. wsapi_env.PATH_INFO .. "</p>")
      coroutine.yield("<p>SCRIPT_NAME: " .. wsapi_env.SCRIPT_NAME .. "</p>")
      coroutine.yield("</body></html>")
   end

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

Puede ver en el código anterior que se forma y se devuelve una página html simple. Puede ver el uso de corrutinas que hace posible devolver instrucción por instrucción a la función de llamada. Finalmente, se devuelve el código de estado html (200), los encabezados y la página html.

Xavante

Xavante es un servidor web Lua HTTP 1.1 que utiliza una arquitectura modular basada en manejadores mapeados URI. Xavante ofrece actualmente,

  • Manejador de archivos
  • Controlador de redireccionamiento
  • Controlador WSAPI

El controlador de archivos se utiliza para archivos generales. El manejador de redireccionamiento habilita la reasignación de URI y el manejador WSAPI para administrar aplicaciones WSAPI.

A continuación se muestra un ejemplo sencillo.

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
   },
}

Para usar hosts virtuales con Xavante, la llamada a xavante.HTTP se cambiaría a algo como lo siguiente:

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

Componentes web de Lua

  • Copas, un despachador basado en corrutinas que pueden utilizar los servidores TCP / IP.

  • Cosmo, un motor de "plantillas seguras" que protege su aplicación de código arbitrario en las plantillas.

  • Coxpcall encapsula pcall y xpcall nativos de Lua con otros compatibles con la rutina.

  • LuaFileSystem, una forma portátil de acceder a la estructura de directorio subyacente y los atributos de archivo.

  • Rings, una biblioteca que proporciona una forma de crear nuevos estados Lua desde dentro de Lua.

Nota final

Hay tantos marcos y componentes web basados ​​en Lua disponibles para nosotros y, en función de la necesidad, se puede elegir. Hay otros marcos web disponibles que incluyen lo siguiente:

  • Moonstalkpermite el desarrollo y alojamiento eficiente de proyectos basados ​​en web generados dinámicamente y construidos con el lenguaje Lua; desde páginas básicas hasta aplicaciones complejas.

  • Lapis, un marco para crear aplicaciones web usando MoonScript (o Lua) que se ejecuta dentro de una versión personalizada de Nginx llamada OpenResty.

  • Lua Server Pages, un complemento del motor de secuencias de comandos de Lua que supera cualquier otro enfoque de desarrollo web integrado, ofrece un acceso directo espectacular a las páginas del servidor C tradicionales.

Estos marcos web pueden aprovechar sus aplicaciones web y ayudarlo a realizar operaciones poderosas.