Lua - Programação Web

Lua é uma linguagem altamente flexível e frequentemente usada em várias plataformas, incluindo aplicativos da web. A comunidade Kepler que foi formada em 2004 para fornecer componentes da web de código aberto em Lua.

Mesmo assim, existem outros frameworks da web que usam Lua que foram desenvolvidos, vamos nos concentrar principalmente nos componentes fornecidos pela comunidade Kepler.

Aplicativos e frameworks

  • Orbit é um framework web MVC para Lua, baseado em WSAPI.

  • WSAPI é a API que abstrai o servidor de hospedagem da web de aplicativos da web Lua e é a base para muitos projetos.

  • Xavante é um servidor Lua Web que oferece uma interface WSAPI.

  • Sputnik é um wiki / CMS desenvolvido sobre WSAPI no Projeto Kepler usado para humor e entretenimento.

  • CGILuaoferece a criação de páginas da web LuaPages e LuaScripts, com base em WSAPI, mas não é mais compatível. Use Orbit, Sputnik ou WSAPI.

Neste tutorial, tentaremos fazer você entender o que Lua pode fazer e saber mais sobre sua instalação e uso, consulte o site kepler

Órbita

Orbit é um framework web MVC para Lua. Abandona completamente o modelo CGILua de "scripts" em favor de aplicativos, onde cada aplicativo Orbit pode caber em um único arquivo, mas você pode dividi-lo em vários arquivos se quiser.

Todos os aplicativos Orbit seguem o protocolo WSAPI, portanto, atualmente funcionam com Xavante, CGI e Fastcgi. Inclui um inicializador que facilita o lançamento de uma instância do Xavante para desenvolvimento.

A maneira mais fácil de instalar o Orbit é usando LuaRocks. Luarocks install orbit é o comando para instalar. Para isso, você precisa instalar o LuaRocks primeiro.

Se você não instalou todas as dependências, aqui estão os passos a serem seguidos para configurar o Orbit em ambiente Unix / Linux.

Instalando Apache

Conecte-se ao seu servidor. Instale o Apache2, seus módulos de suporte e habilite os módulos necessários do Apache2 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

Instale o LuaRocks

$ sudo apt-get install luarocks

Instale WSAPI, FCGI, Orbit e Xavante

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

Configurando Apache2

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

Adicione esta seção a seguir abaixo da seção <Directory / var / www /> do arquivo de configuração. Se esta seção tiver um 'AllowOverride None', então você precisa alterar o 'Nenhum' para 'All' para que o arquivo .htaccess possa substituir a configuração 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 o servidor para garantir que as alterações feitas tenham efeito.

Para habilitar seu aplicativo, você precisa adicionar + ExecCGI a um arquivo .htaccess na raiz do seu aplicativo Orbit - neste caso, / var / www.

Options +ExecCGI
DirectoryIndex index.ws

Exemplo Simples - Ó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

Agora, você deve conseguir iniciar o navegador da web. Vá para http: // localhost: 8080 / e você verá a seguinte saída -

First Page

O Orbit oferece outra opção, ou seja, o código Lua pode gerar 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())

Criação de formulários

Um exemplo de formulário simples é mostrado abaixo -

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

Conforme mencionado anteriormente, o WSAPI atua como a base para muitos projetos e possui vários recursos incorporados. Você pode usar WSAPI e oferecer suporte às seguintes plataformas,

  • Windows
  • Sistemas baseados em UNIX

Os servidores e interfaces suportados por WSAPI incluem,

  • CGI
  • FastCGI
  • Xavante

WSAPI fornece várias bibliotecas, o que torna mais fácil para nós na programação web usando Lua. Alguns dos recursos suportados em Lua incluem,

  • Solicitar processamento
  • Buffer de saída
  • Authentication
  • Uploads de arquivos
  • Solicitar isolamento
  • Multiplexing

Um exemplo simples de WSAPI é mostrado abaixo -

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

Você pode ver no código acima uma página html simples é formada e retornada. Você pode ver o uso de co-rotinas que torna possível retornar instrução por instrução para a função de chamada. Finalmente, o código de status html (200), os cabeçalhos e a página html são retornados.

Xavante

Xavante é um servidor Web Lua HTTP 1.1 que usa uma arquitetura modular baseada em manipuladores mapeados por URI. Xavante atualmente oferece,

  • Gerenciador de arquivos
  • Redirecionar manipulador
  • Manipulador WSAPI

O manipulador de arquivos é usado para arquivos gerais. O manipulador de redirecionamento permite o remapeamento de URI e o manipulador WSAPI para lidar com aplicativos WSAPI.

Um exemplo simples é mostrado abaixo.

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 virtuais com o Xavante, a chamada para xavante.HTTP seria alterada para algo como o seguinte -

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

Lua Web Components

  • Copas, um despachante baseado em corrotinas que podem ser usadas por servidores TCP / IP.

  • Cosmo, um mecanismo de "modelos seguros" que protege seu aplicativo de código arbitrário nos modelos.

  • Coxpcall encapsula Lua pcall e xpcall nativos com outros compatíveis com a corrotina.

  • LuaFileSystem, uma maneira portátil de acessar a estrutura de diretório subjacente e os atributos de arquivo.

  • Rings, uma biblioteca que fornece uma maneira de criar novos estados Lua a partir de Lua.

Nota Final

Existem tantos frameworks e componentes baseados em Lua disponíveis para nós e de acordo com a necessidade, eles podem ser escolhidos. Existem outras estruturas da web disponíveis, que incluem o seguinte -

  • Moonstalkpermite o desenvolvimento e hospedagem eficientes de projetos baseados na web gerados dinamicamente e construídos com a linguagem Lua; de páginas básicas a aplicativos complexos.

  • Lapis, um framework para construir aplicações web usando MoonScript (ou Lua) que roda dentro de uma versão customizada do Nginx chamada OpenResty.

  • Lua Server Pages, um plug-in de mecanismo de script Lua que elimina qualquer outra abordagem para o desenvolvimento da Web embarcado, oferece um atalho dramático para as páginas de servidor C tradicionais.

Essas estruturas da web podem alavancar seus aplicativos da web e ajudá-lo a realizar operações poderosas.