Lua - Programmazione Web

Lua è un linguaggio altamente flessibile ed è spesso utilizzato su più piattaforme, comprese le applicazioni web. La comunità Kepler che è stata costituita nel 2004 per fornire componenti web open source in Lua.

Anche se sono stati sviluppati altri framework web che utilizzano Lua, ci concentreremo principalmente sui componenti forniti dalla comunità Kepler.

Applicazioni e framework

Orbit è un framework web MVC per Lua, basato su WSAPI.
WSAPI è l'API che astrae il server host web dalle applicazioni web Lua ed è la base per molti progetti.
Xavante è un server Web Lua che offre un'interfaccia WSAPI.
Sputnik è un wiki / CMS sviluppato su WSAPI su Kepler Project usato per umorismo e intrattenimento.
CGILuaoffre la creazione di pagine web LuaPages e LuaScripts, basate su WSAPI ma non più supportate. Usa invece Orbit, Sputnik o WSAPI.

In questo tutorial cercheremo di farti capire cosa può fare Lua e per saperne di più sulla sua installazione e utilizzo, fai riferimento a kepler sul sito

Orbita

Orbit è un framework web MVC per Lua. Abbandona completamente il modello CGILua degli "script" a favore delle applicazioni, dove ogni applicazione Orbit può stare in un unico file, ma puoi dividerla in più file se vuoi.

Tutte le applicazioni Orbit seguono il protocollo WSAPI, quindi attualmente funzionano con Xavante, CGI e Fastcgi. Include un programma di avvio che semplifica l'avvio di un'istanza Xavante per lo sviluppo.

Il modo più semplice per installare Orbit è usare LuaRocks. Luarocks install orbit è il comando per l'installazione. Per questo, devi prima installare LuaRocks .

Se non hai installato tutte le dipendenze, ecco i passaggi da seguire per configurare Orbit in ambiente Unix / Linux.

Installazione di Apache

Connettiti al tuo server. Installa Apache2, i suoi moduli di supporto e abilita i moduli Apache2 richiesti 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

Installa LuaRocks

$ sudo apt-get install luarocks

Installa WSAPI, FCGI, Orbit e Xavante

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

Configurazione di Apache2

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

Aggiungere la seguente sezione sotto la sezione <Directory / var / www /> del file di configurazione. Se questa sezione ha un "AllowOverride Nessuno", è necessario modificare "Nessuno" in "Tutto" in modo che il file .htaccess possa sovrascrivere la configurazione 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>

Riavviare il server per assicurarsi che le modifiche apportate abbiano effetto.

Per abilitare la tua applicazione, devi aggiungere + ExecCGI a un file .htaccess nella root della tua applicazione Orbit - in questo caso, / var / www.

Options +ExecCGI
DirectoryIndex index.ws

Semplice esempio: orbita

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

Ora dovresti essere in grado di avviare il tuo browser web. Vai a http: // localhost: 8080 / e dovresti vedere il seguente output:

First Page

Orbit fornisce un'altra opzione, cioè il codice Lua può generare 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())

Creazione di moduli

Di seguito è mostrato un semplice esempio di modulo:

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

Come accennato in precedenza, WSAPI funge da base per molti progetti e dispone di più funzionalità incorporate. Puoi utilizzare WSAPI e supportare le seguenti piattaforme,

Windows
Sistemi basati su UNIX

I server e le interfacce supportati da WSAPI includono,

CGI
FastCGI
Xavante

WSAPI fornisce una serie di librerie, il che ci semplifica la programmazione web utilizzando Lua. Alcune delle funzionalità supportate in Lua includono,

Richiedi elaborazione
Buffering dell'output
Authentication
Caricamenti di file
Richiedi l'isolamento
Multiplexing

Di seguito è mostrato un semplice esempio di 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

Puoi vedere nel codice sopra che una semplice pagina html è formata e restituita. È possibile vedere l'utilizzo delle coroutine che consentono di restituire istruzione per istruzione alla funzione chiamante. Infine, vengono restituiti il codice di stato html (200), le intestazioni e la pagina html.

Xavante

Xavante è un server Web Lua HTTP 1.1 che utilizza un'architettura modulare basata su gestori mappati URI. Xavante attualmente offre,

Gestore di file
Gestore di reindirizzamento
Gestore WSAPI

Il gestore di file viene utilizzato per i file generali. Il gestore di reindirizzamento abilita la rimappatura degli URI e il gestore WSAPI per la gestione con le applicazioni WSAPI.

Di seguito viene mostrato un semplice esempio.

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

Per utilizzare host virtuali con Xavante, la chiamata a xavante.HTTP verrebbe modificata in qualcosa di simile al seguente:

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

Componenti Web Lua

Copas, un dispatcher basato su coroutine che può essere utilizzato dai server TCP / IP.
Cosmo, un motore di "modelli sicuri" che protegge la tua applicazione da codice arbitrario nei modelli.
Coxpcall incapsula pcall nativi di Lua e xpcall con quelli compatibili con coroutine.
LuaFileSystem, un modo portatile per accedere alla struttura della directory sottostante e agli attributi dei file.
Rings, una libreria che fornisce un modo per creare nuovi stati Lua dall'interno di Lua.

Nota finale

Ci sono così tanti framework e componenti web basati su Lua disponibili per noi e in base alle necessità, può essere scelto. Sono disponibili altri framework Web che includono quanto segue:

Moonstalkconsente lo sviluppo e l'hosting efficienti di progetti basati sul web generati dinamicamente realizzati con il linguaggio Lua; dalle pagine di base alle applicazioni complesse.
Lapis, un framework per la creazione di applicazioni web utilizzando MoonScript (o Lua) che gira all'interno di una versione personalizzata di Nginx chiamata OpenResty.
Lua Server Pages, un plug-in del motore di scripting Lua che elimina qualsiasi altro approccio allo sviluppo web incorporato, offre una scorciatoia drammatica alle tradizionali pagine del server C.

Questi framework web possono sfruttare le tue applicazioni web e aiutarti a svolgere operazioni potenti.

↰ Previous page Next page ↱